ЛР 2 — БВТ2304 — Санжаровский — на 4 #53
+23
-16
@@ -1,20 +1,27 @@
|
||||
# В образ попадает только то, что нужно рантайму. Всё лишнее исключаем:
|
||||
# уменьшает контекст сборки, ускоряет build и не даёт утечь .env/секретам.
|
||||
.git
|
||||
.github
|
||||
.gitignore
|
||||
.dockerignore
|
||||
Dockerfile
|
||||
Dockerfile.example
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets
|
||||
certs
|
||||
volumes
|
||||
data
|
||||
backups
|
||||
*.key
|
||||
*.pem
|
||||
*.p12
|
||||
*.pfx
|
||||
*.jks
|
||||
.venv
|
||||
__pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
.venv/
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
tests/
|
||||
student-tests/
|
||||
scripts/
|
||||
contracts/
|
||||
evidence/
|
||||
*.md
|
||||
.github/
|
||||
lab.json
|
||||
requirements-dev.txt
|
||||
compose.yaml
|
||||
compose.example.yaml
|
||||
examples/
|
||||
Makefile
|
||||
MAINTAINERS.md
|
||||
|
||||
+22
-7
@@ -1,11 +1,26 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
# Скопируйте в .env для ЛОКАЛЬНОГО учебного стенда; .env никогда не коммитится.
|
||||
# Пароль ниже — синтетический пример, задайте свой.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
|
||||
# PostgreSQL — источник истины (пользователи, чаты, сообщения, СЕССИИ).
|
||||
# Compose собирает из них DATABASE_URL. Вне compose можно задать
|
||||
# DATABASE_URL или DATABASE_URL_FILE=/run/secrets/database_url (файл приоритетнее).
|
||||
POSTGRES_DB=messenger
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=change-me-local-only
|
||||
|
||||
# Сессии: хранятся в PostgreSQL, Redis — только кэш (уровень 4).
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# CACHE_URL (или CACHE_URL_FILE) задаёт compose: redis://redis:6379/0. Пусто = без кэша.
|
||||
SESSION_CACHE_TTL_SECONDS=60
|
||||
|
||||
# Пул соединений и таймауты
|
||||
DB_POOL_MAX=10
|
||||
DB_POOL_TIMEOUT=3
|
||||
DB_STATEMENT_TIMEOUT_MS=5000
|
||||
REDIS_TIMEOUT=0.5
|
||||
|
||||
LOG_LEVEL=info
|
||||
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
# syntax=docker/dockerfile:1
|
||||
|
||||
# ---- Stage 1: builder: зависимости ставим отдельно, в рантайм несём только результат
|
||||
FROM python:3.12.7-slim-bookworm AS builder
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --prefix=/install -r requirements.txt
|
||||
|
||||
# ---- Stage 2: runtime
|
||||
FROM python:3.12.7-slim-bookworm AS runtime
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \
|
||||
APP_HOST=0.0.0.0 APP_PORT=8080 SHUTDOWN_TIMEOUT=10
|
||||
RUN useradd --create-home --uid 10001 appuser
|
||||
WORKDIR /app
|
||||
COPY --from=builder /install /usr/local
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
USER appuser
|
||||
EXPOSE 8080
|
||||
# /health/ready проверяет PostgreSQL: без БД контейнер станет unhealthy.
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
|
||||
CMD python -c "import os,urllib.request,sys; \
|
||||
u='http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready'; \
|
||||
sys.exit(0 if urllib.request.urlopen(u,timeout=2).status==200 else 1)" || exit 1
|
||||
# exec-форма: uvicorn — PID 1 и сам получает SIGTERM от docker stop.
|
||||
CMD ["python", "-m", "app"]
|
||||
@@ -1,37 +1,146 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Санжаровский, БВТ2304
|
||||
- Целевая оценка: **4** (трек 5 не заявлен)
|
||||
- Commit/PR: TODO после публикации (ветка `solution/bvt2304-sanzharovskiy`)
|
||||
- Источники и библиотеки: FastAPI, uvicorn, Pydantic, psycopg 3 + psycopg-pool, argon2-cffi, redis-py; документация PostgreSQL (transactions, EXPLAIN, индексы), Redis persistence, RFC 7617 (Basic), RFC 6750 (Bearer).
|
||||
- Помощь ИИ: Claude (Anthropic) помогал проектировать схему, писать код, тесты и отчёт. Все решения я разобрал и могу объяснить; результаты проверок получены реальными запусками (файлы в `evidence/`).
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужно: Docker Desktop (Compose v2), Python 3.9+ для тестов. Образы закреплены: `python:3.12.7-slim-bookworm`, `postgres:16.4-alpine`, `redis:7.4.1-alpine`; Python-зависимости закреплены в `requirements.txt`.
|
||||
|
||||
```sh
|
||||
cp .env.example .env # Windows: copy .env.example .env ; задать свой POSTGRES_PASSWORD
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
# миграции применяются автоматически при старте API (MIGRATE_ON_START=true);
|
||||
# вручную/повторно: docker compose --env-file .env exec api python -m app.migrate
|
||||
curl http://localhost:8080/health/ready # ждём {"status":"ok"}
|
||||
|
||||
make check
|
||||
make test # без make: python tests/smoke.py --base-url http://localhost:8080
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
# Windows: python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
python student-tests/run.py --base-url http://localhost:8080
|
||||
python student-tests/race.py --base-url http://localhost:8080
|
||||
python student-tests/outage.py --base-url http://localhost:8080
|
||||
python student-tests/logout_cache.py --base-url http://localhost:8080
|
||||
docker compose --env-file .env --profile ttl up -d api-ttl
|
||||
python student-tests/expiry.py --base-url http://localhost:8081
|
||||
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
|
||||
docker compose exec api python /tmp/rollback_check.py
|
||||
docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
|
||||
docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
|
||||
```
|
||||
|
||||
Остановка без потери данных: `docker compose --env-file .env down` (volume `pgdata` сохраняется).
|
||||
Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет volume `pgdata`, только осознанно).
|
||||
|
||||
Действий оператора, кроме создания `.env`, не требуется. `.env` и секреты в Git не попадают (`.gitignore`), в образ — тоже (`.dockerignore`).
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент ──HTTP──▶ api (FastAPI/uvicorn, без состояния)
|
||||
│ ограниченный пул psycopg (max 10), таймауты
|
||||
├──▶ postgres — ИСТОЧНИК ИСТИНЫ: users, chats, chat_members, messages, sessions
|
||||
│ volume pgdata, миграции migrations/NNNN_*.sql
|
||||
└──▶ redis — только КЭШ поиска сессии (ключ sess:<sha256(token)>, TTL)
|
||||
```
|
||||
|
||||
| Роль | Service | Версия | Health/readiness | Volume | Порт | Credentials |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| api | `api` | собирается из `Dockerfile` (multi-stage, non-root uid 10001) | `HEALTHCHECK` → `/health/ready` | нет (stateless) | `127.0.0.1:8080` | env из `.env` |
|
||||
| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | только внутренняя сеть | `POSTGRES_*` из `.env` |
|
||||
| redis | `redis` | `redis:7.4.1-alpine` | `redis-cli ping` | нет (кэш, persistence выключен) | только внутренняя сеть | без пароля, наружу не опубликован |
|
||||
| api-ttl | `api-ttl` (profile `ttl`) | тот же образ, `SESSION_TTL_SECONDS=2` | — | — | `127.0.0.1:8081` | — |
|
||||
|
||||
**Схема БД** (`migrations/0001_init.sql`): `users` (PK uuid, `username` UNIQUE + CHECK по шаблону, `password_hash`), `chats` (FK `created_by`), `chat_members` (PK `(chat_id,user_id)`, FK на chats ON DELETE CASCADE и на users, `position` для порядка участников), `messages` (FK на chat и sender, CHECK длины текста, индекс `(chat_id, created_at, id)`), `sessions` (PK `token_hash bytea`, FK user, `expires_at`, `revoked_at`).
|
||||
|
||||
**Миграции**: таблица `schema_migrations` + `pg_advisory_lock` (несколько API не применят миграцию дважды), каждый файл — в своей транзакции. Повторный запуск: `applied: nothing (up to date)`, данные не дублируются (`evidence/migrations.txt`).
|
||||
|
||||
**Транзакционные границы**: создание чата = `INSERT chats` + `INSERT chat_members` в одной транзакции (откат проверен `rollback_check.py`). Вход = проверка пароля + `INSERT sessions`. Сообщение — один `INSERT`. Регистрация защищена от гонки ограничением UNIQUE: проигравший получает 409.
|
||||
|
||||
**Аутентификация**: пароль — Argon2id (`argon2-cffi`, параметры библиотеки, своя соль у каждого хэша); для несуществующего пользователя проверяется хэш-заглушка, чтобы время ответа не выдавало существование username. `POST /api/v1/auth/sessions` принимает только `Basic` (без JSON), username ASCII, пароль UTF-8 12–128, двоеточие в пароле допустимо. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только SHA-256 от него. Все остальные endpoint — только `Bearer`; `X-User-Id` игнорируется. Аутентификация — FastAPI dependency, поэтому 401 возвращается раньше валидации тела. Доступ к чату проверяется отдельно (не участник → 404).
|
||||
|
||||
**Сессии и Redis (уровень 4)**:
|
||||
- Источник истины — таблица `sessions` в PostgreSQL. Срок задаёт `expires_at = now + SESSION_TTL_SECONDS`, рестарт его не продлевает.
|
||||
- Чтение Bearer: сначала Redis `sess:<sha256>`; промах → `SELECT … WHERE revoked_at IS NULL AND expires_at > now()` → запись в кэш.
|
||||
- Политика expiry кэша: TTL ключа = `min(SESSION_CACHE_TTL_SECONDS=60, время до expires_at)`, при чтении из кэша дополнительно сверяется `exp`. Кэш никогда не продлевает сессию.
|
||||
- Инвалидация (logout) атомарна для БД и кэша (`app/sessions.py`, `revoke`): в одной транзакции `UPDATE sessions SET revoked_at` и затем `DEL` ключа в Redis. Если Redis не ответил (остановлен, приостановлен, таймаут), транзакция откатывается и клиент получает `503 unavailable`: logout не подтверждён, сессия остаётся согласованной. `204` возвращается только когда отозвано и в БД, и в кэше, поэтому после `204` старый токен не принимается никогда, в том числе после восстановления Redis.
|
||||
- Гонка «параллельное чтение кладёт отозванную сессию в кэш после DEL» закрыта блокировкой: чтение сессии из БД идёт с `SELECT … FOR SHARE` и кладёт её в кэш, не отпуская строку; `UPDATE` в logout ждёт окончания такого чтения и удаляет ключ уже после него.
|
||||
- Redis недоступен / flush / рестарт → кэш обходится, всё читается из PostgreSQL; сессии не теряются. Поэтому Redis запущен без persistence (`--save "" --appendonly no`) — осознанно: он не единственное хранилище.
|
||||
- PostgreSQL недоступен → `503 unavailable` (обработчик `OperationalError`/`PoolTimeout`), `/health/ready` = 503, `/health/live` = 200. Неизвестный токен никогда не принимается.
|
||||
|
||||
**Пагинация**: keyset по `(created_at, id)`: `WHERE chat_id=$1 AND (created_at,id) > ($2,$3) ORDER BY created_at, id LIMIT limit+1`. Курсор — base64 JSON с привязкой к чату (курсор от другого чата → 400).
|
||||
|
||||
**Пул и таймауты**: `AsyncConnectionPool(min=1, max=DB_POOL_MAX=10)`, ожидание свободного соединения `DB_POOL_TIMEOUT=3 c`, `connect_timeout=3 c`, `statement_timeout=5000 мс`, Redis `socket_timeout=0.5 c`. Все запросы параметризованы (`%s`), SQL из пользовательских строк не собирается.
|
||||
|
||||
**Из lab1 перенесено**: формат ошибок `{"error":{code,message,request_id}}`, `X-Request-Id`, 422→400, `extra="forbid"`, graceful shutdown, multi-stage non-root Dockerfile. **Изменено**: хранилище в памяти + `threading.Lock` заменены PostgreSQL (конкурентность обеспечивают транзакции и ограничения БД), `X-User-Id` заменён на Basic → Bearer.
|
||||
|
||||
**Соответствие `.env.example` и реальной конфигурации**:
|
||||
|
||||
| Переменная skeleton | В решении |
|
||||
| --- | --- |
|
||||
| `APP_HOST`, `APP_PORT` | используются как есть |
|
||||
| `APP_ENV` | только метка, на поведение не влияет |
|
||||
| `SESSION_TTL_SECONDS` | срок сессии (`expires_at`) |
|
||||
| `DATABASE_URL_FILE` | поддерживается (приоритетнее `DATABASE_URL`); в compose `DATABASE_URL` собирается из `POSTGRES_*` |
|
||||
| `SESSION_STORE=postgres` | сессии всегда в PostgreSQL |
|
||||
| `CACHE_URL_FILE` | поддерживается, также `CACHE_URL` (в compose `redis://redis:6379/0`); пусто — кэш выключен |
|
||||
| дополнительно | `SESSION_CACHE_TTL_SECONDS`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT`, `DB_STATEMENT_TIMEOUT_MS`, `REDIS_TIMEOUT`, `MIGRATE_ON_START`, `LOG_LEVEL` |
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Стенд для приложенных файлов: 2 vCPU, 7 GiB RAM, Linux, Python 3.11, PostgreSQL 16, Redis 7; API на `127.0.0.1:8092`. На этом стенде Docker-образы скачать нельзя (нет доступа к registry), поэтому сервисы запущены процессами с теми же настройками, а restart-hook делал то же самое средствами `pg_ctl`/`redis-server`. На защите те же сценарии выполняются через `docker compose`.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | `make check`, `make validate`, `make test` | все три PASS | `evidence/smoke.txt` |
|
||||
| Данные и сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (`restart.sh`: `docker compose restart postgres redis api`, volumes не трогает) | PASS: тот же токен читает те же данные | `evidence/persistence.txt` |
|
||||
| Миграции с нуля и повторно | `python -m app.migrate` на пустой и на заполненной БД | `['0001_init']`, затем `nothing (up to date)`, число users не изменилось | `evidence/migrations.txt` |
|
||||
| PK/FK, UNIQUE username, атомарный чат | `migrations/0001_init.sql`; `rollback_check.py` | вставка неизвестного участника падает на FK, после отката `chats=0, members=0` | `evidence/rollback.txt` |
|
||||
| Basic только на `/auth/sessions`, Bearer, `X-User-Id` не даёт доступ | `student-tests/run.py` (раздел «аутентификация») | Basic на бизнес-endpoint → 401; `X-User-Id` → 401 и не подменяет владельца | `evidence/student-tests.txt` |
|
||||
| Неверный пароль, неизвестный user | `run.py` | одинаковый 401 + `WWW-Authenticate: Basic …` | `evidence/student-tests.txt` |
|
||||
| Logout | `run.py` | 204 → токен 401 → повторный logout 401 | `evidence/student-tests.txt` |
|
||||
| Logout при приостановленном Redis | `logout_cache.py` (прогрев кэша → `docker compose pause redis` → logout → `unpause` → старый токен) | logout не подтверждается (503, не 204); после восстановления повторный logout → 204, старый токен → 401. На версии до исправления: 204 и старый токен снова принимался | `evidence/logout-cache.txt` |
|
||||
| Тип содержимого | `run.py` (раздел «Content-Type») | корректный JSON с `text/plain` → 415 `unsupported_media_type`; без токена сначала 401; `application/json; charset=utf-8` принимается; битый JSON → 400 | `evidence/student-tests.txt` |
|
||||
| Expiry при коротком TTL | `expiry.py` против `api-ttl` (TTL=2) | `expires_at` ≈ +2 c; до истечения 200, после — 401 (кэш не продлил сессию) | `evidence/expiry.txt` |
|
||||
| Гонка регистрации одного username | `run.py`: 20 параллельных POST | ровно один 201 и девятнадцать 409 | `evidence/student-tests.txt` |
|
||||
| Конкурентная запись | `race.py`: 10 клиентов × 10 сообщений | 100 принято, 100 уникальных в истории | `evidence/student-tests.txt` |
|
||||
| Индекс истории + EXPLAIN на ≥10 000 | `student-tests/explain.sql` (60 000 сообщений, 12 000 в чате) | Index Scan, 4–5 буферов, ~0.1 мс; без индекса Seq Scan, 740 буферов, 6.8 мс | `evidence/explain.txt` |
|
||||
| Недоступность Redis/БД | `outage.py` | без Redis всё работает в обход кэша; без PostgreSQL 503, ready 503, live 200, аноним 401; после восстановления тот же токен работает | `evidence/outage.txt` |
|
||||
| Пул, таймауты, параметризованный SQL | `app/db.py`, `app/config.py`, `app/repo.py` | см. раздел «Архитектура» | — |
|
||||
| Секреты не в Git | `.gitignore`, `.dockerignore`, `.env.example` | `.env` не коммитится, токены в evidence не печатаются | — |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**EXPLAIN** (`evidence/explain.txt`). Гипотеза: составной индекс `(chat_id, created_at, id)` позволяет читать страницу истории за O(limit) независимо от её позиции, без сортировки. Данные: 60 000 сообщений в 10 чатах, в целевом — 12 000; `ANALYZE` перед замером; всё в транзакции с `ROLLBACK`.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| Запрос | План | Buffers | Время |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| первая страница (51 строка) | Index Scan `messages_chat_created_id_idx` | 4 | 0.03 мс |
|
||||
| страница из середины (keyset) | Index Scan, условие `ROW(created_at,id) > ROW(...)` в Index Cond | 5 | 0.09 мс |
|
||||
| та же страница с запрещённым индексом | Seq Scan + top-N sort, отброшено 54 001 строк | 740 | 6.8 мс |
|
||||
|
||||
Вывод: keyset-страница не читает предыдущие страницы (в отличие от OFFSET) и не сканирует всю таблицу. Цена — дополнительный индекс при записи.
|
||||
|
||||
**Нагрузка** (`evidence/load.json`): `tests/load.py --duration 15 --concurrency 4`, closed loop, POST сообщений, без прогрева: 6636 успешных, 0 ошибок, 439 RPS, p50 8.5 мс, p95 13.1 мс, p99 17.7 мс. Клиент на той же машине, есть coordinated omission, поэтому это не предел пропускной способности.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| рестарт API + PostgreSQL + Redis (volume сохранён) | данные и сессия на месте | PASS resilience, тот же токен работает | несколько секунд до ready; потерь нет |
|
||||
| остановка Redis | кэш обходится, сервис работает | `/users/me` 200, запись 201, вход 201, поддельный токен 401 | сразу; потерь нет (Redis — только кэш) |
|
||||
| остановка PostgreSQL | ограниченная ошибка, не зависание | 503, ready 503, live 200, аноним 401 | после старта БД ready 200, тот же токен читает историю |
|
||||
| истечение TTL (2 c) | 401 после срока | 401 + `WWW-Authenticate: Bearer` | — |
|
||||
| сбой посреди создания чата | откат целиком | `chats=0, members=0` | — |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Пока Redis недоступен, logout возвращает 503 и его нужно повторить после восстановления: так отзыв никогда не подтверждается без инвалидации кэша. Остальные операции в это время работают в обход кэша.
|
||||
- При недоступном PostgreSQL сессия из кэша ещё распознаётся, но любое действие с данными получает 503.
|
||||
- Durability: ответ 201 означает COMMIT в PostgreSQL с настройками по умолчанию (`synchronous_commit=on`, fsync). Реплик и бэкапов нет — отказ диска с volume означает потерю данных.
|
||||
- `created_at` назначает API по своим UTC-часам; при равных метках порядок задаёт `id`. При нескольких репликах (lab3) часы разных хостов могут расходиться.
|
||||
- Нет rate limiting на вход (перебор паролей замедляет только Argon2id). Нет TLS: HTTP только для локального стенда с синтетическими данными.
|
||||
- Трек 5 не выполнялся.
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
"""
|
||||
Точка входа контейнера: `python -m app`. Настройки — из окружения (app/config.py).
|
||||
uvicorn ловит SIGTERM: перестаёт принимать запросы и дожидается текущих
|
||||
(до SHUTDOWN_TIMEOUT), затем закрывает пул БД и соединение с Redis.
|
||||
"""
|
||||
import logging
|
||||
|
||||
import uvicorn
|
||||
|
||||
from .config import settings
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(level=settings.log_level.upper(),
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
||||
uvicorn.run(
|
||||
"app.main:app",
|
||||
host=settings.host,
|
||||
port=settings.port,
|
||||
timeout_graceful_shutdown=settings.shutdown_timeout,
|
||||
access_log=False, # свой лог в middleware: без query, токенов и тел
|
||||
log_level=settings.log_level,
|
||||
)
|
||||
@@ -0,0 +1,55 @@
|
||||
"""
|
||||
Конфигурация только из переменных окружения (ничего не зашито в код и образ).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import os
|
||||
from dataclasses import dataclass
|
||||
|
||||
|
||||
def _int(name: str, default: int) -> int:
|
||||
return int(os.getenv(name, str(default)))
|
||||
|
||||
|
||||
def _float(name: str, default: float) -> float:
|
||||
return float(os.getenv(name, str(default)))
|
||||
|
||||
|
||||
def _secret(name: str, default: str = "") -> str:
|
||||
"""Значение из NAME_FILE (Docker secret, файл) или из переменной NAME.
|
||||
Файл приоритетнее: так credentials не видны в `docker inspect`."""
|
||||
path = os.getenv(name + "_FILE")
|
||||
if path:
|
||||
with open(path, encoding="utf-8") as f:
|
||||
return f.read().strip()
|
||||
return os.getenv(name, default)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Settings:
|
||||
# HTTP
|
||||
host: str = os.getenv("APP_HOST", "0.0.0.0")
|
||||
port: int = _int("APP_PORT", 8080)
|
||||
shutdown_timeout: int = _int("SHUTDOWN_TIMEOUT", 10)
|
||||
log_level: str = os.getenv("LOG_LEVEL", "info")
|
||||
|
||||
# PostgreSQL — источник истины
|
||||
database_url: str = _secret(
|
||||
"DATABASE_URL", "postgresql://messenger:devpass@127.0.0.1:5432/messenger")
|
||||
db_pool_min: int = _int("DB_POOL_MIN", 1)
|
||||
db_pool_max: int = _int("DB_POOL_MAX", 10) # ограниченный пул
|
||||
db_pool_timeout: float = _float("DB_POOL_TIMEOUT", 3.0) # ждать свободное соединение
|
||||
db_connect_timeout: int = _int("DB_CONNECT_TIMEOUT", 3)
|
||||
db_statement_timeout_ms: int = _int("DB_STATEMENT_TIMEOUT_MS", 5000)
|
||||
migrate_on_start: bool = os.getenv("MIGRATE_ON_START", "true").lower() == "true"
|
||||
|
||||
# Сессии
|
||||
session_ttl_seconds: int = _int("SESSION_TTL_SECONDS", 3600)
|
||||
|
||||
# Redis/Valkey — кэш сессий (не источник истины). Пусто = кэш выключен.
|
||||
# Имя из skeleton — CACHE_URL(_FILE); REDIS_URL оставлено как синоним.
|
||||
redis_url: str = _secret("CACHE_URL") or _secret("REDIS_URL")
|
||||
redis_timeout: float = _float("REDIS_TIMEOUT", 0.5)
|
||||
session_cache_ttl_seconds: int = _int("SESSION_CACHE_TTL_SECONDS", 60)
|
||||
|
||||
|
||||
settings = Settings()
|
||||
@@ -0,0 +1,50 @@
|
||||
"""
|
||||
Пул соединений с PostgreSQL.
|
||||
|
||||
- Пул ограничен (DB_POOL_MAX): при нагрузке запросы ждут свободное соединение
|
||||
не дольше DB_POOL_TIMEOUT, а не открывают соединения без предела.
|
||||
- connect_timeout и statement_timeout: зависший запрос или недоступная БД
|
||||
не держат обработчик бесконечно — клиент получает 503.
|
||||
- Все запросы параметризованы (%s), SQL-инъекция невозможна.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
from psycopg_pool import AsyncConnectionPool
|
||||
|
||||
from .config import settings
|
||||
|
||||
pool: AsyncConnectionPool | None = None
|
||||
|
||||
|
||||
def make_pool() -> AsyncConnectionPool:
|
||||
return AsyncConnectionPool(
|
||||
conninfo=settings.database_url,
|
||||
min_size=settings.db_pool_min,
|
||||
max_size=settings.db_pool_max,
|
||||
timeout=settings.db_pool_timeout,
|
||||
kwargs={
|
||||
"connect_timeout": settings.db_connect_timeout,
|
||||
"options": f"-c statement_timeout={settings.db_statement_timeout_ms}",
|
||||
"application_name": "messenger-api",
|
||||
},
|
||||
# Перед выдачей соединение проверяется (SELECT 1 на уровне протокола):
|
||||
# после рестарта PostgreSQL «мёртвые» соединения отбрасываются, а не дают 503.
|
||||
check=AsyncConnectionPool.check_connection,
|
||||
open=False,
|
||||
)
|
||||
|
||||
|
||||
async def open_pool() -> None:
|
||||
global pool
|
||||
pool = make_pool()
|
||||
# wait=False: API стартует, даже если БД ещё поднимается; /health/ready это покажет.
|
||||
await pool.open(wait=False)
|
||||
|
||||
|
||||
async def close_pool() -> None:
|
||||
if pool is not None:
|
||||
await pool.close()
|
||||
|
||||
|
||||
def get_pool() -> AsyncConnectionPool:
|
||||
assert pool is not None, "pool is not opened"
|
||||
return pool
|
||||
+376
@@ -0,0 +1,376 @@
|
||||
"""
|
||||
HTTP-слой мессенджера (lab2).
|
||||
|
||||
Клиент → HTTP API (этот файл) → PostgreSQL (источник истины)
|
||||
↘ Redis/Valkey (кэш сессий, необязательный)
|
||||
|
||||
Что изменилось относительно lab1:
|
||||
* регистрация принимает password, хранится только Argon2id-хэш;
|
||||
* вход: POST /api/v1/auth/sessions с Authorization: Basic → Bearer-токен;
|
||||
* все бизнес-запросы требуют Authorization: Bearer; X-User-Id игнорируется;
|
||||
* данные и действующие сессии лежат в PostgreSQL и переживают рестарт.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import base64
|
||||
import binascii
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import psycopg
|
||||
from fastapi import Depends, FastAPI, Query, Request
|
||||
from fastapi.concurrency import run_in_threadpool
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg_pool import PoolTimeout
|
||||
from pydantic import BaseModel, field_validator
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from . import db, repo, security, sessions
|
||||
from .config import settings
|
||||
from .migrate import migrate
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
if settings.migrate_on_start:
|
||||
try:
|
||||
applied = await migrate()
|
||||
logger.info("migrations: %s", applied or "up to date")
|
||||
except psycopg.OperationalError as exc:
|
||||
# БД ещё не готова: API всё равно стартует, /health/ready покажет 503.
|
||||
logger.warning("migrations skipped, database unavailable: %s", type(exc).__name__)
|
||||
await db.open_pool()
|
||||
sessions.init_redis()
|
||||
yield
|
||||
await sessions.close_redis()
|
||||
await db.close_pool()
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger — lab2", lifespan=lifespan)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# 1. ЕДИНЫЙ ФОРМАТ ОШИБОК {"error":{"code","message","request_id"}}
|
||||
# ============================================================================
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status: int, code: str, message: str, headers: dict | None = None):
|
||||
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
|
||||
|
||||
|
||||
def error_response(request: Request, status: int, code: str, message: str,
|
||||
headers: dict | None = None) -> JSONResponse:
|
||||
rid = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
return JSONResponse(
|
||||
status_code=status,
|
||||
content={"error": {"code": code, "message": message, "request_id": rid}},
|
||||
headers={"X-Request-Id": rid, **(headers or {})},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(ApiError)
|
||||
async def handle_api_error(request: Request, exc: ApiError):
|
||||
return error_response(request, exc.status, exc.code, exc.message, exc.headers)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def handle_validation(request: Request, exc: RequestValidationError):
|
||||
return error_response(request, 400, "invalid_request", "invalid request body or parameters")
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def handle_http(request: Request, exc: StarletteHTTPException):
|
||||
# Только коды из enum контракта (contracts/openapi.json → Error.code).
|
||||
code = {401: "unauthorized", 404: "not_found", 409: "conflict",
|
||||
413: "payload_too_large", 415: "unsupported_media_type",
|
||||
429: "rate_limited", 503: "unavailable"}.get(
|
||||
exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request")
|
||||
return error_response(request, exc.status_code, code, str(exc.detail))
|
||||
|
||||
|
||||
@app.exception_handler(psycopg.OperationalError)
|
||||
@app.exception_handler(PoolTimeout)
|
||||
async def handle_db_down(request: Request, exc: Exception):
|
||||
# БД недоступна или не ответила за таймаут: ограниченная ошибка, а не зависание.
|
||||
logger.warning("database unavailable: %s", type(exc).__name__)
|
||||
return error_response(request, 503, "unavailable", "service temporarily unavailable")
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def handle_unexpected(request: Request, exc: Exception):
|
||||
logger.exception("unexpected error")
|
||||
return error_response(request, 500, "internal_error", "internal error")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# 2. X-Request-Id + лог без тела запроса, токенов и паролей
|
||||
# ============================================================================
|
||||
@app.middleware("http")
|
||||
async def add_request_id(request: Request, call_next):
|
||||
rid = str(uuid.uuid4())
|
||||
request.state.request_id = rid
|
||||
start = time.monotonic()
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = rid
|
||||
logger.info("rid=%s %s %s -> %s %sms", rid, request.method, request.url.path,
|
||||
response.status_code, round((time.monotonic() - start) * 1000, 1))
|
||||
return response
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# 3. АУТЕНТИФИКАЦИЯ
|
||||
# Bearer — для всех бизнес-запросов. Basic — только на POST /auth/sessions.
|
||||
# X-User-Id больше ничего не значит и ни на что не влияет.
|
||||
# ============================================================================
|
||||
def unauthorized(message: str = "invalid or missing bearer token") -> ApiError:
|
||||
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": BEARER_CHALLENGE})
|
||||
|
||||
|
||||
def _bearer_token(request: Request) -> str:
|
||||
auth = request.headers.get("authorization", "")
|
||||
scheme, _, token = auth.partition(" ")
|
||||
token = token.strip()
|
||||
if scheme.lower() != "bearer" or not token or len(token) > 512:
|
||||
raise unauthorized()
|
||||
return token
|
||||
|
||||
|
||||
async def current_user(request: Request) -> dict:
|
||||
"""Зависимость FastAPI: выполняется ДО разбора тела → сначала 401, потом 400."""
|
||||
token = _bearer_token(request)
|
||||
user = await sessions.resolve(db.get_pool(), token, repo.get_user)
|
||||
if user is None:
|
||||
raise unauthorized()
|
||||
request.state.token = token
|
||||
return user
|
||||
|
||||
|
||||
def _parse_basic(request: Request) -> tuple[str, str]:
|
||||
bad = ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
scheme, _, value = request.headers.get("authorization", "").partition(" ")
|
||||
if scheme.lower() != "basic" or not value:
|
||||
raise bad
|
||||
try:
|
||||
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError):
|
||||
raise bad
|
||||
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
|
||||
if not sep or not username.isascii() or not (12 <= len(password) <= 128):
|
||||
raise bad
|
||||
return username, password
|
||||
|
||||
|
||||
def require_json(request: Request) -> None:
|
||||
"""Тип тела проверяем ДО валидации тела: не JSON → 415, а не 400.
|
||||
Подключается после current_user, поэтому без токена по-прежнему сначала 401.
|
||||
Параметры вроде '; charset=utf-8' допустимы."""
|
||||
media_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
|
||||
if media_type != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Content-Type must be application/json")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# 4. МОДЕЛИ ВВОДА
|
||||
# ============================================================================
|
||||
class CreateUser(BaseModel):
|
||||
model_config = {"extra": "forbid"}
|
||||
username: str
|
||||
display_name: str
|
||||
password: str
|
||||
|
||||
@field_validator("username")
|
||||
@classmethod
|
||||
def check_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 check_display_name(cls, v: str) -> str:
|
||||
if not (1 <= len(v) <= 100) or not v.strip():
|
||||
raise ValueError("display_name must be 1..100 non-blank chars")
|
||||
return v
|
||||
|
||||
@field_validator("password")
|
||||
@classmethod
|
||||
def check_password(cls, v: str) -> str:
|
||||
if not (12 <= len(v) <= 128) or not v.strip():
|
||||
raise ValueError("password must be 12..128 chars")
|
||||
return v
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = {"extra": "forbid"}
|
||||
title: str
|
||||
member_ids: list[str]
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def check_title(cls, v: str) -> str:
|
||||
if not (1 <= len(v) <= 100) or not v.strip():
|
||||
raise ValueError("title must be 1..100 non-blank chars")
|
||||
return v
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = {"extra": "forbid"}
|
||||
text: str
|
||||
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def check_text(cls, v: str) -> str:
|
||||
if not (1 <= len(v) <= 4000) or not v.strip():
|
||||
raise ValueError("text must be 1..4000 non-blank chars")
|
||||
return v
|
||||
|
||||
|
||||
def parse_uuid(value: str, what: str) -> uuid.UUID:
|
||||
try:
|
||||
return uuid.UUID(value)
|
||||
except ValueError:
|
||||
raise ApiError(400, "invalid_request", f"{what} is not a valid uuid")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# 5. ENDPOINTS
|
||||
# ============================================================================
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready(request: Request):
|
||||
# Критичная зависимость — только PostgreSQL. Redis — кэш: его отказ не делает API неготовым.
|
||||
try:
|
||||
async with db.get_pool().connection() as conn:
|
||||
await conn.execute("SELECT 1 FROM schema_migrations LIMIT 1")
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
return error_response(request, 503, "unavailable", "database is not ready")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
# -------- users и сессии --------
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def create_user(body: CreateUser, _json: None = Depends(require_json)):
|
||||
# Argon2 намеренно медленный — считаем в пуле потоков, чтобы не блокировать event loop.
|
||||
password_hash = await run_in_threadpool(security.hash_password, body.password)
|
||||
async with db.get_pool().connection() as conn:
|
||||
try:
|
||||
return await repo.create_user(conn, body.username, body.display_name, password_hash)
|
||||
except repo.UsernameTaken:
|
||||
raise ApiError(409, "conflict", "username already taken")
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def create_session(request: Request):
|
||||
username, password = _parse_basic(request)
|
||||
async with db.get_pool().connection() as conn:
|
||||
row = await repo.get_credentials(conn, username)
|
||||
stored_hash = row[4] if row else None
|
||||
# Проверяем хэш даже для несуществующего пользователя — одинаковое время ответа.
|
||||
ok = await run_in_threadpool(security.verify_password, stored_hash, password)
|
||||
if not ok:
|
||||
raise ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
user = repo.user_out(row)
|
||||
async with db.get_pool().connection() as conn:
|
||||
if security.needs_rehash(stored_hash):
|
||||
await repo.update_password_hash(conn, row[0], await run_in_threadpool(security.hash_password, password))
|
||||
token, expires_at = await sessions.create_session(conn, row[0])
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": repo.iso(expires_at), "user": user}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def delete_session(request: Request, user: dict = Depends(current_user)):
|
||||
try:
|
||||
revoked = await sessions.revoke(db.get_pool(), request.state.token)
|
||||
except sessions.CacheUnavailable:
|
||||
# 204 только при гарантированном отзыве; иначе ограниченная ошибка, повторить позже.
|
||||
raise ApiError(503, "unavailable", "session cache unavailable, logout not confirmed")
|
||||
if not revoked:
|
||||
raise unauthorized()
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
async def get_me(user: dict = Depends(current_user)):
|
||||
return user
|
||||
|
||||
|
||||
# -------- chats --------
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(body: CreateChat, user: dict = Depends(current_user),
|
||||
_json: None = Depends(require_json)):
|
||||
members = body.member_ids
|
||||
if not (1 <= len(members) <= 100):
|
||||
raise ApiError(400, "invalid_request", "member_ids must have 1..100 items")
|
||||
if len(set(members)) != len(members):
|
||||
raise ApiError(400, "invalid_request", "duplicate member_ids")
|
||||
ids = [parse_uuid(m, "member id") for m in members]
|
||||
if uuid.UUID(user["id"]) not in ids:
|
||||
raise ApiError(400, "invalid_request", "caller must be a member")
|
||||
async with db.get_pool().connection() as conn:
|
||||
# Одна транзакция: чат и все участники создаются вместе или не создаются вовсе.
|
||||
async with conn.transaction():
|
||||
if await repo.count_existing_users(conn, ids) != len(ids):
|
||||
raise ApiError(400, "invalid_request", "unknown member")
|
||||
return await repo.insert_chat(conn, body.title, ids, user["id"])
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(user: dict = Depends(current_user),
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: str | None = Query(default=None, min_length=1)):
|
||||
async with db.get_pool().connection() as conn:
|
||||
try:
|
||||
items, nxt = await repo.list_chats(conn, user["id"], limit, cursor)
|
||||
except ValueError:
|
||||
raise ApiError(400, "invalid_request", "bad cursor")
|
||||
return {"items": items, "next_cursor": nxt}
|
||||
|
||||
|
||||
async def accessible_chat(conn, chat_id: str, user: dict) -> dict:
|
||||
"""Кривой UUID → 400. Чата нет ИЛИ ты не участник → одинаковый 404."""
|
||||
cid = parse_uuid(chat_id, "chat_id")
|
||||
chat = await repo.get_chat_for_member(conn, cid, user["id"])
|
||||
if chat is None:
|
||||
raise ApiError(404, "not_found", "chat not found")
|
||||
return chat
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: str, user: dict = Depends(current_user)):
|
||||
async with db.get_pool().connection() as conn:
|
||||
return await accessible_chat(conn, chat_id, user)
|
||||
|
||||
|
||||
# -------- messages --------
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def send_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user),
|
||||
_json: None = Depends(require_json)):
|
||||
async with db.get_pool().connection() as conn:
|
||||
chat = await accessible_chat(conn, chat_id, user)
|
||||
# Отправитель — из сессии, а не из тела запроса.
|
||||
return await repo.insert_message(conn, chat["id"], user["id"], body.text)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: str, user: dict = Depends(current_user),
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: str | None = Query(default=None, min_length=1)):
|
||||
async with db.get_pool().connection() as conn:
|
||||
chat = await accessible_chat(conn, chat_id, user)
|
||||
try:
|
||||
items, nxt = await repo.list_messages(conn, chat["id"], limit, cursor)
|
||||
except ValueError:
|
||||
raise ApiError(400, "invalid_request", "bad cursor")
|
||||
return {"items": items, "next_cursor": nxt}
|
||||
@@ -0,0 +1,57 @@
|
||||
"""
|
||||
Версионируемые миграции: migrations/NNNN_name.sql.
|
||||
|
||||
- Таблица schema_migrations хранит применённые версии → повторный запуск
|
||||
ничего не дублирует (идемпотентно).
|
||||
- Каждая миграция применяется в своей транзакции: либо целиком, либо никак.
|
||||
- pg_advisory_lock: если стартуют несколько API одновременно, миграции
|
||||
выполнит только один, остальные подождут.
|
||||
|
||||
Запуск вручную: python -m app.migrate
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import asyncio
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
|
||||
from .config import settings
|
||||
|
||||
log = logging.getLogger("messenger.migrate")
|
||||
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
|
||||
LOCK_ID = 824_113_2026 # произвольная константа для advisory lock
|
||||
|
||||
|
||||
async def migrate(conninfo: str | None = None) -> list[str]:
|
||||
applied_now: list[str] = []
|
||||
async with await psycopg.AsyncConnection.connect(
|
||||
conninfo or settings.database_url,
|
||||
connect_timeout=settings.db_connect_timeout, autocommit=True) as conn:
|
||||
await conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
|
||||
try:
|
||||
await conn.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations ("
|
||||
" version text PRIMARY KEY,"
|
||||
" applied_at timestamptz NOT NULL DEFAULT now())")
|
||||
cur = await conn.execute("SELECT version FROM schema_migrations")
|
||||
done = {row[0] for row in await cur.fetchall()}
|
||||
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
|
||||
version = path.stem
|
||||
if version in done:
|
||||
continue
|
||||
async with conn.transaction():
|
||||
await conn.execute(path.read_text(encoding="utf-8"))
|
||||
await conn.execute(
|
||||
"INSERT INTO schema_migrations (version) VALUES (%s)", (version,))
|
||||
applied_now.append(version)
|
||||
log.info("migration applied: %s", version)
|
||||
finally:
|
||||
await conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
|
||||
return applied_now
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
result = asyncio.run(migrate())
|
||||
print("applied:", result or "nothing (up to date)")
|
||||
+176
@@ -0,0 +1,176 @@
|
||||
"""
|
||||
Доступ к данным в PostgreSQL. Только параметризованные запросы (%s):
|
||||
значения передаются отдельно от текста SQL, инъекция невозможна.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from psycopg.errors import UniqueViolation
|
||||
|
||||
|
||||
def iso(dt: datetime) -> str:
|
||||
"""RFC 3339 UTC с Z — формат контракта."""
|
||||
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def now() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- курсор
|
||||
def encode_cursor(scope: str, created_at: datetime, id_) -> str:
|
||||
raw = json.dumps({"s": scope, "c": iso(created_at), "i": str(id_)}).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode()
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, scope: str) -> tuple[datetime, uuid.UUID]:
|
||||
"""(created_at, id) последнего показанного элемента или ValueError → 400."""
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()))
|
||||
if data.get("s") != scope:
|
||||
raise ValueError("cursor scope mismatch")
|
||||
return datetime.fromisoformat(data["c"].replace("Z", "+00:00")), uuid.UUID(data["i"])
|
||||
except (ValueError, KeyError, TypeError, AttributeError) as exc:
|
||||
raise ValueError("bad cursor") from exc
|
||||
|
||||
|
||||
def _page(rows: list, limit: int, scope: str, key):
|
||||
"""rows получены с LIMIT limit+1: лишняя строка = есть следующая страница."""
|
||||
has_more = len(rows) > limit
|
||||
page = rows[:limit]
|
||||
next_cursor = encode_cursor(scope, *key(page[-1])) if has_more and page else None
|
||||
return page, next_cursor
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- users
|
||||
USER_COLS = "id, username, display_name, created_at"
|
||||
|
||||
|
||||
def user_out(row) -> dict:
|
||||
return {"id": str(row[0]), "username": row[1], "display_name": row[2], "created_at": iso(row[3])}
|
||||
|
||||
|
||||
class UsernameTaken(Exception):
|
||||
pass
|
||||
|
||||
|
||||
async def create_user(conn, username: str, display_name: str, password_hash: str) -> dict:
|
||||
try:
|
||||
cur = await conn.execute(
|
||||
f"INSERT INTO users (id, username, display_name, password_hash, created_at) "
|
||||
f"VALUES (%s, %s, %s, %s, %s) RETURNING {USER_COLS}",
|
||||
(uuid.uuid4(), username, display_name, password_hash, now()))
|
||||
except UniqueViolation as exc:
|
||||
# Уникальность username гарантирует БД, а не проверка «есть ли такой»
|
||||
# перед вставкой: две одновременные регистрации не пройдут обе.
|
||||
raise UsernameTaken() from exc
|
||||
return user_out(await cur.fetchone())
|
||||
|
||||
|
||||
async def get_user(conn, user_id) -> dict | None:
|
||||
cur = await conn.execute(f"SELECT {USER_COLS} FROM users WHERE id = %s", (user_id,))
|
||||
row = await cur.fetchone()
|
||||
return user_out(row) if row else None
|
||||
|
||||
|
||||
async def get_credentials(conn, username: str):
|
||||
cur = await conn.execute(
|
||||
f"SELECT {USER_COLS}, password_hash FROM users WHERE username = %s", (username,))
|
||||
return await cur.fetchone()
|
||||
|
||||
|
||||
async def update_password_hash(conn, user_id, password_hash: str) -> None:
|
||||
await conn.execute("UPDATE users SET password_hash = %s WHERE id = %s", (password_hash, user_id))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- chats
|
||||
CHAT_SELECT = (
|
||||
"SELECT c.id, c.title, c.created_at, "
|
||||
" (SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) "
|
||||
"FROM chats c ")
|
||||
|
||||
|
||||
def chat_out(row) -> dict:
|
||||
return {"id": str(row[0]), "title": row[1],
|
||||
"member_ids": [str(x) for x in row[3]], "created_at": iso(row[2])}
|
||||
|
||||
|
||||
async def count_existing_users(conn, ids: list[uuid.UUID]) -> int:
|
||||
cur = await conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (ids,))
|
||||
return (await cur.fetchone())[0]
|
||||
|
||||
|
||||
async def insert_chat(conn, title: str, member_ids: list[uuid.UUID], creator) -> dict:
|
||||
"""Чат + все участники. Вызывать внутри транзакции: либо всё, либо ничего."""
|
||||
chat_id, created = uuid.uuid4(), now()
|
||||
await conn.execute(
|
||||
"INSERT INTO chats (id, title, created_by, created_at) VALUES (%s, %s, %s, %s)",
|
||||
(chat_id, title, creator, created))
|
||||
async with conn.cursor() as cur:
|
||||
await cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||||
[(chat_id, uid, pos) for pos, uid in enumerate(member_ids)])
|
||||
return {"id": str(chat_id), "title": title,
|
||||
"member_ids": [str(x) for x in member_ids], "created_at": iso(created)}
|
||||
|
||||
|
||||
async def get_chat_for_member(conn, chat_id, user_id) -> dict | None:
|
||||
"""Чат, если он существует И пользователь в нём состоит; иначе None (→ 404)."""
|
||||
cur = await conn.execute(
|
||||
CHAT_SELECT + "WHERE c.id = %s AND EXISTS "
|
||||
"(SELECT 1 FROM chat_members x WHERE x.chat_id = c.id AND x.user_id = %s)",
|
||||
(chat_id, user_id))
|
||||
row = await cur.fetchone()
|
||||
return chat_out(row) if row else None
|
||||
|
||||
|
||||
async def list_chats(conn, user_id, limit: int, cursor: str | None):
|
||||
scope = f"chats:{user_id}"
|
||||
params: list = [user_id]
|
||||
where = ""
|
||||
if cursor:
|
||||
c_at, c_id = decode_cursor(cursor, scope)
|
||||
where = "WHERE (c.created_at, c.id) > (%s, %s) "
|
||||
params += [c_at, c_id]
|
||||
cur = await conn.execute(
|
||||
CHAT_SELECT + "JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s "
|
||||
+ where + "ORDER BY c.created_at, c.id LIMIT %s", (*params, limit + 1))
|
||||
rows = await cur.fetchall()
|
||||
page, nxt = _page(rows, limit, scope, key=lambda r: (r[2], r[0]))
|
||||
return [chat_out(r) for r in page], nxt
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- messages
|
||||
MSG_COLS = "id, chat_id, sender_id, text, created_at"
|
||||
|
||||
|
||||
def message_out(row) -> dict:
|
||||
return {"id": str(row[0]), "chat_id": str(row[1]), "sender_id": str(row[2]),
|
||||
"text": row[3], "created_at": iso(row[4])}
|
||||
|
||||
|
||||
async def insert_message(conn, chat_id, sender_id, text: str) -> dict:
|
||||
cur = await conn.execute(
|
||||
f"INSERT INTO messages ({MSG_COLS}) VALUES (%s, %s, %s, %s, %s) RETURNING {MSG_COLS}",
|
||||
(uuid.uuid4(), chat_id, sender_id, text, now()))
|
||||
return message_out(await cur.fetchone())
|
||||
|
||||
|
||||
async def list_messages(conn, chat_id, limit: int, cursor: str | None):
|
||||
"""Keyset-пагинация по индексу (chat_id, created_at, id): без OFFSET и без скана истории."""
|
||||
scope = f"messages:{chat_id}"
|
||||
params: list = [chat_id]
|
||||
where = ""
|
||||
if cursor:
|
||||
c_at, c_id = decode_cursor(cursor, scope)
|
||||
where = "AND (created_at, id) > (%s, %s) "
|
||||
params += [c_at, c_id]
|
||||
cur = await conn.execute(
|
||||
f"SELECT {MSG_COLS} FROM messages WHERE chat_id = %s " + where
|
||||
+ "ORDER BY created_at, id LIMIT %s", (*params, limit + 1))
|
||||
rows = await cur.fetchall()
|
||||
page, nxt = _page(rows, limit, scope, key=lambda r: (r[4], r[0]))
|
||||
return [message_out(r) for r in page], nxt
|
||||
@@ -0,0 +1,46 @@
|
||||
"""
|
||||
Пароли и токены.
|
||||
|
||||
Пароль: Argon2id (password KDF). Он специально медленный и требует память,
|
||||
поэтому перебор украденных хэшей дорог. Соль своя у каждого хэша.
|
||||
|
||||
Токен сессии: 32 случайных байта (256 бит) из secrets — непрозрачная строка,
|
||||
не связанная с username/UUID. В БД кладём SHA-256 от токена: для случайного
|
||||
256-битного значения быстрый хэш достаточен (перебирать нечего), а утечка
|
||||
таблицы sessions не даёт рабочих токенов.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import hashlib
|
||||
import secrets
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
|
||||
|
||||
_hasher = PasswordHasher() # Argon2id, параметры по умолчанию библиотеки (RFC 9106 low-memory)
|
||||
|
||||
# Хэш-заглушка: проверяем пароль даже для несуществующего пользователя,
|
||||
# чтобы по времени ответа нельзя было узнать, существует ли username.
|
||||
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return _hasher.hash(password)
|
||||
|
||||
|
||||
def verify_password(password_hash: str | None, password: str) -> bool:
|
||||
try:
|
||||
return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None
|
||||
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
def needs_rehash(password_hash: str) -> bool:
|
||||
return _hasher.check_needs_rehash(password_hash)
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
return secrets.token_urlsafe(32) # 256 бит энтропии
|
||||
|
||||
|
||||
def token_hash(token: str) -> bytes:
|
||||
return hashlib.sha256(token.encode("utf-8")).digest()
|
||||
+168
@@ -0,0 +1,168 @@
|
||||
"""
|
||||
Сессии: PostgreSQL — источник истины, Redis/Valkey — кэш поиска сессии.
|
||||
|
||||
Чтение (проверка Bearer):
|
||||
1. Ищем в Redis ключ sess:<sha256(token)>. Нашли и не истёк → пользователь.
|
||||
2. Нет в кэше / Redis недоступен → читаем sessions в PostgreSQL
|
||||
(не отозвана и expires_at > now()) и кладём результат в кэш.
|
||||
|
||||
Политика expiry: срок жизни сессии задаёт PostgreSQL (expires_at).
|
||||
TTL ключа в Redis = min(SESSION_CACHE_TTL_SECONDS, время до expires_at),
|
||||
поэтому кэш никогда не продлевает сессию.
|
||||
|
||||
Инвалидация (logout) — атомарно для БД и кэша:
|
||||
в одной транзакции UPDATE sessions SET revoked_at (строка блокируется),
|
||||
затем DEL ключа в Redis. Если Redis не ответил — транзакция откатывается и
|
||||
клиент получает 503: logout НЕ подтверждён, 204 отдаётся только когда
|
||||
копии отозванной сессии в кэше гарантированно нет.
|
||||
Гонка «чтение кладёт старую сессию в кэш после DEL» закрыта блокировкой:
|
||||
чтение из БД идёт с FOR SHARE и кладёт в кэш, не отпуская строку, поэтому
|
||||
logout ждёт окончания такого чтения и удаляет ключ уже после него.
|
||||
|
||||
Отказ Redis: кэш обходится, всё читается из PostgreSQL (медленнее, но верно).
|
||||
Flush/рестарт Redis: кэш пустой → сессии восстанавливаются из PostgreSQL.
|
||||
Отказ PostgreSQL: новые проверки идут в БД → 503, анонимный запрос не принимается.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from redis.exceptions import RedisError
|
||||
|
||||
from .config import settings
|
||||
from .security import new_token, token_hash
|
||||
|
||||
log = logging.getLogger("messenger.sessions")
|
||||
|
||||
_redis: aioredis.Redis | None = None
|
||||
|
||||
|
||||
def init_redis() -> None:
|
||||
global _redis
|
||||
if settings.redis_url:
|
||||
_redis = aioredis.Redis.from_url(
|
||||
settings.redis_url,
|
||||
socket_timeout=settings.redis_timeout,
|
||||
socket_connect_timeout=settings.redis_timeout,
|
||||
decode_responses=True,
|
||||
)
|
||||
|
||||
|
||||
async def close_redis() -> None:
|
||||
if _redis is not None:
|
||||
await _redis.aclose()
|
||||
|
||||
|
||||
def redis_enabled() -> bool:
|
||||
return _redis is not None
|
||||
|
||||
|
||||
async def redis_ping() -> bool:
|
||||
if _redis is None:
|
||||
return False
|
||||
try:
|
||||
return bool(await _redis.ping())
|
||||
except (RedisError, OSError):
|
||||
return False
|
||||
|
||||
|
||||
def _key(th: bytes) -> str:
|
||||
return "sess:" + th.hex()
|
||||
|
||||
|
||||
async def _cache_get(th: bytes) -> dict | None:
|
||||
if _redis is None:
|
||||
return None
|
||||
try:
|
||||
raw = await _redis.get(_key(th))
|
||||
except (RedisError, OSError) as exc:
|
||||
log.warning("redis unavailable on read, bypassing cache: %s", type(exc).__name__)
|
||||
return None
|
||||
return json.loads(raw) if raw else None
|
||||
|
||||
|
||||
async def _cache_put(th: bytes, user: dict, expires_at: datetime) -> None:
|
||||
if _redis is None:
|
||||
return
|
||||
left = int((expires_at - datetime.now(timezone.utc)).total_seconds())
|
||||
ttl = min(settings.session_cache_ttl_seconds, left)
|
||||
if ttl <= 0:
|
||||
return
|
||||
try:
|
||||
await _redis.set(_key(th), json.dumps({"user": user, "exp": expires_at.isoformat()}), ex=ttl)
|
||||
except (RedisError, OSError) as exc:
|
||||
log.warning("redis unavailable on write, skipping cache: %s", type(exc).__name__)
|
||||
|
||||
|
||||
class CacheUnavailable(Exception):
|
||||
"""Redis не подтвердил удаление ключа — отзыв сессии нельзя гарантировать."""
|
||||
|
||||
|
||||
async def _cache_delete_strict(th: bytes) -> None:
|
||||
"""Удалить копию сессии из кэша или поднять CacheUnavailable.
|
||||
Молча проглатывать ошибку нельзя: если Redis «приостановлен», ключ
|
||||
переживёт сбой и после восстановления отозванный токен снова примут."""
|
||||
if _redis is None:
|
||||
return
|
||||
try:
|
||||
await _redis.delete(_key(th))
|
||||
except (RedisError, OSError) as exc:
|
||||
log.warning("redis unavailable on invalidate: %s", type(exc).__name__)
|
||||
raise CacheUnavailable() from exc
|
||||
|
||||
|
||||
async def create_session(conn, user_id) -> tuple[str, datetime]:
|
||||
token = new_token()
|
||||
now = datetime.now(timezone.utc)
|
||||
expires_at = now + timedelta(seconds=settings.session_ttl_seconds)
|
||||
await conn.execute(
|
||||
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at) "
|
||||
"VALUES (%s, %s, %s, %s)",
|
||||
(token_hash(token), user_id, now, expires_at))
|
||||
return token, expires_at
|
||||
|
||||
|
||||
async def resolve(pool, token: str, load_user) -> dict | None:
|
||||
"""Вернёт пользователя (dict) для действующего токена или None."""
|
||||
th = token_hash(token)
|
||||
cached = await _cache_get(th)
|
||||
if cached is not None:
|
||||
if datetime.fromisoformat(cached["exp"]) > datetime.now(timezone.utc):
|
||||
return cached["user"]
|
||||
return None
|
||||
async with pool.connection() as conn:
|
||||
# FOR SHARE: пока эта транзакция не закончилась (вместе с записью в кэш),
|
||||
# logout не сможет отозвать строку — он дождётся и удалит ключ после нас.
|
||||
cur = await conn.execute(
|
||||
"SELECT user_id, expires_at FROM sessions "
|
||||
"WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() "
|
||||
"FOR SHARE",
|
||||
(th,))
|
||||
row = await cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
user = await load_user(conn, row[0])
|
||||
if user is None:
|
||||
return None
|
||||
await _cache_put(th, user, row[1])
|
||||
return user
|
||||
|
||||
|
||||
async def revoke(pool, token: str) -> bool:
|
||||
"""Отозвать сессию. True — была действующая и теперь отозвана (и в БД, и в кэше).
|
||||
False — сессии нет/уже отозвана. CacheUnavailable — Redis не ответил:
|
||||
транзакция откатана, сессия осталась действующей, logout не подтверждён."""
|
||||
th = token_hash(token)
|
||||
async with pool.connection() as conn:
|
||||
async with conn.transaction():
|
||||
cur = await conn.execute(
|
||||
"UPDATE sessions SET revoked_at = now() "
|
||||
"WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() "
|
||||
"RETURNING 1", (th,))
|
||||
if await cur.fetchone() is None:
|
||||
return False
|
||||
# Внутри транзакции: ошибка Redis → исключение → ROLLBACK отзыва.
|
||||
await _cache_delete_strict(th)
|
||||
return True
|
||||
@@ -0,0 +1,76 @@
|
||||
# Локальный стенд lab2: API + PostgreSQL (источник истины) + Redis (кэш сессий).
|
||||
# Запуск: docker compose --env-file .env up -d --build
|
||||
# Данные лежат в именованном volume pgdata и переживают перезапуск контейнеров.
|
||||
name: mtusi-messenger
|
||||
|
||||
x-api-env: &api-env
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
|
||||
CACHE_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
|
||||
DB_POOL_MAX: ${DB_POOL_MAX:-10}
|
||||
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3}
|
||||
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
|
||||
REDIS_TIMEOUT: ${REDIS_TIMEOUT:-0.5}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-info}
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_DB: ${POSTGRES_DB}
|
||||
POSTGRES_USER: ${POSTGRES_USER}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1-alpine
|
||||
# Чистый кэш: persistence выключен намеренно. Источник истины сессий — PostgreSQL,
|
||||
# после рестарта Redis кэш пуст и заполняется заново из базы.
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no",
|
||||
"--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"]
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
environment: *api-env
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_started
|
||||
restart: unless-stopped
|
||||
|
||||
# Второй экземпляр API с коротким TTL — только для теста истечения сессии.
|
||||
# Запуск: docker compose --env-file .env --profile ttl up -d api-ttl
|
||||
api-ttl:
|
||||
image: mtusi-messenger:lab2
|
||||
environment:
|
||||
<<: *api-env
|
||||
SESSION_TTL_SECONDS: "2"
|
||||
SESSION_CACHE_TTL_SECONDS: "60"
|
||||
MIGRATE_ON_START: "false"
|
||||
ports:
|
||||
- "127.0.0.1:8081:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
profiles: ["ttl"]
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,8 @@
|
||||
# 2026-10-15T10:02Z, второй экземпляр API с SESSION_TTL_SECONDS=2 (в compose: api-ttl на 8081)
|
||||
$ python student-tests/expiry.py
|
||||
ok - login -> 201
|
||||
ok - expires_at is about 2s ahead (got 2.00s)
|
||||
ok - token works before expiry
|
||||
ok - expired token -> 401 (cache does not extend the session)
|
||||
|
||||
4 passed, 0 failed
|
||||
@@ -0,0 +1,57 @@
|
||||
BEGIN
|
||||
INSERT 0 1
|
||||
INSERT 0 10
|
||||
INSERT 0 10
|
||||
INSERT 0 60000
|
||||
ANALYZE
|
||||
messages_in_target_chat
|
||||
-------------------------
|
||||
12000
|
||||
(1 row)
|
||||
|
||||
=== 1. Первая страница (limit 50 + 1) ===
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.41..14.11 rows=51 width=65) (actual time=0.010..0.018 rows=51 loops=1)
|
||||
Buffers: shared hit=4
|
||||
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..3252.33 rows=12114 width=65) (actual time=0.010..0.014 rows=51 loops=1)
|
||||
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
|
||||
Buffers: shared hit=4
|
||||
Planning:
|
||||
Buffers: shared hit=18
|
||||
Planning Time: 0.107 ms
|
||||
Execution Time: 0.032 ms
|
||||
(9 rows)
|
||||
|
||||
=== 2. Страница из середины истории (keyset-курсор после ~6000-го сообщения) ===
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..15.40 rows=51 width=65) (actual time=0.012..0.035 rows=51 loops=1)
|
||||
Buffers: shared hit=5
|
||||
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..3199.66 rows=10891 width=65) (actual time=0.011..0.030 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW(((now() - '1 day'::interval) + '00:00:06'::interval), '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Buffers: shared hit=5
|
||||
Planning Time: 0.079 ms
|
||||
Execution Time: 0.094 ms
|
||||
(7 rows)
|
||||
|
||||
=== 3. Для сравнения: та же страница, если запретить индекс ===
|
||||
SET
|
||||
SET
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=2603.40..2603.52 rows=51 width=65) (actual time=6.820..6.826 rows=51 loops=1)
|
||||
Buffers: shared hit=740
|
||||
-> Sort (cost=2603.40..2630.62 rows=10891 width=65) (actual time=6.819..6.821 rows=51 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 31kB
|
||||
Buffers: shared hit=740
|
||||
-> Seq Scan on messages (cost=0.00..2240.05 rows=10891 width=65) (actual time=1.638..6.339 rows=6001 loops=1)
|
||||
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW(((now() - '1 day'::interval) + '00:00:06'::interval), '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 54001
|
||||
Buffers: shared hit=740
|
||||
Planning Time: 0.072 ms
|
||||
Execution Time: 6.841 ms
|
||||
(12 rows)
|
||||
|
||||
ROLLBACK
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.11,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 6636,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 439.183,
|
||||
"successful_latency_ms": {
|
||||
"p50": 8.483,
|
||||
"p95": 13.092,
|
||||
"p99": 17.662
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
# 2026-10-22T10:10Z, Redis приостановлен процессным сигналом (в Docker: docker compose pause/unpause redis)
|
||||
$ python student-tests/logout_cache.py
|
||||
ok - session is warmed up in cache
|
||||
== Redis приостановлен ==
|
||||
$ kill -STOP 4026
|
||||
ok - logout is NOT confirmed while cache cannot be invalidated (got 503, expected 503)
|
||||
$ kill -CONT 4026
|
||||
== Redis восстановлен ==
|
||||
ok - unconfirmed logout left the session consistent and valid (got 200)
|
||||
ok - retry logout after Redis recovery -> 204 (got 204)
|
||||
ok - old token after confirmed logout -> 401, no stale cache copy (got 401)
|
||||
ok - old token still rejected on repeat (got 401)
|
||||
|
||||
6 passed, 0 failed
|
||||
|
||||
# Для сравнения: та же проверка на версии ДО исправления (commit dbdb66456a)
|
||||
ok - session is warmed up in cache
|
||||
== Redis приостановлен ==
|
||||
$ kill -STOP 6663
|
||||
FAIL - logout is NOT confirmed while cache cannot be invalidated (got 204, expected 503)
|
||||
$ kill -CONT 6663
|
||||
== Redis восстановлен ==
|
||||
FAIL - after a 204 the old token is rejected after Redis recovery (got 200)
|
||||
FAIL - old token after confirmed logout -> 401, no stale cache copy (got 200)
|
||||
FAIL - old token still rejected on repeat (got 200)
|
||||
|
||||
1 passed, 4 failed
|
||||
@@ -0,0 +1,37 @@
|
||||
# 2026-10-15T09:59Z повторный запуск миграций на заполненной БД
|
||||
$ python -m app.migrate
|
||||
applied: nothing (up to date)
|
||||
$ psql: SELECT version, applied_at FROM schema_migrations; SELECT count(*) FROM users
|
||||
version | applied_at
|
||||
-----------+------------------------------
|
||||
0001_init | 2026-10-15 12:50:12.87179+03
|
||||
(1 row)
|
||||
|
||||
users
|
||||
-------
|
||||
46
|
||||
(1 row)
|
||||
|
||||
$ python -m app.migrate (ещё раз)
|
||||
applied: nothing (up to date)
|
||||
users
|
||||
-------
|
||||
46
|
||||
(1 row)
|
||||
|
||||
|
||||
# миграции с нуля на пустой БД
|
||||
$ DATABASE_URL=.../fresh python -m app.migrate
|
||||
INFO:messenger.migrate:migration applied: 0001_init
|
||||
applied: ['0001_init']
|
||||
List of relations
|
||||
Schema | Name | Type | Owner
|
||||
--------+-------------------+-------+-----------
|
||||
public | chat_members | table | messenger
|
||||
public | chats | table | messenger
|
||||
public | messages | table | messenger
|
||||
public | schema_migrations | table | messenger
|
||||
public | sessions | table | messenger
|
||||
public | users | table | messenger
|
||||
(6 rows)
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
# 2026-10-15T10:02Z, локальный стенд; в Docker тот же скрипт по умолчанию делает docker compose stop/start
|
||||
== 1. Redis недоступен ==
|
||||
$ redis-cli shutdown nosave
|
||||
ok - valid token still works without Redis (cache bypassed)
|
||||
ok - writes still work without Redis
|
||||
ok - login works without Redis
|
||||
ok - forged token still rejected without Redis
|
||||
$ redis-server --daemonize yes --save '' --appendonly no
|
||||
== 2. PostgreSQL недоступен ==
|
||||
$ su postgres -c '/usr/lib/postgresql/16/bin/pg_ctl -D /tmp/pgdata -m fast -w stop'
|
||||
ok - history without DB -> 503, not a hang (got 503)
|
||||
ok - unknown token is never trusted without DB (got 503)
|
||||
ok - anonymous request -> 401
|
||||
ok - /health/ready -> 503
|
||||
ok - /health/live -> 200 (process is alive)
|
||||
$ su postgres -c '/usr/lib/postgresql/16/bin/pg_ctl -D /tmp/pgdata -w start -o "-p 5432 -k /tmp" -l /tmp/pg.log'
|
||||
== 3. восстановление ==
|
||||
ok - /health/ready back to 200
|
||||
ok - same token reads the same history after DB is back
|
||||
|
||||
11 passed, 0 failed
|
||||
@@ -0,0 +1,15 @@
|
||||
# 2026-10-15T10:02Z
|
||||
# hook: локальный аналог scripts/restart.sh (Docker недоступен на стенде): остановка API, pg_ctl restart PostgreSQL, перезапуск Redis, старт API; каталоги данных сохраняются
|
||||
$ python tests/resilience.py --mode persistence --action-script <hook>
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
# процессы до/после (PID меняются => реально перезапущены):
|
||||
before:
|
||||
14201 python3 -m app
|
||||
14621 redis-server *:6379
|
||||
14632 /usr/lib/postgresql/16/bin/postgres -D /tmp/pgdata -p 5432 -k /tmp
|
||||
after:
|
||||
14958 /usr/lib/postgresql/16/bin/postgres -p 5432 -k /tmp
|
||||
14968 redis-server *:6379
|
||||
14975 python3 -m app
|
||||
@@ -0,0 +1,5 @@
|
||||
# 2026-10-15T10:02Z
|
||||
$ python student-tests/rollback_check.py
|
||||
ok - insert of unknown member failed on foreign key
|
||||
ok - after rollback: chats=0, members=0 (expected 0, 0)
|
||||
PASS
|
||||
@@ -0,0 +1,7 @@
|
||||
# 2026-10-15T10:02Z, local stand (PostgreSQL 16, Redis 7, Python 3.11), API http://127.0.0.1:8092
|
||||
$ make check
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
$ make validate
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
$ make test
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,34 @@
|
||||
# 2026-10-15T10:02Z
|
||||
$ python student-tests/run.py
|
||||
== аутентификация ==
|
||||
ok - wrong password -> 401 + Basic challenge
|
||||
ok - unknown user -> 401 (same as wrong password)
|
||||
ok - no token -> 401 + Bearer challenge
|
||||
ok - X-User-Id alone gives no access
|
||||
ok - unknown/forged token -> 401
|
||||
ok - Basic on business endpoint -> 401
|
||||
ok - X-User-Id cannot override bearer identity
|
||||
ok - password shorter than 12 -> 400
|
||||
== logout ==
|
||||
ok - logout -> 204
|
||||
ok - token after logout -> 401
|
||||
ok - second logout -> 401
|
||||
== гонка регистрации одного username ==
|
||||
ok - 20 parallel registrations -> one 201, nineteen 409 (got [201, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409])
|
||||
== ошибки и доступ (из lab1) ==
|
||||
ok - malformed JSON -> 400
|
||||
ok - duplicate username -> 409
|
||||
ok - blank message -> 400
|
||||
ok - sender_id in body is rejected
|
||||
ok - outsider POST to foreign chat -> 404
|
||||
ok - outsider GET foreign history -> 404
|
||||
ok - invalid chat uuid -> 400
|
||||
== пагинация ==
|
||||
ok - 5 messages / limit 2 -> 3 pages, no duplicates
|
||||
ok - cursor from another chat -> 400
|
||||
|
||||
21 passed, 0 failed
|
||||
|
||||
$ python student-tests/race.py
|
||||
sent=100 accepted=100 received=100 unique_ids=100 all_texts_present=True
|
||||
PASS
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
# Перейти в папку проекта и создать .env (один раз)
|
||||
cd C:\Users\79152\Desktop\mtusi2026lab2
|
||||
copy .env.example .env
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Запуск: API + PostgreSQL + Redis
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
docker compose ps
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Миграции: применились при старте, повтор ничего не дублирует
|
||||
docker compose logs api --tail 15
|
||||
docker compose exec api python -m app.migrate
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "\dt"
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "SELECT * FROM schema_migrations"
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Функции: St печатает код ответа, Login входит через Basic (вставить один раз)
|
||||
function St($m,$u,$b,$h){ try{ if($b){ $r=Invoke-WebRequest $u -Method $m -ContentType 'application/json' -Body $b -Headers $h -UseBasicParsing } else { $r=Invoke-WebRequest $u -Method $m -Headers $h -UseBasicParsing }; $r.StatusCode } catch { $_.Exception.Response.StatusCode.value__ } }
|
||||
function Login($u,$p){ $b=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${u}:${p}")); Invoke-RestMethod http://localhost:8080/api/v1/auth/sessions -Method Post -Headers @{ Authorization = "Basic $b" } }
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Health
|
||||
Invoke-RestMethod http://localhost:8080/health/live
|
||||
Invoke-RestMethod http://localhost:8080/health/ready
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Суффикс для уникальных имён и общий пароль
|
||||
$s = Get-Random -Maximum 100000
|
||||
$PW = 'Hockey-pass-2026'
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Регистрация: Майк, Артём, Толя (пароля в ответе нет)
|
||||
$mike = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""mike_$s"",""display_name"":""Mike"",""password"":""$PW""}"; $M = $mike.id; $mike
|
||||
$artem = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""artem_$s"",""display_name"":""Artem"",""password"":""$PW""}"; $A = $artem.id; $artem
|
||||
$toly = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""toly_$s"",""display_name"":""Toly"",""password"":""$PW""}"; $T = $toly.id; $toly
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Вход (Basic) -> получаем Bearer-токены
|
||||
$sm = Login "mike_$s" $PW; $sm | ConvertTo-Json -Depth 5
|
||||
$sa = Login "artem_$s" $PW
|
||||
$st = Login "toly_$s" $PW
|
||||
$hM = @{ Authorization = "Bearer $($sm.token)" }
|
||||
$hA = @{ Authorization = "Bearer $($sa.token)" }
|
||||
$hT = @{ Authorization = "Bearer $($st.token)" }
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Кто я (по Bearer)
|
||||
Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers $hM
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Майк создаёт чат с Артёмом
|
||||
$body = "{""title"":""Hockey"",""member_ids"":[""$M"",""$A""]}"; $chat = Invoke-RestMethod http://localhost:8080/api/v1/chats -Method Post -ContentType application/json -Body $body -Headers $hM; $CHAT = $chat.id; $chat
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Переписка: Артём, Майк, Артём
|
||||
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Привет"}')) -Headers $hA
|
||||
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Привет, как дела?"}')) -Headers $hM
|
||||
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Хорошо, идём на тренировку?"}')) -Headers $hA
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# История чата и список чатов
|
||||
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages" -Headers $hM | ConvertTo-Json -Depth 5
|
||||
Invoke-RestMethod "http://localhost:8080/api/v1/chats" -Headers $hA | ConvertTo-Json -Depth 5
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Пагинация по курсору
|
||||
$p = Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages?limit=2" -Headers $hM; $p | ConvertTo-Json -Depth 5; $C = [uri]::EscapeDataString($p.next_cursor)
|
||||
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages?limit=2&cursor=$C" -Headers $hM | ConvertTo-Json -Depth 5
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Ошибки аутентификации: все 401, кроме последней строки
|
||||
$bad = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("mike_${s}:wrong-password-1"))
|
||||
$good = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("mike_${s}:$PW"))
|
||||
"nevernyy parol: " + (St POST "http://localhost:8080/api/v1/auth/sessions" $null @{ Authorization = "Basic $bad" })
|
||||
"bez tokena: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{})
|
||||
"Basic na /users/me: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ Authorization = "Basic $good" })
|
||||
"tolko X-User-Id: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ "X-User-Id" = $M })
|
||||
"poddelnyy token: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ Authorization = "Bearer fake-token-123" })
|
||||
(Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers @{ Authorization = "Bearer $($sm.token)"; "X-User-Id" = $T }).username
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Ошибки доступа и данных: 404 / 400 / 400 / 409
|
||||
"Tolya v chuzhom chate: " + (St GET "http://localhost:8080/api/v1/chats/$CHAT/messages" $null $hT)
|
||||
"pustoy tekst: " + (St POST "http://localhost:8080/api/v1/chats/$CHAT/messages" '{"text":" "}' $hM)
|
||||
"korotkiy parol: " + (St POST "http://localhost:8080/api/v1/users" "{""username"":""short_$s"",""display_name"":""S"",""password"":""123""}" @{})
|
||||
"dubl username: " + (St POST "http://localhost:8080/api/v1/users" "{""username"":""mike_$s"",""display_name"":""Other"",""password"":""$PW""}" @{})
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Что лежит в БД: хэш Argon2id вместо пароля, хэш токена вместо токена
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "SELECT username, left(password_hash, 40) AS hash FROM users ORDER BY created_at DESC LIMIT 3"
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "SELECT left(encode(token_hash,'hex'),16) AS token_sha256, expires_at, revoked_at FROM sessions ORDER BY created_at DESC LIMIT 3"
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Redis: кэш сессий с TTL
|
||||
Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers $hA | Out-Null
|
||||
docker compose exec redis redis-cli --scan --pattern "sess:*"
|
||||
$k = docker compose exec -T redis redis-cli --scan --pattern "sess:*" | Select-Object -First 1
|
||||
docker compose exec redis redis-cli TTL $k
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Logout Майка: 204, потом его токен 401
|
||||
"logout: " + (St DELETE "http://localhost:8080/api/v1/auth/sessions/current" $null $hM)
|
||||
"token posle logout: " + (St GET "http://localhost:8080/api/v1/users/me" $null $hM)
|
||||
"povtornyy logout: " + (St DELETE "http://localhost:8080/api/v1/auth/sessions/current" $null $hM)
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Ручной рестарт API + PostgreSQL + Redis: токен Артёма и история на месте
|
||||
docker compose restart postgres redis api
|
||||
docker compose ps
|
||||
Invoke-RestMethod http://localhost:8080/health/ready
|
||||
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages" -Headers $hA | ConvertTo-Json -Depth 5
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Публичные тесты
|
||||
python scripts\check_contract.py
|
||||
python tests\smoke.py --base-url http://localhost:8080
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Тест сохранности (persistence)
|
||||
python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
docker compose ps
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Свои тесты: аутентификация, logout, гонка регистрации, ошибки, пагинация
|
||||
python student-tests\run.py --base-url http://localhost:8080
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Гонка: 10 клиентов x 10 сообщений
|
||||
python student-tests\race.py --base-url http://localhost:8080
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Истечение сессии: второй API с TTL = 2 секунды
|
||||
docker compose --env-file .env --profile ttl up -d api-ttl
|
||||
python student-tests\expiry.py --base-url http://localhost:8081
|
||||
docker compose --profile ttl stop api-ttl
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Отказ Redis и PostgreSQL
|
||||
python student-tests\outage.py --base-url http://localhost:8080
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Rollback создания чата
|
||||
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
|
||||
docker compose exec api python /tmp/rollback_check.py
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# EXPLAIN истории на 60 000 сообщений
|
||||
docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
|
||||
docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Нагрузка (по желанию)
|
||||
python tests\load.py --base-url http://localhost:8080 --duration 15 --concurrency 4
|
||||
|
||||
------------------------------------------------------------
|
||||
|
||||
# Остановка (данные в volume сохраняются)
|
||||
docker compose down
|
||||
@@ -0,0 +1,54 @@
|
||||
-- 0001: начальная схема мессенджера (lab2).
|
||||
-- Источник истины для пользователей, чатов, участников, сообщений и сессий.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_key UNIQUE (username),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_by uuid NOT NULL REFERENCES users (id),
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
-- Участники чата. position сохраняет порядок member_ids из запроса.
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
-- «Мои чаты»: найти чаты пользователя без полного скана.
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
);
|
||||
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
-- ORDER BY created_at, id LIMIT n — индекс отдаёт страницу без скана всей истории.
|
||||
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
-- Сессии. Храним только SHA-256 от токена: утечка таблицы не даёт рабочих токенов.
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
created_at timestamptz NOT NULL,
|
||||
expires_at timestamptz NOT NULL,
|
||||
revoked_at timestamptz
|
||||
);
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,8 @@
|
||||
# Рантайм-зависимости, версии закреплены для воспроизводимой сборки.
|
||||
fastapi==0.141.1
|
||||
uvicorn[standard]==0.46.0
|
||||
pydantic==2.13.3
|
||||
psycopg[binary]==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
argon2-cffi==25.1.0
|
||||
redis==8.1.0
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
rem Restart hook for Windows: same as restart.sh (volumes are kept).
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env restart postgres redis api
|
||||
Executable
+6
@@ -0,0 +1,6 @@
|
||||
#!/bin/sh
|
||||
# Restart hook для make test-persistence: перезапускает API и ВСЕ хранилища
|
||||
# (PostgreSQL и Redis), сохраняя именованные volumes. Ничего не удаляет и не сидит данные.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis api
|
||||
@@ -0,0 +1,72 @@
|
||||
"""Общий HTTP-клиент для собственных тестов (только стандартная библиотека)."""
|
||||
import base64
|
||||
import json
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
PASSWORD = "Test-password-" + uuid.uuid4().hex[:8]
|
||||
|
||||
|
||||
class Api:
|
||||
def __init__(self, base: str):
|
||||
self.base = base.rstrip("/")
|
||||
|
||||
def raw(self, method, path, data=None, headers=None, timeout=10):
|
||||
req = urllib.request.Request(self.base + path, data=data, headers=headers or {}, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as r:
|
||||
return r.status, r.read(), r.headers
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read(), e.headers
|
||||
|
||||
def call(self, method, path, body=None, token=None, headers=None):
|
||||
h = dict(headers or {})
|
||||
data = None
|
||||
if body is not None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode()
|
||||
h["Content-Type"] = "application/json"
|
||||
if token:
|
||||
h["Authorization"] = "Bearer " + token
|
||||
st, raw, rh = self.raw(method, path, data, h)
|
||||
try:
|
||||
return st, json.loads(raw or b"null"), rh
|
||||
except ValueError:
|
||||
return st, None, rh
|
||||
|
||||
def register(self, prefix: str, password: str = PASSWORD) -> dict:
|
||||
name = (prefix + "_" + uuid.uuid4().hex[:10])[:32]
|
||||
st, user, _ = self.call("POST", "/api/v1/users",
|
||||
{"username": name, "display_name": prefix, "password": password})
|
||||
assert st == 201, f"register {name}: {st} {user}"
|
||||
user["password"] = password
|
||||
return user
|
||||
|
||||
def login(self, username: str, password: str):
|
||||
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
st, body, rh = self.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
|
||||
return st, body, rh
|
||||
|
||||
def new_user(self, prefix: str) -> dict:
|
||||
user = self.register(prefix)
|
||||
st, sess, _ = self.login(user["username"], user["password"])
|
||||
assert st == 201, f"login: {st}"
|
||||
user["token"] = sess["token"]
|
||||
return user
|
||||
|
||||
|
||||
class Report:
|
||||
def __init__(self):
|
||||
self.passed = self.failed = 0
|
||||
|
||||
def check(self, cond, name):
|
||||
if cond:
|
||||
self.passed += 1
|
||||
print(f" ok - {name}")
|
||||
else:
|
||||
self.failed += 1
|
||||
print(f" FAIL - {name}")
|
||||
|
||||
def finish(self):
|
||||
print(f"\n{self.passed} passed, {self.failed} failed")
|
||||
raise SystemExit(1 if self.failed else 0)
|
||||
@@ -0,0 +1,38 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Истечение сессии при коротком SESSION_TTL_SECONDS (=2).
|
||||
Запускается против отдельного экземпляра API с коротким TTL:
|
||||
docker compose --env-file .env --profile ttl up -d api-ttl
|
||||
python student-tests/expiry.py --base-url http://localhost:8081
|
||||
"""
|
||||
import argparse
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from common import Api, Report
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--base-url", default="http://localhost:8081")
|
||||
ap.add_argument("--ttl", type=float, default=2)
|
||||
args = ap.parse_args()
|
||||
api, r = Api(args.base_url), Report()
|
||||
|
||||
user = api.register("ttl")
|
||||
st, sess, _ = api.login(user["username"], user["password"])
|
||||
r.check(st == 201, "login -> 201")
|
||||
exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00"))
|
||||
left = (exp - datetime.now(timezone.utc)).total_seconds()
|
||||
r.check(0 < left <= args.ttl + 1, f"expires_at is about {args.ttl}s ahead (got {left:.2f}s)")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=sess["token"])
|
||||
r.check(st == 200, "token works before expiry") # заодно кладёт сессию в кэш Redis
|
||||
time.sleep(args.ttl + 1.5)
|
||||
st, _, rh = api.call("GET", "/api/v1/users/me", token=sess["token"])
|
||||
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"),
|
||||
"expired token -> 401 (cache does not extend the session)")
|
||||
r.finish()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,60 @@
|
||||
-- План запроса истории на ≥10 000 сообщениях (уровень «4»).
|
||||
-- Всё внутри транзакции с ROLLBACK: учебные данные не остаются в базе.
|
||||
-- Запуск (одинаково в PowerShell и sh):
|
||||
-- docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
|
||||
-- docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
|
||||
BEGIN;
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Seed', 'x', now());
|
||||
|
||||
-- Чат, историю которого читаем, и 9 «соседних» чатов, чтобы в таблице были чужие сообщения.
|
||||
INSERT INTO chats (id, title, created_by, created_at)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid, 'seed ' || g,
|
||||
'00000000-0000-4000-8000-000000000001', now()
|
||||
FROM generate_series(0, 9) g;
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id, position)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid,
|
||||
'00000000-0000-4000-8000-000000000001', 0
|
||||
FROM generate_series(0, 9) g;
|
||||
|
||||
-- 12 000 сообщений в целевом чате + 48 000 в соседних = 60 000 строк.
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN g <= 12000 THEN 0 ELSE g % 9 + 1 END)::text, 2, '0'))::uuid,
|
||||
'00000000-0000-4000-8000-000000000001',
|
||||
'msg ' || g,
|
||||
now() - interval '1 day' + g * interval '1 millisecond'
|
||||
FROM generate_series(1, 60000) g;
|
||||
|
||||
ANALYZE messages;
|
||||
|
||||
SELECT count(*) AS messages_in_target_chat
|
||||
FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100';
|
||||
|
||||
\echo '=== 1. Первая страница (limit 50 + 1) ==='
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo '=== 2. Страница из середины истории (keyset-курсор после ~6000-го сообщения) ==='
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
|
||||
AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond',
|
||||
'00000000-0000-0000-0000-000000000000')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo '=== 3. Для сравнения: та же страница, если запретить индекс ==='
|
||||
SET LOCAL enable_indexscan = off;
|
||||
SET LOCAL enable_bitmapscan = off;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
|
||||
AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond',
|
||||
'00000000-0000-0000-0000-000000000000')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
ROLLBACK;
|
||||
@@ -0,0 +1,68 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Logout при приостановленном Redis (замечание к app/sessions.py).
|
||||
|
||||
Сценарий преподавателя: прогреть сессию в кэше, приостановить Redis, сделать
|
||||
logout, восстановить Redis и проверить старый токен.
|
||||
Требование: 204 только при гарантированном отзыве; после 204 старый токен
|
||||
никогда не принимается, в том числе после восстановления Redis.
|
||||
|
||||
python student-tests/logout_cache.py --base-url http://localhost:8080
|
||||
(по умолчанию сам делает docker compose pause/unpause redis)
|
||||
"""
|
||||
import argparse
|
||||
import shlex
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
from common import Api, Report
|
||||
|
||||
COMPOSE = "docker compose --env-file .env"
|
||||
|
||||
|
||||
def sh(cmd: str):
|
||||
print(f" $ {cmd}")
|
||||
subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--base-url", default="http://localhost:8080")
|
||||
ap.add_argument("--pause-redis", default=f"{COMPOSE} pause redis")
|
||||
ap.add_argument("--unpause-redis", default=f"{COMPOSE} unpause redis")
|
||||
args = ap.parse_args()
|
||||
api, r = Api(args.base_url), Report()
|
||||
|
||||
user = api.new_user("logoutcache")
|
||||
token = user["token"]
|
||||
for _ in range(2): # первый запрос кладёт сессию в Redis, второй читает из кэша
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
|
||||
r.check(st == 200, "session is warmed up in cache")
|
||||
|
||||
print("== Redis приостановлен ==")
|
||||
sh(args.pause_redis)
|
||||
try:
|
||||
st_logout, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token)
|
||||
r.check(st_logout != 204,
|
||||
f"logout is NOT confirmed while cache cannot be invalidated (got {st_logout}, expected 503)")
|
||||
finally:
|
||||
sh(args.unpause_redis)
|
||||
time.sleep(0.5)
|
||||
|
||||
print("== Redis восстановлен ==")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
|
||||
if st_logout == 204:
|
||||
r.check(st == 401, f"after a 204 the old token is rejected after Redis recovery (got {st})")
|
||||
else:
|
||||
r.check(st == 200, f"unconfirmed logout left the session consistent and valid (got {st})")
|
||||
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token)
|
||||
r.check(st == 204, f"retry logout after Redis recovery -> 204 (got {st})")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
|
||||
r.check(st == 401, f"old token after confirmed logout -> 401, no stale cache copy (got {st})")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
|
||||
r.check(st == 401, f"old token still rejected on repeat (got {st})")
|
||||
r.finish()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,96 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Недоступность зависимостей (уровень «4»). Сам останавливает и запускает контейнеры:
|
||||
python student-tests/outage.py --base-url http://localhost:8080
|
||||
|
||||
1. Redis остановлен → API работает в обход кэша (сессии читаются из PostgreSQL).
|
||||
2. PostgreSQL остановлен → защищённые запросы получают ограниченную ошибку 503,
|
||||
неизвестный токен НЕ принимается (никогда 200), /health/ready = 503.
|
||||
3. PostgreSQL запущен снова → тот же токен снова работает, данные на месте.
|
||||
"""
|
||||
import argparse
|
||||
import shlex
|
||||
import subprocess
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from common import Api, Report
|
||||
|
||||
COMPOSE = "docker compose --env-file .env"
|
||||
|
||||
|
||||
def sh(cmd: str):
|
||||
print(f" $ {cmd}")
|
||||
subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def wait_ready(api: Api, seconds=90):
|
||||
deadline = time.time() + seconds
|
||||
while time.time() < deadline:
|
||||
try:
|
||||
if api.raw("GET", "/health/ready", timeout=3)[0] == 200:
|
||||
return True
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(1)
|
||||
return False
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--base-url", default="http://localhost:8080")
|
||||
ap.add_argument("--stop-redis", default=f"{COMPOSE} stop redis")
|
||||
ap.add_argument("--start-redis", default=f"{COMPOSE} start redis")
|
||||
ap.add_argument("--stop-db", default=f"{COMPOSE} stop postgres")
|
||||
ap.add_argument("--start-db", default=f"{COMPOSE} start postgres")
|
||||
args = ap.parse_args()
|
||||
api, r = Api(args.base_url), Report()
|
||||
|
||||
user = api.new_user("outage")
|
||||
st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "outage", "member_ids": [user["id"]]}, token=user["token"])
|
||||
path = f"/api/v1/chats/{chat['id']}/messages"
|
||||
api.call("POST", path, {"text": "before outage"}, token=user["token"])
|
||||
|
||||
print("== 1. Redis недоступен ==")
|
||||
sh(args.stop_redis)
|
||||
try:
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=user["token"])
|
||||
r.check(st == 200, "valid token still works without Redis (cache bypassed)")
|
||||
st, _, _ = api.call("POST", path, {"text": "without redis"}, token=user["token"])
|
||||
r.check(st == 201, "writes still work without Redis")
|
||||
fresh = api.register("noredis")
|
||||
st, sess, _ = api.login(fresh["username"], fresh["password"])
|
||||
r.check(st == 201, "login works without Redis")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
|
||||
r.check(st == 401, "forged token still rejected without Redis")
|
||||
finally:
|
||||
sh(args.start_redis)
|
||||
|
||||
print("== 2. PostgreSQL недоступен ==")
|
||||
sh(args.stop_db)
|
||||
try:
|
||||
time.sleep(1)
|
||||
st, _, _ = api.call("GET", path, token=user["token"])
|
||||
r.check(st == 503, f"history without DB -> 503, not a hang (got {st})")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
|
||||
r.check(st in (401, 503), f"unknown token is never trusted without DB (got {st})")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me")
|
||||
r.check(st == 401, "anonymous request -> 401")
|
||||
st = api.raw("GET", "/health/ready")[0]
|
||||
r.check(st == 503, "/health/ready -> 503")
|
||||
st = api.raw("GET", "/health/live")[0]
|
||||
r.check(st == 200, "/health/live -> 200 (process is alive)")
|
||||
finally:
|
||||
sh(args.start_db)
|
||||
|
||||
print("== 3. восстановление ==")
|
||||
r.check(wait_ready(api), "/health/ready back to 200")
|
||||
st, page, _ = api.call("GET", path, token=user["token"])
|
||||
texts = [m["text"] for m in (page or {}).get("items", [])]
|
||||
r.check(st == 200 and "before outage" in texts and "without redis" in texts,
|
||||
"same token reads the same history after DB is back")
|
||||
r.finish()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,46 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Конкурентная запись: 10 клиентов параллельно отправляют по 10 сообщений.
|
||||
Ожидаем ровно 100 уникальных сообщений в истории.
|
||||
python student-tests/race.py --base-url http://localhost:8080
|
||||
"""
|
||||
import argparse
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from common import Api
|
||||
|
||||
CLIENTS, PER_CLIENT = 10, 10
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--base-url", default="http://localhost:8080")
|
||||
api = Api(ap.parse_args().base_url)
|
||||
user = api.new_user("race")
|
||||
st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "race", "member_ids": [user["id"]]}, token=user["token"])
|
||||
mpath = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
def worker(w):
|
||||
return [api.call("POST", mpath, {"text": f"c{w}-m{i}"}, token=user["token"])[0] for i in range(PER_CLIENT)]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
codes = [c for batch in pool.map(worker, range(CLIENTS)) for c in batch]
|
||||
|
||||
ids, texts, cursor = [], [], None
|
||||
while True:
|
||||
st, page, _ = api.call("GET", f"{mpath}?limit=50" + (f"&cursor={cursor}" if cursor else ""), token=user["token"])
|
||||
ids += [m["id"] for m in page["items"]]
|
||||
texts += [m["text"] for m in page["items"]]
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
expected = {f"c{w}-m{i}" for w in range(CLIENTS) for i in range(PER_CLIENT)}
|
||||
ok = codes.count(201) == 100 and len(ids) == 100 and len(set(ids)) == 100 and set(texts) == expected
|
||||
print(f"sent=100 accepted={codes.count(201)} received={len(ids)} unique_ids={len(set(ids))} "
|
||||
f"all_texts_present={set(texts) == expected}")
|
||||
print("PASS" if ok else "FAIL")
|
||||
raise SystemExit(0 if ok else 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,52 @@
|
||||
"""
|
||||
Rollback составной операции «создать чат + участников» (уровень «4»).
|
||||
|
||||
Создаём чат, где последний участник — несуществующий пользователь. Проверку
|
||||
приложения нарочно обходим и вызываем запись напрямую: первый INSERT в chats
|
||||
проходит, а вставка участника падает на внешнем ключе. Ожидаем, что транзакция
|
||||
откатилась целиком: ни чата, ни участников в базе нет.
|
||||
|
||||
Запуск внутри контейнера API (у него есть доступ к БД и коду):
|
||||
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
|
||||
docker compose exec api python /tmp/rollback_check.py
|
||||
Локально без Docker: python student-tests/rollback_check.py
|
||||
"""
|
||||
import asyncio
|
||||
import sys
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path.cwd()))
|
||||
import psycopg # noqa: E402
|
||||
|
||||
from app import repo # noqa: E402
|
||||
from app.config import settings # noqa: E402
|
||||
|
||||
|
||||
async def main() -> int:
|
||||
title = "rollback-" + uuid.uuid4().hex[:8]
|
||||
async with await psycopg.AsyncConnection.connect(settings.database_url) as conn:
|
||||
creator = await repo.create_user(conn, "rb_" + uuid.uuid4().hex[:10], "rb", "x")
|
||||
await conn.commit()
|
||||
ghost = uuid.uuid4() # такого пользователя нет
|
||||
try:
|
||||
async with conn.transaction():
|
||||
await repo.insert_chat(conn, title, [uuid.UUID(creator["id"]), ghost], creator["id"])
|
||||
print("FAIL - insert unexpectedly succeeded")
|
||||
return 1
|
||||
except psycopg.errors.ForeignKeyViolation:
|
||||
print(" ok - insert of unknown member failed on foreign key")
|
||||
cur = await conn.execute(
|
||||
"SELECT count(*) FROM chats WHERE title = %s", (title,))
|
||||
chats = (await cur.fetchone())[0]
|
||||
cur = await conn.execute(
|
||||
"SELECT count(*) FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE c.title = %s", (title,))
|
||||
members = (await cur.fetchone())[0]
|
||||
ok = chats == 0 and members == 0
|
||||
print(f" {'ok ' if ok else 'FAIL'} - after rollback: chats={chats}, members={members} (expected 0, 0)")
|
||||
print("PASS" if ok else "FAIL")
|
||||
return 0 if ok else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(asyncio.run(main()))
|
||||
@@ -0,0 +1,121 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Собственные тесты lab2 (запуск одной командой):
|
||||
python student-tests/run.py --base-url http://localhost:8080
|
||||
|
||||
Негативные сценарии lab1 на новой аутентификации + проверки уровня «4»:
|
||||
неверный пароль, logout, X-User-Id/Basic не дают доступ, гонка регистрации.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from common import PASSWORD, Api, Report
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--base-url", default="http://localhost:8080")
|
||||
api = Api(ap.parse_args().base_url)
|
||||
r = Report()
|
||||
|
||||
alice, bob, eve = api.new_user("alice"), api.new_user("bob"), api.new_user("eve")
|
||||
st, chat, _ = api.call("POST", "/api/v1/chats",
|
||||
{"title": "own tests", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"])
|
||||
assert st == 201, st
|
||||
mpath = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
print("== аутентификация ==")
|
||||
st, _, rh = api.login(alice["username"], "Wrong-password-123")
|
||||
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Basic"), "wrong password -> 401 + Basic challenge")
|
||||
st, _, _ = api.login("no_such_user_" + uuid.uuid4().hex[:8], PASSWORD)
|
||||
r.check(st == 401, "unknown user -> 401 (same as wrong password)")
|
||||
st, _, rh = api.call("GET", "/api/v1/users/me")
|
||||
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"), "no token -> 401 + Bearer challenge")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]})
|
||||
r.check(st == 401, "X-User-Id alone gives no access")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
|
||||
r.check(st == 401, "unknown/forged token -> 401")
|
||||
basic = base64.b64encode(f"{alice['username']}:{alice['password']}".encode()).decode()
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", headers={"Authorization": "Basic " + basic})
|
||||
r.check(st == 401, "Basic on business endpoint -> 401")
|
||||
st, me, _ = api.call("GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": eve["id"]})
|
||||
r.check(st == 200 and me["id"] == alice["id"], "X-User-Id cannot override bearer identity")
|
||||
st, _, _ = api.call("POST", "/api/v1/users", {"username": "short_pw_" + uuid.uuid4().hex[:6],
|
||||
"display_name": "x", "password": "short"})
|
||||
r.check(st == 400, "password shorter than 12 -> 400")
|
||||
|
||||
print("== logout ==")
|
||||
tmp = api.new_user("logout")
|
||||
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"])
|
||||
r.check(st == 204, "logout -> 204")
|
||||
st, _, _ = api.call("GET", "/api/v1/users/me", token=tmp["token"])
|
||||
r.check(st == 401, "token after logout -> 401")
|
||||
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"])
|
||||
r.check(st == 401, "second logout -> 401")
|
||||
|
||||
print("== гонка регистрации одного username ==")
|
||||
name = "race_" + uuid.uuid4().hex[:10]
|
||||
|
||||
def reg(_):
|
||||
st, _, _ = api.call("POST", "/api/v1/users", {"username": name, "display_name": "r", "password": PASSWORD})
|
||||
return st
|
||||
|
||||
with ThreadPoolExecutor(max_workers=20) as pool:
|
||||
codes = list(pool.map(reg, range(20)))
|
||||
r.check(codes.count(201) == 1 and codes.count(409) == 19,
|
||||
f"20 parallel registrations -> one 201, nineteen 409 (got {sorted(codes)})")
|
||||
|
||||
print("== ошибки и доступ (из lab1) ==")
|
||||
st, _, _ = api.raw("POST", "/api/v1/users", b"{not json", {"Content-Type": "application/json"})
|
||||
r.check(st == 400, "malformed JSON -> 400")
|
||||
st, _, _ = api.call("POST", "/api/v1/users", {"username": alice["username"], "display_name": "d", "password": PASSWORD})
|
||||
r.check(st == 409, "duplicate username -> 409")
|
||||
st, _, _ = api.call("POST", mpath, {"text": " "}, token=alice["token"])
|
||||
r.check(st == 400, "blank message -> 400")
|
||||
st, _, _ = api.call("POST", mpath, {"text": "x", "sender_id": eve["id"]}, token=alice["token"])
|
||||
r.check(st == 400, "sender_id in body is rejected")
|
||||
st, _, _ = api.call("POST", mpath, {"text": "чужое"}, token=eve["token"])
|
||||
r.check(st == 404, "outsider POST to foreign chat -> 404")
|
||||
st, _, _ = api.call("GET", mpath, token=eve["token"])
|
||||
r.check(st == 404, "outsider GET foreign history -> 404")
|
||||
st, _, _ = api.call("GET", "/api/v1/chats/not-a-uuid", token=alice["token"])
|
||||
r.check(st == 400, "invalid chat uuid -> 400")
|
||||
|
||||
print("== пагинация ==")
|
||||
for i in range(5):
|
||||
api.call("POST", mpath, {"text": f"m{i}"}, token=bob["token"])
|
||||
seen, cursor, pages = [], None, 0
|
||||
while pages < 10:
|
||||
st, page, _ = api.call("GET", f"{mpath}?limit=2" + (f"&cursor={cursor}" if cursor else ""), token=alice["token"])
|
||||
pages += 1
|
||||
seen += [m["id"] for m in page["items"]]
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
r.check(len(seen) == 5 and len(set(seen)) == 5 and pages == 3, "5 messages / limit 2 -> 3 pages, no duplicates")
|
||||
st, other, _ = api.call("POST", "/api/v1/chats", {"title": "other", "member_ids": [alice["id"]]}, token=alice["token"])
|
||||
st, p, _ = api.call("GET", f"{mpath}?limit=1", token=alice["token"])
|
||||
st, _, _ = api.call("GET", f"/api/v1/chats/{other['id']}/messages?cursor={p['next_cursor']}", token=alice["token"])
|
||||
r.check(st == 400, "cursor from another chat -> 400")
|
||||
|
||||
print("== Content-Type ==")
|
||||
body = json.dumps({"username": "ct_" + uuid.uuid4().hex[:8], "display_name": "c", "password": PASSWORD}).encode()
|
||||
st, _, _ = api.raw("POST", "/api/v1/users", body, {"Content-Type": "text/plain"})
|
||||
r.check(st == 415, f"valid JSON with text/plain -> 415 (got {st})")
|
||||
st, _, _ = api.raw("POST", mpath, json.dumps({"text": "x"}).encode(),
|
||||
{"Content-Type": "text/plain", "Authorization": "Bearer " + alice["token"]})
|
||||
r.check(st == 415, f"message with text/plain -> 415 (got {st})")
|
||||
st, _, _ = api.raw("POST", "/api/v1/chats", b"{}", {"Content-Type": "text/plain"})
|
||||
r.check(st == 401, f"text/plain without token -> 401 first (got {st})")
|
||||
st, _, _ = api.raw("POST", mpath, json.dumps({"text": "utf8"}).encode(),
|
||||
{"Content-Type": "application/json; charset=utf-8", "Authorization": "Bearer " + alice["token"]})
|
||||
r.check(st == 201, f"application/json; charset=utf-8 accepted (got {st})")
|
||||
|
||||
r.finish()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user