diff --git a/.env.example b/.env.example index 714c807..e4b048d 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,22 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Секреты сюда НЕ пишутся: их создаёт scripts/init_secrets.py в каталоге secrets/. 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. +# TTL второго экземпляра API (профиль ttl, порт 8081) для автотеста истечения +SHORT_SESSION_TTL_SECONDS=2 +# Файлы с секретами внутри контейнера (Compose secrets) DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: +# Источник истины для сессий — PostgreSQL; Redis — кэш проверок токена SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url +SESSION_CACHE_TTL_SECONDS=60 +# Пул соединений и таймауты +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_TIMEOUT_SECONDS=3 +DB_CONNECT_TIMEOUT_SECONDS=3 +DB_STATEMENT_TIMEOUT_MS=5000 +CACHE_TIMEOUT_SECONDS=0.25 +CACHE_RETRY_AFTER_SECONDS=5 diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa1..177d700 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,14 +1,14 @@ ## Лабораторная 2 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Попов Константин Дмитриевич, БВТ2303 +Целевая оценка (3/4/5): 4 +Трек 5, если заявлен: не заявлен -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: перенесён API lab1 (модели, ошибки, курсоры, Dockerfile, тесты); хранилище — PostgreSQL с миграциями; Argon2id, Basic → opaque Bearer-сессия с TTL и logout; Redis — кэш проверок сессии с обходом при отказе. Подробно — REPORT.md, «Архитектура и решения». +Команды запуска из чистого clone: `python scripts/init_secrets.py`, `cp .env.example .env`, `docker compose --env-file .env up -d --build --wait` (REPORT.md, «Запуск из чистого clone»). +Результаты проверок и ссылка на REPORT.md: smoke, persistence, 28 собственных тестов, race, отказ Redis/БД, EXPLAIN — evidence/, таблицы в REPORT.md. +Ограничения / известные ошибки: один host/БД/Redis; окно до 60 с для logout при сетевом разрыве с Redis; HTTP только для локального стенда (REPORT.md, «Ограничения»). +Источники и использование ИИ: см. REPORT.md. - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [ ] Контракт и публичные тесты не ослаблены. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..645cf88 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +# Lab2: API мессенджера (FastAPI + PostgreSQL + Redis). +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt + +COPY src ./src +COPY migrations ./migrations + +RUN useradd --create-home --shell /usr/sbin/nologin appuser \ + && chown -R appuser:appuser /app + +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()" || exit 1 + +# exec-форма: uvicorn — PID 1 и получает SIGTERM напрямую. +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "10"] diff --git a/Makefile b/Makefile index 9ecb223..7edf1cf 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence secrets up down migrate test-student test-expiry test-storage test-failures explain help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +24,38 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +#Решение +COMPOSE ?= docker compose --env-file .env +EXPIRY_URL ?= http://localhost:8081 + +secrets: + $(PYTHON) scripts/init_secrets.py + @test -f .env || cp .env.example .env + +up: secrets + $(COMPOSE) up -d --build --wait + +down: + $(COMPOSE) --profile ttl down + +migrate: + $(COMPOSE) exec api python -m src.migrate + +test-student: + BASE_URL="$(BASE_URL)" $(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)" + +test-expiry: + $(COMPOSE) --profile ttl up -d --wait api-short-ttl + EXPIRY_BASE_URL="$(EXPIRY_URL)" BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -p test_expiry.py -v + +test-storage: + $(COMPOSE) run --rm --no-deps -v "$(CURDIR)/student-tests:/app/student-tests:ro" api \ + python -m unittest discover -s student-tests -p test_storage_rollback.py -v + +test-failures: + $(PYTHON) student-tests/dependency_failure.py --base-url "$(BASE_URL)" --output evidence/dependency_failure.json + +explain: + $(COMPOSE) exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/sql/explain_history.sql > evidence/explain_history.txt + @echo "saved evidence/explain_history.txt" diff --git a/REPORT.md b/REPORT.md index e42f2b0..cf71be5 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,210 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Попов Константин Дмитриевич, группа БВТ2303 +- Целевая оценка: **4**; трек 5 не заявляется - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: Python, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16, Redis 7; документация PostgreSQL (transactions, EXPLAIN), Redis persistence, RFC 7617. Помощь ИИ использовалась при переносе кода lab1 на PostgreSQL, написании тестов и формулировке отчёта. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Версии.** Образ API: `python:3.12.7-slim-bookworm`; `postgres:16.4-alpine`; `redis:7.4.1-alpine`. Зависимости Python закреплены точными версиями в `requirements.txt`. Требуются Docker Desktop (Compose v2) и Python 3.9+ для тестов (только стандартная библиотека). + +```powershell +# 1. Локальные секреты (создаются один раз в ./secrets, каталог в .gitignore; значения не печатаются) +python scripts/init_secrets.py +copy .env.example .env # Linux/macOS: cp .env.example .env + +# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Redis +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait + +# 3. Миграции применяются автоматически при старте API (advisory lock). +# Явный повторный запуск ничего не дублирует: +docker compose exec api python -m src.migrate # -> schema is up to date; nothing applied + +# 4. Готовность +curl http://localhost:8080/health/ready # {"status":"ok"} +``` + +Проверки (Linux/macOS — через `make`, Windows — те же команды Python напрямую): + +```powershell +python scripts/check_contract.py # make check +python tests/smoke.py --base-url http://localhost:8080 # make test +# Перезапуск API и всех хранилищ с сохранением volumes: +# Linux/macOS/WSL/Git Bash: make test-persistence ACTION_SCRIPT=scripts/restart.sh +# Windows (cmd/PowerShell): python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +python student-tests/run_all.py --base-url http://localhost:8080 # make test-student + +# Истечение сессии — второй экземпляр API с SESSION_TTL_SECONDS=2 на порту 8081: +docker compose --profile ttl up -d --wait api-short-ttl +python student-tests/run_all.py --expiry-url http://localhost:8081 # make test-expiry + +# Rollback на уровне БД с внедрённым сбоем (внутри compose-сети, БД наружу не публикуется): +make test-storage + +# Отказ Redis и PostgreSQL (останавливает и снова запускает контейнеры): +python student-tests/dependency_failure.py --output evidence/dependency_failure.json # make test-failures + +# План запроса истории на 52 000 сообщениях (данные создаются и откатываются в одной транзакции): +make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | docker compose exec -T postgres psql -U messenger -d messenger > evidence/explain_history.txt +``` + +**Остановка.** Безопасная остановка без потери данных: `docker compose --profile ttl down` (volume `pgdata` сохраняется). Намеренное удаление всех учебных данных — только вручную: `docker compose --profile ttl down -v`. Restart-hook и тесты никогда не удаляют volumes. + +**Действия оператора:** создать секреты (`init_secrets.py`) до первого запуска. Пароль PostgreSQL задаётся только при инициализации пустого volume, поэтому скрипт не перезаписывает существующие файлы секретов. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент ──HTTP :8080──► API (FastAPI/Uvicorn, 1 процесс, sync-обработчики в threadpool) + │ пул psycopg: min 1 / max 10, ожидание соединения 3 с, + │ connect_timeout 3 с, statement_timeout 5 с + ├──────────► PostgreSQL 16 (источник истины; volume pgdata) + │ users, chats, chat_members, messages, sessions + └──────────► Redis 7 (кэш проверок сессий; без persistence) + таймаут 250 мс, circuit breaker 5 с +``` + +### Что перенесено из lab1 и что изменено + +Перенесены: модели Pydantic со строгой валидацией (`extra="forbid"`), формат ошибок с `X-Request-Id`, keyset-курсор `(created_at, id)` с привязкой к ресурсу, Dockerfile (non-root `appuser`, HEALTHCHECK, exec-форма CMD, graceful shutdown), собственные тесты `test_api.py`, `race.py`, `run_all.py`. + +Изменено по объявленному переходу 1 → 2: `POST /users` требует `password`; `POST /auth/sessions` принимает только Basic; все бизнес-endpoint принимают только `Bearer`; `X-User-Id` игнорируется; добавлен `DELETE /auth/sessions/current`. In-memory `Storage` с `RLock` заменён на PostgreSQL; пагинация теперь выполняется в SQL (`LIMIT n+1` по индексу), а не срезом списка в памяти. Исправление базы lab1: заголовок `X-Request-Id` от клиента принимается только по шаблону `[A-Za-z0-9._:-]{1,128}`, иначе генерируется новый. + +### Схема данных (`migrations/001_init.sql`) + +| Таблица | Ключи и ограничения | Индексы под запросы | +| --- | --- | --- | +| `users` | PK `id`; `UNIQUE(username)`; CHECK формата username и длины display_name | уникальный индекс username — вход и гонка регистрации | +| `chats` | PK `id`; CHECK длины title | — | +| `chat_members` | PK `(chat_id, user_id)`; FK → chats (CASCADE), FK → users; `UNIQUE(chat_id, position)` | `(user_id, chat_id)` — «мои чаты» | +| `messages` | PK `id`; FK → chats, FK → users; CHECK длины text 1–4000 | `(chat_id, created_at, id)` — история и keyset | +| `sessions` | PK `token_hash` (SHA-256 токена, 32 байта); FK → users; `expires_at`, `revoked_at` | `user_id`, `expires_at` | + +Миграции версионируются файлами `migrations/NNN_*.sql` и таблицей `schema_migrations`. Каждая миграция и отметка о ней — одна транзакция; одновременный старт нескольких API сериализуется `pg_advisory_lock`. Повторный запуск — no-op (проверено тестом `test_migrations_are_idempotent`). + +### Транзакционные границы + +- **Регистрация** — один `INSERT`; уникальность гарантирует `UNIQUE(username)`, приложение лишь переводит `UniqueViolation` в 409 (нет окна «SELECT, потом INSERT»). +- **Создание чата** — одна транзакция: `INSERT chats` → `INSERT chat_members` (в порядке `member_ids`). Существование участников проверяет FK; при неизвестном id откатывается всё, включая строку чата и уже вставленных участников → 400. +- **Отправка сообщения** — один оператор `INSERT … SELECT … WHERE EXISTS(членство)`: проверка доступа и запись атомарны. `created_at` назначает БД (`clock_timestamp()`), ответ отдаётся после COMMIT. +- **Чтение истории** — проверка членства и выборка страницы в одном соединении; snapshot между HTTP-страницами не обещается (как в контракте). При конкурентных вставках порядок определяется часами БД; сообщение с меньшим `created_at`, закоммиченное после чтения страницы, может быть пропущено уже прошедшим курсором — допустимое ограничение keyset по времени. +- **Вход** — `INSERT sessions` (expires_at = `clock_timestamp() + TTL` по часам БД, поэтому рестарт API не продлевает TTL). **Logout** — `UPDATE sessions SET revoked_at` (момент отзыва = COMMIT), затем инвалидация кэша. + +### Аутентификация + +- Пароли: **Argon2id** (`argon2-cffi`, m = 19 MiB, t = 2, p = 1 — рекомендация OWASP), пароль 12–128 code points хешируется целиком в UTF-8, без усечения. Для несуществующего username выполняется проверка против хеша-«пустышки», чтобы время ответа не выдавало наличие пользователя; ответ 401 одинаковый. +- Basic разбирается строго: base64 → UTF-8 → разделение по **первому** двоеточию (двоеточие в пароле допустимо). Неверные/битые credentials → 401 `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. +- Токен: `secrets.token_urlsafe(32)` — 256 бит, непрозрачный. В БД и Redis хранится только SHA-256 токена: для 256-битного случайного значения перебор невозможен, а KDF лишь замедлил бы каждый запрос (в отличие от пароля, где KDF защищает низкоэнтропийный секрет). +- Сначала аутентификация (dependency `current_user`), затем доступ к чату: посторонний получает 404, а не 403. + +### Роль Redis: кэш проверок сессии + +- **Источник истины** для сессий — PostgreSQL. Redis хранит `sess:` → `{user, expires_at}`. +- **Заполнение:** промах → запрос в PostgreSQL → `SET NX PX=min(SESSION_CACHE_TTL_SECONDS=60 с, время до expires_at)`. Запись кэша никогда не живёт дольше сессии, поэтому истечение работает и при попадании в кэш (тест `test_session_expires_even_when_cached`). +- **Инвалидация при logout:** после COMMIT отзыва в PostgreSQL выполняется `SET sess: "revoked" PX=60 с` (обычный SET перезаписывает). Заполнение идёт через `SET NX`, поэтому параллельный запрос, прочитавший сессию до отзыва, не может вернуть в кэш валидную запись поверх «надгробия». +- **Persistence:** отключена сознательно (`--save "" --appendonly no`), `maxmemory 64mb`, `allkeys-lru`. После flush/рестарта Redis кэш пуст, все проверки идут в PostgreSQL и заново наполняют кэш; сессии не теряются, потому что Redis не единственное их хранилище. +- **Отказ Redis:** таймаут операций 250 мс; при ошибке кэш пропускается на 5 с (circuit breaker), запросы обслуживаются через PostgreSQL. Readiness от Redis не зависит. +- **Эффект:** за прогон собственных тестов и 30-секундной нагрузки Redis показал `keyspace_hits=9979`, `keyspace_misses=31` — почти все проверки токена обслужены без обращения к PostgreSQL. + +### Отказ PostgreSQL + +PostgreSQL — критичная зависимость: `/health/ready` → 503; запросы к данным → `503 unavailable` за ≤ 3 с (ожидание соединения из пула) без текста драйвера/SQL. Анонимный запрос отклоняется 401 ещё до обращения к БД; неизвестный токен при недоступной БД не принимается (503). Ранее проверенный токен, ещё лежащий в кэше, может получить 200 на `GET /users/me` (≤ 60 с), но любые операции с данными всё равно получают 503. Пул проверяет соединения при выдаче (`check_connection`), поэтому после возврата БД API восстанавливается без рестарта. + +### Соответствие `.env.example` и реальной конфигурации + +| Переменная | Где используется | +| --- | --- | +| `APP_HOST`, `APP_PORT` | `APP_PORT` — публикуемый порт в compose (`127.0.0.1:${APP_PORT}:8080`); внутри контейнера Uvicorn слушает `0.0.0.0:8080` (CMD) | +| `APP_ENV` | передаётся в API, сейчас только информативно | +| `SESSION_TTL_SECONDS` | TTL сессии основного API (по умолчанию 3600) | +| `SHORT_SESSION_TTL_SECONDS` | TTL экземпляра `api-short-ttl` (профиль `ttl`, порт 8081), по умолчанию 2 | +| `DATABASE_URL_FILE` | `/run/secrets/database_url` — Compose secret, создаётся `init_secrets.py` | +| `SESSION_STORE` | `postgres` — источник истины сессий (другое значение API отвергает при старте) | +| `CACHE_URL_FILE` | `/run/secrets/cache_url` — адрес Redis с паролем; без него API работает без кэша | +| `SESSION_CACHE_TTL_SECONDS` | верхняя граница TTL записи кэша и «надгробия» logout | +| `DB_POOL_MIN/MAX`, `DB_POOL_TIMEOUT_SECONDS` | размер пула и ожидание соединения (→ 503) | +| `DB_CONNECT_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | таймаут подключения и любого SQL-оператора | +| `CACHE_TIMEOUT_SECONDS`, `CACHE_RETRY_AFTER_SECONDS` | таймаут Redis и длительность обхода кэша после ошибки | + +### Инфраструктура + +| Роль | Service | Версия | Health/readiness | Volume | Сеть/порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| api | `api` (+ `api-short-ttl` в профиле `ttl`) | сборка из `Dockerfile`, `python:3.12.7-slim-bookworm` | HEALTHCHECK `/health/ready` | нет (stateless) | `backend`; `127.0.0.1:8080` (`8081` для ttl) | secrets `database_url`, `cache_url` | +| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | `backend`, наружу не публикуется | secret `postgres_password` (`POSTGRES_PASSWORD_FILE`) | +| redis | `redis` | `redis:7.4.1-alpine`, user `redis` | `redis-cli ping` | нет (кэш) | `backend`, наружу не публикуется | secret `redis_password` (`--requirepass`) | + +Bootstrap: схема создаётся миграциями при первом старте API на пустом volume; повтор безопасен. `scripts/restart.sh` / `scripts/restart.cmd`: `stop api` → `restart postgres redis` → `up -d --wait api`; без `down -v`, flush и повторного seed. ## Доказательства критериев +Стенд, на котором сняты приложенные результаты: Linux x86_64, 2 vCPU Intel Xeon 2.1 GHz, 8 GB RAM; PostgreSQL 16.15 и Redis 7.0.15, запущенные нативно (без Docker), API — тот же код, Uvicorn, Python 3.13; клиент тестов на той же машине. Перед защитой результаты нужно повторить на compose-стенде командами из раздела «Запуск» и обновить файлы в `evidence/`. + +### Уровень 3 + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Структура/контракт | `make check`, `make validate` | оба PASS | `evidence/check.txt` | +| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` — тот же токен читает те же сообщения | `evidence/persistence.txt` | +| Hook реально перезапускает процессы | PID до/после hook | postgres 1212→1269, redis 1222→1279, api 1228→1286; пользователей 51→51, действующих сессий 42→42 | `evidence/restart_processes.txt` | +| PK/FK, UNIQUE(username), миграции с нуля | `migrations/001_init.sql`; старт на пустой БД | `migrations applied at startup: ['001_init']` | `migrations/001_init.sql` | +| Повторный запуск миграций без дублирования | `python -m src.migrate`; `test_migrations_are_idempotent` | `schema is up to date; nothing applied`; в `schema_migrations` одна строка | `evidence/student-tests.txt` | +| Атомарное создание чата | `test_unknown_member_rolls_back_whole_chat`, `test_failure_after_inserts_leaves_nothing` | после ошибки нет ни чата, ни участников | `evidence/student-tests.txt` | +| Basic только на `POST /auth/sessions`, остальное Bearer | `test_basic_on_business_endpoint_rejected`, smoke | Basic на `/users/me` → 401 `WWW-Authenticate: Bearer` | `evidence/student-tests.txt` | +| X-User-Id не даёт доступа | `test_x_user_id_gives_no_access`, smoke | 401 без Bearer; с Bearer владелец не меняется | `evidence/student-tests.txt` | +| Срок жизни и отзыв сессии | `test_session_expires_even_when_cached`, `test_logout_revokes_only_current_session` | после TTL и после logout → 401; повторный logout → 401 | `evidence/student-tests.txt` | +| Пароли — password KDF | `test_passwords_stored_as_argon2id` | в БД `$argon2id$…`, plaintext отсутствует | `evidence/student-tests.txt` | +| Secrets/volumes не в Git | `.gitignore` (`secrets/`, `.env`, `volumes/`, `data/`), секреты в отдельных файлах | после `init_secrets.py` и `git add -A` в индекс не попадают `secrets/` и `.env` | `.gitignore` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### Уровень 4 + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| Redis реально используется для сессий с TTL; описаны источник истины, expiry, инвалидация | код `src/sessions.py`; нагрузка | `keyspace_hits=9979 / misses=31` (свои тесты + 30 с нагрузки); TTL записи ≤ min(60 с, остаток сессии); «надгробие» при logout; без persistence — обосновано выше | раздел «Роль Redis», `evidence/load.json` | +| Параметризованные запросы | `src/storage.py` | только плейсхолдеры `%s` psycopg; в SQL подставляются лишь константные фрагменты кода | `src/storage.py` | +| Ограниченный пул и таймауты | `src/db.py`, `.env.example` | пул 1..10, ожидание 3 с, connect 3 с, statement 5 с, Redis 250 мс | `src/db.py`, `src/config.py` | +| Гонка регистрации одинакового username | `test_same_username_parallel_registration` (16 параллельных запросов, Barrier) | ровно 1×201 и 15×409; входит только победитель | `evidence/student-tests.txt` | +| Rollback составной операции | `test_unknown_member_rolls_back_whole_chat` (HTTP, FK-ошибка на 3-м участнике), `test_failure_after_inserts_leaves_nothing` (внедрённый сбой после вставки чата и 3 участников) | внутри транзакции строки были видны (1 чат, 3 участника), после — 0 и 0 | `evidence/student-tests.txt` | +| Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений | `make explain` | 52 000 сообщений, 12 000 в чате; keyset-страница после 10 000-го: Index Scan, 5 буферов, 0.04 мс; OFFSET: Seq Scan + Sort 10 051 строк, 695 буферов, 5 мс; без индекса: Seq Scan 695 буферов, 3–5 мс | `evidence/explain_history.txt` | +| Пагинация без полного скана | тот же EXPLAIN | `Index Cond: chat_id = … AND ROW(created_at,id) > ROW(…)`, читается limit+1 = 51 строка | `evidence/explain_history.txt` | +| Автотест expiry при коротком TTL | `test_session_expires_even_when_cached` на API с `SESSION_TTL_SECONDS=2` | 200, 200 (из кэша) → через TTL+1.5 с 401; logout истёкшим → 401; новый вход → 201 | `evidence/student-tests.txt` | +| Автотест logout и неверного пароля | `test_logout_revokes_only_current_session`, `test_wrong_password_and_unknown_user_look_the_same`, `test_malformed_basic_headers` | все PASS | `evidence/student-tests.txt` | +| Автотест недоступности Redis | `dependency_failure.py` | API обходит кэш: чтение/запись/вход/logout работают, max задержка 6 мс, readiness 200 | `evidence/dependency_failure.json` | +| Автотест недоступности БД | `dependency_failure.py` | live 200, ready 503; запись/чтение/вход → 503 `unavailable` за 3.0 с; анонимный → 401; неизвестный токен → 503; восстановление 0.45 с; отклонённая запись не сохранилась | `evidence/dependency_failure.json` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза 1.** Если PostgreSQL — единственный источник истины для данных и сессий, а Redis только кэш, то перезапуск всех процессов с сохранением volumes не теряет ни подтверждённых сообщений, ни действующих сессий, а потеря Redis не влияет на корректность. Подтверждено `test-persistence` (тот же токен после рестарта) и `dependency_failure.py`. + +**Гипотеза 2.** Составной индекс `(chat_id, created_at, id)` делает стоимость страницы истории независимой от глубины курсора. На 52 000 сообщениях первая и «10 000-я» страница стоят одинаково (4–5 буферов, < 0.1 мс), тогда как OFFSET и запрос без индекса читают весь чат/таблицу (695 буферов) и растут линейно с объёмом. + +**Нагрузка** (`tests/load.py`, closed-loop POST сообщений, без retry): 30 с, concurrency 4, без прогрева; 9 842 успешных запроса, 0 ошибок, 327 RPS; p50 11.8 мс, p95 17.4 мс, p99 20.9 мс (только успешные). Стенд: 2 vCPU / 8 GB, без CPU/RAM-лимитов, клиент на той же машине; CPU/RAM процессов не измерялись. Это пропускная способность HTTP-подтверждений в этом профиле, а не максимум системы. Для сравнения, lab1 (in-memory) на другом ноутбуке давала 254 RPS — значения разных машин несопоставимы. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Рестарт API + PostgreSQL + Redis (hook) | данные и сессии сохраняются | тот же токен читает ту же историю; пользователей и сессий столько же | готовность через 2.6 с после начала hook; потерь нет | +| Остановка Redis | обход кэша, работа через PostgreSQL | все операции 200/201/204, max 6 мс, readiness 200 | без восстановления; после возврата кэш наполняется заново | +| Остановка PostgreSQL | 503 на данные, 401 анониму, live 200 | 503 `unavailable` за 3.0 с, ready 503, аноним 401 | 0.45 с после старта БД; запись во время отказа не сохранена (клиент получил 503) | +| 16 одинаковых регистраций одновременно | ровно одна успешна | 1×201, 15×409 | — | +| Сбой между INSERT chats и chat_members | полный откат | 0 строк чата и участников | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один API, одна PostgreSQL, один Redis на одном Docker-host: отказ host или диска БД не выдерживается; репликации и бэкапов нет (бэкап/восстановление — трек 2 уровня 5, не заявлен). +- Durability зависит от настроек PostgreSQL по умолчанию (`fsync=on`, `synchronous_commit=on`): подтверждённый 201 означает COMMIT, записанный в WAL на локальный диск. +- Окно кэша: если logout выполнен при недоступном Redis, а Redis при этом не перезапускался (сетевой разрыв), отозванный токен может приниматься из кэша до `SESSION_CACHE_TTL_SECONDS` (60 с). При рестарте Redis кэш пуст, и окна нет. Сокращается уменьшением TTL кэша. +- При недоступной БД токен из кэша ещё ≤ 60 с проходит аутентификацию, но операции с данными получают 503. +- Basic/Bearer идут по HTTP — допустимо только на локальном учебном стенде; TLS — lab7. +- Пароль Redis передаётся в `redis-server` аргументом командной строки внутри контейнера (виден в списке процессов контейнера); hardening — lab7. +- Приложенные результаты сняты на нативном стенде без Docker (см. «Доказательства»); compose-конфигурация проверена `docker compose config`, перед сдачей нужно прогнать те же сценарии на compose. +- Следующие шаги (lab3): несколько реплик API за балансировщиком уже совместимы с выбранной схемой (сессии в общей БД, кэш в общем Redis, миграции под advisory lock); нужно добавить `Idempotency-Key` и `X-Instance-Id`. + +## Вопросы защиты — кратко + +- **Что подтверждает COMMIT?** Что транзакция записана в WAL и после сбоя процесса/рестарта будет видна. Гарантия зависит от `fsync`, `synchronous_commit` и от того, что диск действительно сбрасывает кэш; потеря самого volume не покрывается. +- **Где сессии и что после flush/restart Redis?** В PostgreSQL. Redis — кэш; после flush следующие запросы проверяют токен в PostgreSQL и заново кладут его в кэш, пользователи не разлогиниваются. +- **Аутентификация vs доступ к чату:** аутентификация отвечает «кто это» (Bearer → user_id), авторизация — «может ли этот пользователь работать с этим чатом» (строка в `chat_members`); посторонний получает 404. +- **Hash пароля vs checksum:** KDF (Argon2id) намеренно медленный и с солью, чтобы перебор слабого пароля по утёкшей базе был дорогим; быстрый checksum (SHA-256) нужен для целостности/поиска и годится для токена только потому, что токен — 256 случайных бит. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..f826cc8 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,104 @@ +# Лабораторная 2: API + PostgreSQL + Redis. +# Перед первым запуском: python scripts/init_secrets.py && cp .env.example .env +name: messenger-lab2 + +x-api: &api + build: . + image: messenger-api:lab2 + restart: unless-stopped + environment: &api-env + APP_ENV: ${APP_ENV:-lab} + SESSION_STORE: postgres + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-3} + DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + CACHE_TIMEOUT_SECONDS: ${CACHE_TIMEOUT_SECONDS:-0.25} + CACHE_RETRY_AFTER_SECONDS: ${CACHE_RETRY_AFTER_SECONDS:-5} + secrets: + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + networks: [backend] + stop_grace_period: 15s + +services: + api: + <<: *api + ports: + - "127.0.0.1:${APP_PORT:-8080}:8080" + + # Второй экземпляр с коротким TTL — только для автотеста истечения сессии. + # Запуск: docker compose --profile ttl up -d api-short-ttl + api-short-ttl: + <<: *api + profiles: [ttl] + environment: + <<: *api-env + SESSION_TTL_SECONDS: ${SHORT_SESSION_TTL_SECONDS:-2} + ports: + - "127.0.0.1:8081:8080" + + postgres: + image: postgres:16.4-alpine + restart: unless-stopped + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -h 127.0.0.1"] + interval: 3s + timeout: 3s + retries: 20 + start_period: 10s + networks: [backend] + stop_grace_period: 30s + + redis: + image: redis:7.4.1-alpine + restart: unless-stopped + user: redis + # Только кэш: без RDB/AOF, ограничение памяти и LRU-вытеснение. + # Пароль читается из secret, в compose.yaml и env его нет. + command: + - sh + - -c + - exec redis-server --requirepass "$$(cat /run/secrets/redis_password)" --save "" --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru + secrets: + - redis_password + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"] + interval: 3s + timeout: 3s + retries: 20 + networks: [backend] + +volumes: + pgdata: + +networks: + backend: + +secrets: + postgres_password: + file: ./secrets/postgres_password + redis_password: + file: ./secrets/redis_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..d63b181 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,4 @@ +$ 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. diff --git a/evidence/dependency_failure.json b/evidence/dependency_failure.json new file mode 100644 index 0000000..6a26336 --- /dev/null +++ b/evidence/dependency_failure.json @@ -0,0 +1,117 @@ +{ + "base_url": "http://127.0.0.1:8080", + "timings": { + "redis_down_first_request_s": 0.0, + "redis_down_max_write_s": 0.031, + "postgres_down_write_s": 3.0, + "postgres_recovery_s": 0.02 + }, + "checks": [ + { + "check": "redis down: existing token still valid via PostgreSQL", + "ok": true, + "detail": "0.000s" + }, + { + "check": "redis down: writes succeed", + "ok": true, + "detail": "" + }, + { + "check": "redis down: bounded latency", + "ok": true, + "detail": "max 0.031s over 10 requests" + }, + { + "check": "redis down: readiness stays 200 (cache is not critical)", + "ok": true, + "detail": "" + }, + { + "check": "redis down: login works", + "ok": true, + "detail": "" + }, + { + "check": "redis down: logout works", + "ok": true, + "detail": "" + }, + { + "check": "redis down: revoked token rejected", + "ok": true, + "detail": "" + }, + { + "check": "redis down: anonymous rejected", + "ok": true, + "detail": "" + }, + { + "check": "redis down: unknown token rejected", + "ok": true, + "detail": "" + }, + { + "check": "redis back: requests ok", + "ok": true, + "detail": "" + }, + { + "check": "postgres down: liveness 200", + "ok": true, + "detail": "" + }, + { + "check": "postgres down: readiness 503 unavailable", + "ok": true, + "detail": "3.000s" + }, + { + "check": "postgres down: anonymous -> 401 (not trusted)", + "ok": true, + "detail": "status 401" + }, + { + "check": "postgres down: unknown token is not accepted (503)", + "ok": true, + "detail": "status 503, 3.000s" + }, + { + "check": "postgres down: write -> 503 within bound", + "ok": true, + "detail": "status 503, 3.000s" + }, + { + "check": "postgres down: history read -> 503", + "ok": true, + "detail": "status 503" + }, + { + "check": "postgres down: login -> 503 (not 401, not 201)", + "ok": true, + "detail": "status 503" + }, + { + "check": "postgres down: error hides internals", + "ok": true, + "detail": "" + }, + { + "check": "postgres back: readiness recovered", + "ok": true, + "detail": "0.0s" + }, + { + "check": "postgres back: same token reads intact history", + "ok": true, + "detail": "" + }, + { + "check": "postgres back: rejected write was not stored", + "ok": true, + "detail": "" + } + ], + "passed": true +} diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt new file mode 100644 index 0000000..3a56f62 Binary files /dev/null and b/evidence/explain_history.txt differ diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 0000000..ab9cdc2 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.096, + "concurrency": 4, + "successful_requests": 9842, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 327.024, + "successful_latency_ms": { + "p50": 11.831, + "p95": 17.414, + "p99": 20.949 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..16003a8 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +$ make test-persistence ACTION_SCRIPT= +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/restart_processes.txt b/evidence/restart_processes.txt new file mode 100644 index 0000000..78a29d8 --- /dev/null +++ b/evidence/restart_processes.txt @@ -0,0 +1,3 @@ +# Локальный стенд без Docker (PID процессов до/после restart hook; volumes = каталоги данных сохраняются) +before: postgres=1212 redis=1222 api=1228 users_in_db=51 sessions_in_db=42 +after: postgres=1269 redis=1279 api=1286 users_in_db=51 sessions_in_db=42 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..fbad974 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +$ make test BASE_URL=http://127.0.0.1:8080 +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 0000000..f7e46bd --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,42 @@ +$ python student-tests/run_all.py --base-url http://127.0.0.1:8080 --expiry-url http://127.0.0.1:8081 + +== API, auth, concurrency, rollback, expiry tests +test_chat_list_pagination (test_api.ApiBehaviorTests.test_chat_list_pagination) ... ok +test_cursor_from_other_chat_returns_400 (test_api.ApiBehaviorTests.test_cursor_from_other_chat_returns_400) ... ok +test_duplicate_username_returns_409 (test_api.ApiBehaviorTests.test_duplicate_username_returns_409) ... ok +test_empty_message_returns_400 (test_api.ApiBehaviorTests.test_empty_message_returns_400) ... ok +test_malformed_json_returns_400 (test_api.ApiBehaviorTests.test_malformed_json_returns_400) ... ok +test_naive_timestamp_cursor_returns_400 (test_api.ApiBehaviorTests.test_naive_timestamp_cursor_returns_400) ... ok +test_outsider_cannot_access_chat (test_api.ApiBehaviorTests.test_outsider_cannot_access_chat) ... ok +test_pagination_returns_all_messages_without_duplicates (test_api.ApiBehaviorTests.test_pagination_returns_all_messages_without_duplicates) ... ok +test_password_never_returned (test_api.ApiBehaviorTests.test_password_never_returned) ... ok +test_registration_without_password_returns_400 (test_api.ApiBehaviorTests.test_registration_without_password_returns_400) ... ok +test_sender_id_in_body_rejected (test_api.ApiBehaviorTests.test_sender_id_in_body_rejected) ... ok +test_short_password_returns_400 (test_api.ApiBehaviorTests.test_short_password_returns_400) ... ok +test_basic_on_business_endpoint_rejected (test_auth.AuthTests.test_basic_on_business_endpoint_rejected) ... ok +test_logout_revokes_only_current_session (test_auth.AuthTests.test_logout_revokes_only_current_session) ... ok +test_malformed_basic_headers (test_auth.AuthTests.test_malformed_basic_headers) ... ok +test_password_with_colon_and_unicode (test_auth.AuthTests.test_password_with_colon_and_unicode) ... ok +test_session_shape_and_token_entropy (test_auth.AuthTests.test_session_shape_and_token_entropy) ... ok +test_unknown_and_garbage_tokens (test_auth.AuthTests.test_unknown_and_garbage_tokens) ... ok +test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTests.test_wrong_password_and_unknown_user_look_the_same) ... ok +test_x_user_id_gives_no_access (test_auth.AuthTests.test_x_user_id_gives_no_access) ... ok +test_duplicate_and_missing_caller_rejected (test_concurrency.ChatRollbackTests.test_duplicate_and_missing_caller_rejected) ... ok +test_unknown_member_rolls_back_whole_chat (test_concurrency.ChatRollbackTests.test_unknown_member_rolls_back_whole_chat) +Чат вставляется первым, затем участники по порядку (сначала сам владелец). ... ok +test_same_username_parallel_registration (test_concurrency.RegistrationRaceTests.test_same_username_parallel_registration) ... ok +test_session_expires_even_when_cached (test_expiry.ExpiryTests.test_session_expires_even_when_cached) ... ok +test_failure_after_inserts_leaves_nothing (test_storage_rollback.StorageRollbackTests.test_failure_after_inserts_leaves_nothing) ... ok +test_migrations_are_idempotent (test_storage_rollback.StorageRollbackTests.test_migrations_are_idempotent) ... ok +test_no_orphan_chats_in_database (test_storage_rollback.StorageRollbackTests.test_no_orphan_chats_in_database) ... ok +test_passwords_stored_as_argon2id (test_storage_rollback.StorageRollbackTests.test_passwords_stored_as_argon2id) ... ok + +---------------------------------------------------------------------- +Ran 28 tests in 6.224s + +OK + +== Concurrent write test +PASS: concurrent write test; 10 clients x 10 messages = 100 messages; no lost or duplicate messages + +ALL STUDENT TESTS PASSED diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..1bfb18f --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,66 @@ +-- 001_init: базовая схема мессенджера lab2. +-- Применяется src/migrate.py ровно один раз (таблица schema_migrations), +-- внутри одной транзакции; повторный запуск миграций ничего не дублирует. + +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 DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +-- Список чатов пользователя: WHERE user_id = ? ORDER BY (created_at, id) +CREATE INDEX chats_created_at_id_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + position smallint NOT NULL, + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_key UNIQUE (chat_id, position) +); + +-- "В каких чатах состоит пользователь" (GET /chats) +CREATE INDEX chat_members_user_id_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) ON DELETE RESTRICT, + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + 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 $4 +-- Обоснование и EXPLAIN (ANALYZE, BUFFERS): evidence/explain_history.txt +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +-- Серверные сессии. Источник истины для сессий — PostgreSQL; +-- Redis хранит только кэш проверок токена (см. REPORT.md). +-- Хранится SHA-256 от токена, сам токен в БД не попадает. +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32), + CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at) +); + +CREATE INDEX sessions_user_id_idx ON sessions (user_id); +CREATE INDEX sessions_expires_at_idx ON sessions (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3810a15 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +fastapi==0.115.6 +uvicorn==0.34.0 +pydantic==2.10.4 +psycopg[binary]==3.2.3 +psycopg-pool==3.2.4 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 0000000..49de415 --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Создаёт локальные учебные секреты в ./secrets (каталог в .gitignore). + +Повторный запуск ничего не перезаписывает: пароль PostgreSQL задаётся только +при первой инициализации volume, и смена файла сломала бы подключение. +Значения секретов не печатаются. +""" +import os +import secrets +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +DIR = ROOT / "secrets" + + +def write(name: str, value: str) -> None: + path = DIR / name + if path.exists(): + print("keep secrets/%s" % name) + return + path.write_text(value + "\n", encoding="utf-8") + # Каталог 0700, файлы 0644: внутри контейнера их читают непривилегированные + # пользователи (appuser, redis), а на хосте каталог закрыт. + os.chmod(path, 0o644) + print("create secrets/%s" % name) + + +def read(name: str) -> str: + return (DIR / name).read_text(encoding="utf-8").strip() + + +def main() -> None: + DIR.mkdir(exist_ok=True) + try: + os.chmod(DIR, 0o700) + except OSError: + pass + write("postgres_password", secrets.token_hex(24)) + write("redis_password", secrets.token_hex(24)) + write("database_url", "postgresql://messenger:%s@postgres:5432/messenger" % read("postgres_password")) + write("cache_url", "redis://:%s@redis:6379/0" % read("redis_password")) + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..4c2970d --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,10 @@ +@echo off +rem Windows-вариант restart.sh (Docker Desktop): API и все хранилища, volumes сохраняются. +setlocal +cd /d "%~dp0.." +set ENVARG= +if exist .env set ENVARG=--env-file .env +docker compose %ENVARG% stop api >nul || exit /b 1 +docker compose %ENVARG% restart postgres redis >nul || exit /b 1 +docker compose %ENVARG% up -d --wait api >nul || exit /b 1 +exit /b 0 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..d7f4096 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,16 @@ +#!/bin/sh +# Restart hook для make test-persistence: перезапускает API и ВСЕ хранилища +# (PostgreSQL, Redis), сохраняя volumes. Никаких down -v / flush / повторного seed. +set -eu +cd "$(dirname "$0")/.." +COMPOSE="docker compose --env-file ${ENV_FILE:-.env}" +[ -f "${ENV_FILE:-.env}" ] || COMPOSE="docker compose" + +# 1. Останавливаем API, чтобы он не писал во время рестарта хранилищ. +$COMPOSE stop api >/dev/null +# 2. Перезапуск хранилищ: PostgreSQL выполняет штатный shutdown (checkpoint), +# данные остаются в именованном volume pgdata; Redis-кэш стартует пустым. +$COMPOSE restart postgres redis >/dev/null +# 3. API стартует после healthcheck зависимостей (depends_on: service_healthy). +$COMPOSE up -d --wait api >/dev/null +exit 0 diff --git a/scripts/sql/explain_history.sql b/scripts/sql/explain_history.sql new file mode 100644 index 0000000..d2ee413 --- /dev/null +++ b/scripts/sql/explain_history.sql @@ -0,0 +1,93 @@ +-- Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на >= 10 000 сообщений. +-- Всё выполняется в ОДНОЙ транзакции и откатывается (ROLLBACK): синтетические +-- данные и временное удаление индекса не остаются в БД. +-- Запуск (compose): +-- docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 \ +-- < scripts/sql/explain_history.sql > evidence/explain_history.txt +-- Внимание: DROP INDEX внутри транзакции берёт эксклюзивную блокировку messages +-- до ROLLBACK (несколько секунд) — запускать на учебном стенде. + +\set ON_ERROR_STOP 1 +\timing off +SET TimeZone = 'UTC'; +-- Убираем мёртвые версии строк от прошлых запусков (VACUUM нельзя внутри транзакции). +VACUUM (ANALYZE) messages, chat_members, chats, users; +BEGIN; + +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('00000000-0000-4000-8000-00000000e001', 'explain_alice', 'Explain', 'x'), + ('00000000-0000-4000-8000-00000000e002', 'explain_bob', 'Explain', 'x'); + +-- 1 большой чат (12 000 сообщений) + 40 чатов по 1 000 = 52 000 сообщений. +INSERT INTO chats (id, title, created_at) +SELECT CASE WHEN g = 0 THEN '00000000-0000-4000-8000-0000000c0000'::uuid ELSE gen_random_uuid() END, + 'explain-' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM generate_series(0, 40) AS g; + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT c.id, u.id, u.pos +FROM chats c +CROSS JOIN (VALUES ('00000000-0000-4000-8000-00000000e001'::uuid, 0), + ('00000000-0000-4000-8000-00000000e002'::uuid, 1)) AS u(id, pos) +WHERE c.title LIKE 'explain-%'; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), c.id, + CASE WHEN g % 2 = 0 THEN '00000000-0000-4000-8000-00000000e001'::uuid + ELSE '00000000-0000-4000-8000-00000000e002'::uuid END, + 'synthetic message ' || g, + timestamptz '2026-01-02 00:00:00+00' + g * interval '1 millisecond' + (c.created_at - timestamptz '2026-01-01 00:00:00+00') +FROM chats c +CROSS JOIN LATERAL generate_series(1, CASE WHEN c.title = 'explain-0' THEN 12000 ELSE 1000 END) AS g +WHERE c.title LIKE 'explain-%'; + +ANALYZE users, chats, chat_members, messages; + +\echo '=== dataset' +SELECT count(*) AS total_messages, + count(*) FILTER (WHERE chat_id = '00000000-0000-4000-8000-0000000c0000') AS big_chat_messages +FROM messages; + +-- Позиция курсора после 10 000-го сообщения большого чата (как в next_cursor). +SELECT created_at AS cur_ts, id AS cur_id +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id OFFSET 9999 LIMIT 1 \gset + +\echo '=== 1. first page (no cursor), LIMIT 51 = limit+1' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id +LIMIT 51; + +\echo '=== 2. deep page: keyset cursor after message #10000 (query used by API)' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' + AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id +LIMIT 51; + +\echo '=== 3. for comparison: OFFSET pagination to the same page (NOT used by API)' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id +OFFSET 10000 LIMIT 51; + +\echo '=== 4. same keyset query WITHOUT messages_chat_created_id_idx (index dropped inside the transaction)' +DROP INDEX messages_chat_created_id_idx; +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' + AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id +LIMIT 51; + +ROLLBACK; +\echo '=== rolled back: synthetic data removed, index restored' diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/config.py b/src/config.py new file mode 100644 index 0000000..10c4146 --- /dev/null +++ b/src/config.py @@ -0,0 +1,84 @@ +"""Конфигурация из переменных окружения. + +Секреты (строки подключения с паролями) читаются из файлов *_FILE, +которые Compose монтирует как secrets в /run/secrets/. Для локального +запуска без Docker допускаются и прямые переменные DATABASE_URL / CACHE_URL. +""" +import os +from dataclasses import dataclass +from typing import Optional + + +def _read_secret(name: str) -> Optional[str]: + path = os.environ.get(name + "_FILE") + if path: + with open(path, "r", encoding="utf-8") as handle: + value = handle.read().strip() + return value or None + value = os.environ.get(name, "").strip() + return value or None + + +def _int(name: str, default: int) -> int: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + return int(raw) + + +def _float(name: str, default: float) -> float: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + return float(raw) + + +@dataclass(frozen=True) +class Settings: + app_env: str + database_url: str + cache_url: Optional[str] + session_store: str + session_ttl_seconds: int + session_cache_ttl_seconds: int + db_pool_min: int + db_pool_max: int + db_pool_timeout: float + db_connect_timeout: int + db_statement_timeout_ms: int + cache_timeout_seconds: float + cache_retry_after_seconds: float + migrate_wait_seconds: int + + +def load_settings() -> Settings: + database_url = _read_secret("DATABASE_URL") + if not database_url: + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE must be set") + + ttl = _int("SESSION_TTL_SECONDS", 3600) + if ttl < 1: + raise RuntimeError("SESSION_TTL_SECONDS must be positive") + + session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower() + # Источник истины для сессий в этой реализации всегда PostgreSQL; + # Redis (CACHE_URL) — только кэш проверок токена. + if session_store != "postgres": + raise RuntimeError("only SESSION_STORE=postgres is supported") + + return Settings( + app_env=os.environ.get("APP_ENV", "lab"), + database_url=database_url, + cache_url=_read_secret("CACHE_URL"), + session_store=session_store, + session_ttl_seconds=ttl, + session_cache_ttl_seconds=_int("SESSION_CACHE_TTL_SECONDS", 60), + db_pool_min=_int("DB_POOL_MIN", 1), + db_pool_max=_int("DB_POOL_MAX", 10), + db_pool_timeout=_float("DB_POOL_TIMEOUT_SECONDS", 3.0), + db_connect_timeout=_int("DB_CONNECT_TIMEOUT_SECONDS", 3), + db_statement_timeout_ms=_int("DB_STATEMENT_TIMEOUT_MS", 5000), + cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.25), + cache_retry_after_seconds=_float("CACHE_RETRY_AFTER_SECONDS", 5.0), + migrate_wait_seconds=_int("MIGRATE_WAIT_SECONDS", 60), + ) diff --git a/src/db.py b/src/db.py new file mode 100644 index 0000000..e2b4120 --- /dev/null +++ b/src/db.py @@ -0,0 +1,108 @@ +"""Пул соединений PostgreSQL и версионируемые миграции.""" +import logging +import time +from pathlib import Path +from typing import Optional + +import psycopg +from psycopg_pool import ConnectionPool + +from .config import Settings + +log = logging.getLogger("messenger.db") + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + +# Произвольная константа: один процесс за раз применяет миграции, +# даже если одновременно стартуют несколько реплик API (lab3). +MIGRATION_LOCK_ID = 2026_0002 + + +def conninfo_kwargs(settings: Settings) -> dict: + return { + "connect_timeout": settings.db_connect_timeout, + # Все timestamptz приходят в UTC; любой запрос ограничен по времени. + "options": "-c TimeZone=UTC -c statement_timeout=%d" + % settings.db_statement_timeout_ms, + "application_name": "messenger-api", + } + + +def create_pool(settings: Settings) -> ConnectionPool: + pool = ConnectionPool( + conninfo=settings.database_url, + kwargs=conninfo_kwargs(settings), + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + # Сколько запрос ждёт свободное соединение, прежде чем получить 503. + timeout=settings.db_pool_timeout, + # Битые после рестарта БД соединения отбрасываются при выдаче из пула. + check=ConnectionPool.check_connection, + max_idle=300, + reconnect_timeout=3600, + open=False, + name="messenger", + ) + # wait=False: процесс поднимается, даже если БД ещё/уже недоступна; + # readiness это покажет, а запросы получат 503. + pool.open(wait=False) + return pool + + +def _migration_files(): + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + if not files: + raise RuntimeError("no migrations found in %s" % MIGRATIONS_DIR) + return files + + +def apply_migrations(settings: Settings) -> list: + """Применяет недостающие миграции; возвращает список применённых версий.""" + applied_now = [] + with psycopg.connect( + settings.database_url, autocommit=True, **conninfo_kwargs(settings) + ) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,)) + try: + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + ) + """ + ) + done = { + row[0] + for row in conn.execute("SELECT version FROM schema_migrations") + } + for path in _migration_files(): + version = path.stem + if version in done: + continue + sql = path.read_text(encoding="utf-8") + # DDL и отметка о версии — одна транзакция: либо всё, либо ничего. + with conn.transaction(): + conn.execute(sql) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", + (version,), + ) + applied_now.append(version) + log.info("applied migration %s", version) + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,)) + return applied_now + + +def wait_and_migrate(settings: Settings) -> list: + deadline = time.monotonic() + settings.migrate_wait_seconds + last_error: Optional[Exception] = None + while time.monotonic() < deadline: + try: + return apply_migrations(settings) + except psycopg.OperationalError as exc: + last_error = exc + log.warning("database not ready for migrations, retrying") + time.sleep(1) + raise RuntimeError("database unavailable for migrations") from last_error diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..f46ec51 --- /dev/null +++ b/src/main.py @@ -0,0 +1,367 @@ +import base64 +import json +import logging +import re +from contextlib import asynccontextmanager +from datetime import datetime +from typing import Any, Callable, Dict, Optional, Tuple +from uuid import UUID, uuid4 + +import psycopg +from fastapi import Depends, FastAPI, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from psycopg_pool import PoolTimeout +from starlette.exceptions import HTTPException as StarletteHTTPException +from starlette.middleware.base import BaseHTTPMiddleware + +from .config import load_settings +from .db import create_pool, wait_and_migrate +from .models import ( + Chat, + ChatCreate, + ChatPage, + Message, + MessageCreate, + MessagePage, + Session, + User, + UserCreate, +) +from .security import hash_password, parse_basic, parse_bearer, verify_password +from .sessions import SessionCache, SessionService +from .storage import Storage, UnknownMember, UsernameTaken + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") +log = logging.getLogger("messenger.api") + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' +REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + settings = load_settings() + applied = wait_and_migrate(settings) + log.info("migrations applied at startup: %s", applied or "none") + pool = create_pool(settings) + storage = Storage(pool) + cache = SessionCache(settings) + app.state.settings = settings + app.state.storage = storage + app.state.cache = cache + app.state.sessions = SessionService(storage, cache, settings) + log.info( + "started: session_ttl=%ss cache=%s pool=%s..%s", + settings.session_ttl_seconds, + "redis" if cache.client is not None else "disabled", + settings.db_pool_min, + settings.db_pool_max, + ) + try: + yield + finally: + pool.close() + if cache.client is not None: + cache.client.close() + + +app = FastAPI( + title="MTUSI Messenger (PostgreSQL + Redis)", + version="2.0.0", + lifespan=lifespan, +) + + +# Request ID + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch(self, request: Request, call_next: Callable): + incoming = request.headers.get("X-Request-Id", "") + request_id = incoming if REQUEST_ID_RE.match(incoming) else str(uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + + +app.add_middleware(RequestIdMiddleware) + + +# errors + +class ApiError(Exception): + def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None): + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers or {} + + +def unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError: + return ApiError(401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge}) + + +def bad_request(message: str = "Invalid request") -> ApiError: + return ApiError(400, "invalid_request", message) + + +def not_found() -> ApiError: + return ApiError(404, "not_found", "Not found") + + +def error_response( + request: Request, + status_code: int, + code: str, + message: str, + headers: Optional[Dict[str, str]] = None, +) -> JSONResponse: + request_id = getattr(request.state, "request_id", None) or str(uuid4()) + all_headers = {"X-Request-Id": request_id} + all_headers.update(headers or {}) + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=all_headers, + ) + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse: + return error_response(request, exc.status_code, exc.code, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse: + return error_response(request, 400, "invalid_request", "Invalid request") + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse: + status_to_code = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 503: "unavailable", + } + status_code = exc.status_code if exc.status_code in status_to_code else 500 + code = status_to_code.get(status_code, "internal_error") + message = str(exc.detail) if status_code != 500 else "Internal server error" + return error_response(request, status_code, code, message) + + +async def dependency_unavailable(request: Request, exc: Exception) -> JSONResponse: + # Наружу — только общий 503, без SQL, адресов и текста драйвера. + log.warning("database unavailable: %s", type(exc).__name__) + return error_response(request, 503, "unavailable", "Service temporarily unavailable") + + +app.add_exception_handler(psycopg.OperationalError, dependency_unavailable) +app.add_exception_handler(psycopg.InterfaceError, dependency_unavailable) +app.add_exception_handler(PoolTimeout, dependency_unavailable) + + +@app.exception_handler(Exception) +async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse: + log.exception("unexpected error") + return error_response(request, 500, "internal_error", "Internal server error") + + +# helpers + +def require_json_content_type(request: Request) -> None: + content_type = request.headers.get("content-type", "") + if not content_type.lower().startswith("application/json"): + raise ApiError(415, "unsupported_media_type", "Unsupported media type") + + +def ensure_not_blank(value: str) -> None: + if not value.strip(): + raise bad_request() + + +def storage_of(request: Request) -> Storage: + return request.app.state.storage + + +def current_user(request: Request) -> User: + """Только Authorization: Bearer. Basic и X-User-Id здесь не дают доступа.""" + token = parse_bearer(request.headers.get("Authorization")) + if token is None: + raise unauthorized() + user = request.app.state.sessions.resolve(token) + if user is None: + raise unauthorized() + request.state.token = token + return user + + +def encode_cursor(resource_id: UUID, created_at: datetime, item_id: UUID) -> str: + payload = { + "resource_id": str(resource_id), + "created_at": created_at.isoformat(), + "item_id": str(item_id), + } + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(cursor: Optional[str], expected_resource_id: UUID) -> Optional[Tuple[datetime, UUID]]: + if cursor is None: + return None + try: + padding = "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(cursor + padding) + payload = json.loads(raw.decode("utf-8")) + resource_id = UUID(payload["resource_id"]) + created_at = datetime.fromisoformat(payload["created_at"]) + item_id = UUID(payload["item_id"]) + if created_at.tzinfo is None or created_at.utcoffset() is None: + raise ValueError("invalid_cursor") + except (ValueError, KeyError, TypeError, AttributeError, json.JSONDecodeError): + raise bad_request("Invalid cursor") + if resource_id != expected_resource_id: + raise bad_request("Invalid cursor") + return created_at, item_id + + +# health + +@app.get("/health/live", response_model=Dict[str, str]) +def liveness() -> Dict[str, str]: + return {"status": "ok"} + + +@app.get("/health/ready", response_model=Dict[str, str]) +def readiness(request: Request) -> Dict[str, str]: + # Критична только PostgreSQL. Redis — кэш с обходом, его отказ не делает + # API неготовым (см. REPORT.md). + try: + storage_of(request).ping() + except (psycopg.Error, PoolTimeout): + raise ApiError(503, "unavailable", "Database is not available") + return {"status": "ok"} + + +# users + +@app.post("/api/v1/users", response_model=User, status_code=201) +def register_user(request: Request, data: UserCreate) -> User: + require_json_content_type(request) + ensure_not_blank(data.display_name) + ensure_not_blank(data.password) + password_hash = hash_password(data.password) + try: + return storage_of(request).create_user(data.username, data.display_name, password_hash) + except UsernameTaken: + raise ApiError(409, "conflict", "Username already exists") + + +@app.get("/api/v1/users/me", response_model=User) +def get_current_user(user: User = Depends(current_user)) -> User: + return user + + +# sessions + +@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201) +def create_session(request: Request) -> Session: + credentials = parse_basic(request.headers.get("Authorization")) + if credentials is None: + raise unauthorized(BASIC_CHALLENGE) + username, password = credentials + found = storage_of(request).get_credentials(username) + user, password_hash = found if found else (None, None) + # verify_password выполняется и для несуществующего username (с хешем-пустышкой). + if not verify_password(password_hash, password) or user is None: + raise unauthorized(BASIC_CHALLENGE) + token, expires_at = request.app.state.sessions.create(user) + return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user) + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def delete_current_session(request: Request, user: User = Depends(current_user)) -> Response: + if not request.app.state.sessions.revoke(request.state.token): + raise unauthorized() + return Response(status_code=204) + + +# chats + +@app.post("/api/v1/chats", response_model=Chat, status_code=201) +def create_chat(request: Request, data: ChatCreate, user: User = Depends(current_user)) -> Chat: + require_json_content_type(request) + ensure_not_blank(data.title) + if len(data.member_ids) != len(set(data.member_ids)): + raise bad_request("Duplicate member ids") + if user.id not in data.member_ids: + raise bad_request("Caller must be a chat member") + try: + return storage_of(request).create_chat(data.title, data.member_ids) + except UnknownMember: + raise bad_request("Unknown member") + + +@app.get("/api/v1/chats", response_model=ChatPage) +def list_chats( + request: Request, + user: User = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +) -> ChatPage: + after = decode_cursor(cursor, user.id) + items, has_more = storage_of(request).list_user_chats(user.id, limit, after) + next_cursor = None + if has_more and items: + next_cursor = encode_cursor(user.id, items[-1].created_at, items[-1].id) + return ChatPage(items=items, next_cursor=next_cursor) + + +@app.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat(request: Request, chat_id: UUID, user: User = Depends(current_user)) -> Chat: + chat = storage_of(request).get_chat_for_member(chat_id, user.id) + if chat is None: + raise not_found() + return chat + + +# messages + +@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) +def create_message( + request: Request, + chat_id: UUID, + data: MessageCreate, + user: User = Depends(current_user), +) -> Message: + require_json_content_type(request) + ensure_not_blank(data.text) + message = storage_of(request).create_message(chat_id, user.id, data.text) + if message is None: + raise not_found() + return message + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +def list_messages( + request: Request, + chat_id: UUID, + user: User = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +) -> MessagePage: + after = decode_cursor(cursor, chat_id) + result = storage_of(request).list_messages(chat_id, user.id, limit, after) + if result is None: + raise not_found() + items, has_more = result + next_cursor = None + if has_more and items: + next_cursor = encode_cursor(chat_id, items[-1].created_at, items[-1].id) + return MessagePage(items=items, next_cursor=next_cursor) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 0000000..4f6bb67 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,22 @@ +"""Ручной запуск миграций: python -m src.migrate + +API применяет миграции и сам при старте; команда нужна для явного bootstrap +и для демонстрации, что повторный запуск ничего не меняет. +""" +import logging + +from .config import load_settings +from .db import wait_and_migrate + + +def main() -> None: + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message)s") + applied = wait_and_migrate(load_settings()) + if applied: + print("applied migrations: " + ", ".join(applied)) + else: + print("schema is up to date; nothing applied") + + +if __name__ == "__main__": + main() diff --git a/src/models.py b/src/models.py new file mode 100644 index 0000000..2a4dfc1 --- /dev/null +++ b/src/models.py @@ -0,0 +1,83 @@ +from datetime import datetime +from typing import List, Optional +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field + + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid") + + +class UserCreate(StrictModel): + username: str = Field( + min_length=3, + max_length=32, + pattern=r"^[a-z0-9_]{3,32}$", + ) + display_name: str = Field( + min_length=1, + max_length=100, + ) + # lab2: пароль обязателен; длина в Unicode code points (len() в Python). + password: str = Field( + min_length=12, + max_length=128, + ) + + +class User(StrictModel): + id: UUID + username: str + display_name: str + created_at: datetime + + +class Session(StrictModel): + token: str + token_type: str = "Bearer" + expires_at: datetime + user: User + + +class ChatCreate(StrictModel): + title: str = Field( + min_length=1, + max_length=100, + ) + member_ids: List[UUID] = Field( + min_length=1, + max_length=100, + ) + + +class Chat(StrictModel): + id: UUID + title: str + member_ids: List[UUID] + created_at: datetime + + +class MessageCreate(StrictModel): + text: str = Field( + min_length=1, + max_length=4000, + ) + + +class Message(StrictModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + +class ChatPage(StrictModel): + items: List[Chat] + next_cursor: Optional[str] + + +class MessagePage(StrictModel): + items: List[Message] + next_cursor: Optional[str] diff --git a/src/security.py b/src/security.py new file mode 100644 index 0000000..252ca00 --- /dev/null +++ b/src/security.py @@ -0,0 +1,82 @@ +"""Пароли, разбор Basic/Bearer и генерация токенов.""" +import base64 +import binascii +import hashlib +import re +import secrets +from typing import Optional, Tuple + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + +# Argon2id (библиотека argon2-cffi). Параметры — рекомендация OWASP для +# Argon2id: m=19 MiB, t=2, p=1. Пароль хешируется целиком в UTF-8, без усечения. +_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1) + +# Хеш-«пустышка»: проверка для несуществующего пользователя стоит столько же, +# сколько для существующего, — время ответа не выдаёт наличие username. +_DUMMY_HASH = _hasher.hash("dummy-password-for-timing-equalization") + +# 32 байта случайности = 256 бит энтропии; base64url без padding = 43 символа. +TOKEN_BYTES = 32 +MAX_TOKEN_LENGTH = 256 + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password_hash: Optional[str], password: str) -> bool: + try: + return _hasher.verify(password_hash or _DUMMY_HASH, password) and bool( + password_hash + ) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +def new_token() -> str: + return secrets.token_urlsafe(TOKEN_BYTES) + + +def token_digest(token: str) -> bytes: + """Токен высокоэнтропийный, поэтому для поиска достаточно быстрого SHA-256. + + В отличие от пароля, перебор 256-битного токена невозможен, и KDF здесь + только замедлил бы каждый запрос. + """ + return hashlib.sha256(token.encode("ascii")).digest() + + +def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]: + """Authorization: Basic base64(username:password) -> (username, password).""" + if not header: + return None + scheme, _, value = header.strip().partition(" ") + if scheme.lower() != "basic" or not value.strip(): + return None + try: + raw = base64.b64decode(value.strip(), validate=True) + decoded = raw.decode("utf-8") + except (binascii.Error, ValueError, UnicodeDecodeError): + return None + username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо + if not sep or not USERNAME_RE.match(username): + return None + if not 12 <= len(password) <= 128: + return None + return username, password + + +def parse_bearer(header: Optional[str]) -> Optional[str]: + if not header: + return None + scheme, _, value = header.strip().partition(" ") + token = value.strip() + if scheme.lower() != "bearer" or not token or len(token) > MAX_TOKEN_LENGTH: + return None + if not token.isascii() or any(ch.isspace() for ch in token): + return None + return token diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 0000000..97803db --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,167 @@ +"""Сессии: PostgreSQL — источник истины, Redis — кэш проверок токена. + +Роль Redis +---------- +Каждый защищённый запрос сначала ищет `sess:` в Redis. +* попадание -> пользователь берётся из кэша, PostgreSQL не трогаем; +* промах -> читаем sessions JOIN users в PostgreSQL и кладём результат + в Redis через SET NX с TTL = min(SESSION_CACHE_TTL_SECONDS, + время до expires_at). Запись кэша никогда не переживает сессию. + +Инвалидация (logout) +-------------------- +1. UPDATE sessions SET revoked_at (COMMIT в PostgreSQL — момент отзыва); +2. SET sess: = "revoked" PX=SESSION_CACHE_TTL (обычный SET, перезаписывает). +Заполнение кэша идёт через SET NX, поэтому параллельный запрос, прочитавший +сессию до отзыва, не может перезаписать «надгробие» валидной записью. + +Отказ Redis +----------- +Любая ошибка Redis (таймаут 250 мс) -> кэш пропускается, проверка идёт в +PostgreSQL; на CACHE_RETRY_AFTER_SECONDS Redis выключается (простой +circuit breaker), чтобы не платить таймаут на каждом запросе. +Redis работает без persistence: после рестарта кэш пуст, и это безопасно — +следующие запросы просто заполнят его из PostgreSQL. +""" +import json +import logging +import threading +import time +from datetime import datetime, timezone +from typing import Optional, Tuple + +import redis + +from .config import Settings +from .models import User +from .security import new_token, token_digest +from .storage import Storage + +log = logging.getLogger("messenger.sessions") + +REVOKED = "revoked" + + +class SessionCache: + def __init__(self, settings: Settings) -> None: + self.ttl_ms = settings.session_cache_ttl_seconds * 1000 + self.retry_after = settings.cache_retry_after_seconds + self._down_until = 0.0 + self._lock = threading.Lock() + self.client: Optional[redis.Redis] = None + if settings.cache_url: + self.client = redis.Redis.from_url( + settings.cache_url, + socket_timeout=settings.cache_timeout_seconds, + socket_connect_timeout=settings.cache_timeout_seconds, + retry_on_timeout=False, + health_check_interval=30, + max_connections=20, + decode_responses=True, + ) + # Счётчики для наблюдения и тестов (GET /health/cache не нужен контракту, + # поэтому они только логируются). + self.hits = 0 + self.misses = 0 + self.errors = 0 + + @staticmethod + def key(digest: bytes) -> str: + return "sess:" + digest.hex() + + def _available(self) -> bool: + return self.client is not None and time.monotonic() >= self._down_until + + def _failed(self, exc: Exception) -> None: + with self._lock: + self.errors += 1 + if time.monotonic() >= self._down_until: + log.warning("redis unavailable (%s); bypassing cache for %.0fs", + type(exc).__name__, self.retry_after) + self._down_until = time.monotonic() + self.retry_after + + def get(self, digest: bytes): + """None — промах/кэш недоступен; REVOKED — отозвано; иначе (User, expires_at).""" + if not self._available(): + return None + try: + raw = self.client.get(self.key(digest)) + except redis.RedisError as exc: + self._failed(exc) + return None + if raw is None: + self.misses += 1 + return None + self.hits += 1 + if raw == REVOKED: + return REVOKED + try: + data = json.loads(raw) + expires_at = datetime.fromisoformat(data["expires_at"]) + return User(**data["user"]), expires_at + except (ValueError, KeyError, TypeError): + return None + + def put(self, digest: bytes, user: User, expires_at: datetime) -> None: + if not self._available(): + return + remaining_ms = int((expires_at - datetime.now(timezone.utc)).total_seconds() * 1000) + ttl = min(self.ttl_ms, remaining_ms) + if ttl <= 0: + return + value = json.dumps({"user": user.model_dump(mode="json"), "expires_at": expires_at.isoformat()}) + try: + self.client.set(self.key(digest), value, px=ttl, nx=True) + except redis.RedisError as exc: + self._failed(exc) + + def revoke(self, digest: bytes) -> None: + if self.client is None: + return + try: + self.client.set(self.key(digest), REVOKED, px=self.ttl_ms) + except redis.RedisError as exc: + self._failed(exc) + + def ping(self) -> bool: + if self.client is None: + return False + try: + return bool(self.client.ping()) + except redis.RedisError: + return False + + +class SessionService: + def __init__(self, storage: Storage, cache: SessionCache, settings: Settings) -> None: + self.storage = storage + self.cache = cache + self.ttl = settings.session_ttl_seconds + + def create(self, user: User) -> Tuple[str, datetime]: + token = new_token() + expires_at = self.storage.create_session(token_digest(token), user.id, self.ttl) + return token, expires_at + + def resolve(self, token: str) -> Optional[User]: + digest = token_digest(token) + cached = self.cache.get(digest) + if cached == REVOKED: + return None + if cached is not None: + user, expires_at = cached + if expires_at > datetime.now(timezone.utc): + return user + found = self.storage.find_session(digest) # PostgreSQL недоступна -> исключение -> 503 + if found is None: + return None + user, expires_at = found + self.cache.put(digest, user, expires_at) + return user + + def revoke(self, token: str) -> bool: + digest = token_digest(token) + revoked = self.storage.revoke_session(digest) + if revoked: + self.cache.revoke(digest) + return revoked diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 0000000..9cc8ded --- /dev/null +++ b/src/storage.py @@ -0,0 +1,261 @@ +"""Доступ к PostgreSQL. Все запросы параметризованы (%s), SQL не склеивается +со значениями пользователя. Каждая публичная операция — одна транзакция +(`with pool.connection()` делает COMMIT при успехе и ROLLBACK при исключении). +""" +from datetime import datetime, timedelta +from typing import List, Optional, Sequence, Tuple +from uuid import UUID, uuid4 + +from psycopg import errors +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +from .models import Chat, Message, User + + +class UsernameTaken(Exception): + pass + + +class UnknownMember(Exception): + pass + + +Position = Optional[Tuple[datetime, UUID]] + + +def _user(row) -> User: + return User( + id=row["id"], + username=row["username"], + display_name=row["display_name"], + created_at=row["created_at"], + ) + + +class Storage: + def __init__(self, pool: ConnectionPool) -> None: + self.pool = pool + + def ping(self) -> None: + with self.pool.connection() as conn: + conn.execute("SELECT 1") + + # users + + def create_user(self, username: str, display_name: str, password_hash: str) -> User: + try: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + INSERT INTO users (id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (uuid4(), username, display_name, password_hash), + ).fetchone() + except errors.UniqueViolation: + # Гонку двух одинаковых регистраций решает UNIQUE(username) в БД, + # а не проверка «SELECT, потом INSERT» в приложении. + raise UsernameTaken() + return _user(row) + + def get_credentials(self, username: str) -> Optional[Tuple[User, str]]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT id, username, display_name, created_at, password_hash + FROM users WHERE username = %s + """, + (username,), + ).fetchone() + if row is None: + return None + return _user(row), row["password_hash"] + + # sessions (источник истины) + + def create_session(self, token_hash: bytes, user_id: UUID, ttl_seconds: int) -> datetime: + with self.pool.connection() as conn: + # Заодно убираем давно истёкшие сессии этого пользователя. + conn.execute( + "DELETE FROM sessions WHERE user_id = %s AND expires_at < now() - interval '1 day'", + (user_id,), + ) + row = conn.execute( + """ + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s)) + RETURNING expires_at + """, + (token_hash, user_id, ttl_seconds), + ).fetchone() + return row[0] + + def find_session(self, token_hash: bytes) -> Optional[Tuple[User, datetime]]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at + FROM sessions s JOIN users u ON u.id = s.user_id + WHERE s.token_hash = %s + AND s.revoked_at IS NULL + AND s.expires_at > clock_timestamp() + """, + (token_hash,), + ).fetchone() + if row is None: + return None + return _user(row), row["expires_at"] + + def revoke_session(self, token_hash: bytes) -> bool: + with self.pool.connection() as conn: + row = conn.execute( + """ + UPDATE sessions SET revoked_at = clock_timestamp() + WHERE token_hash = %s + AND revoked_at IS NULL + AND expires_at > clock_timestamp() + RETURNING 1 + """, + (token_hash,), + ).fetchone() + return row is not None + + # chats + + def _insert_members(self, conn, chat_id: UUID, member_ids: Sequence[UUID]) -> None: + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat_id, member_id, pos) for pos, member_id in enumerate(member_ids)], + ) + + def create_chat(self, title: str, member_ids: Sequence[UUID]) -> Chat: + """Чат и все участники создаются в одной транзакции. + + Существование участников проверяет внешний ключ chat_members.user_id: + если хоть один id неизвестен, INSERT падает, и откатывается вся + транзакция, включая уже вставленную строку chats и других участников. + """ + chat_id = uuid4() + try: + with self.pool.connection() as conn: + with conn.transaction(): + created_at = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at", + (chat_id, title), + ).fetchone()[0] + self._insert_members(conn, chat_id, member_ids) + except errors.ForeignKeyViolation: + raise UnknownMember() + return Chat(id=chat_id, title=title, member_ids=list(member_ids), created_at=created_at) + + def _members_for(self, conn, chat_ids: List[UUID]) -> dict: + members = {chat_id: [] for chat_id in chat_ids} + if not chat_ids: + return members + rows = conn.execute( + """ + SELECT chat_id, user_id FROM chat_members + WHERE chat_id = ANY(%s) ORDER BY chat_id, position + """, + (chat_ids,), + ).fetchall() + for chat_id, user_id in rows: + members[chat_id].append(user_id) + return members + + def get_chat_for_member(self, chat_id: UUID, user_id: UUID) -> Optional[Chat]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s + WHERE c.id = %s + """, + (user_id, chat_id), + ).fetchone() + if row is None: + return None + members = self._members_for(conn, [row["id"]]) + return Chat(id=row["id"], title=row["title"], member_ids=members[row["id"]], created_at=row["created_at"]) + + def list_user_chats(self, user_id: UUID, limit: int, after: Position) -> Tuple[List[Chat], bool]: + params: list = [user_id] + keyset = "" + if after is not None: + keyset = "AND (c.created_at, c.id) > (%s, %s)" + params.extend(after) + params.append(limit + 1) + with self.pool.connection() as conn: + rows = conn.cursor(row_factory=dict_row).execute( + """ + SELECT c.id, c.title, c.created_at + FROM chat_members m JOIN chats c ON c.id = m.chat_id + WHERE m.user_id = %s {keyset} + ORDER BY c.created_at, c.id + LIMIT %s + """.format(keyset=keyset), + params, + ).fetchall() + has_more = len(rows) > limit + rows = rows[:limit] + members = self._members_for(conn, [r["id"] for r in rows]) + chats = [ + Chat(id=r["id"], title=r["title"], member_ids=members[r["id"]], created_at=r["created_at"]) + for r in rows + ] + return chats, has_more + + # messages + + def create_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Optional[Message]: + """Проверка членства и вставка — один оператор, без окна гонки.""" + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text) + SELECT %s, %s, %s, %s + WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s + ) + RETURNING id, chat_id, sender_id, text, created_at + """, + (uuid4(), chat_id, sender_id, text, chat_id, sender_id), + ).fetchone() + if row is None: + return None + return Message(**row) + + def list_messages( + self, chat_id: UUID, user_id: UUID, limit: int, after: Position + ) -> Optional[Tuple[List[Message], bool]]: + params: list = [chat_id] + keyset = "" + if after is not None: + keyset = "AND (created_at, id) > (%s, %s)" + params.extend(after) + params.append(limit + 1) + with self.pool.connection() as conn: + member = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id), + ).fetchone() + if member is None: + return None + # Keyset-пагинация по индексу messages_chat_created_id_idx: + # Index Scan сразу с позиции курсора, читается limit+1 строк. + rows = conn.cursor(row_factory=dict_row).execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s {keyset} + ORDER BY created_at, id + LIMIT %s + """.format(keyset=keyset), + params, + ).fetchall() + has_more = len(rows) > limit + return [Message(**r) for r in rows[:limit]], has_more diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 0000000..8f5556f --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,101 @@ +"""Общие HTTP-помощники собственных тестов (только стандартная библиотека).""" +import base64 +import json +import os +import uuid +from urllib.error import HTTPError, URLError +from urllib.request import Request, urlopen + +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") + + +class Resp: + def __init__(self, status, data, headers, elapsed=0.0): + self.status = status + self.json = data + self.headers = headers + self.elapsed = elapsed + + +def request(method, path, token=None, payload=None, raw=None, headers=None, + base_url=None, timeout=10): + import time + h = {"Accept": "application/json"} + if token is not None: + h["Authorization"] = "Bearer " + token + body = None + if payload is not None: + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + elif raw is not None: + body = raw + h["Content-Type"] = "application/json" + h.update(headers or {}) + req = Request((base_url or BASE_URL) + path, data=body, headers=h, method=method) + started = time.monotonic() + try: + response = urlopen(req, timeout=timeout) + except HTTPError as error: + response = error + with response: + content = response.read() + status = response.status if hasattr(response, "status") else response.code + rh = response.headers + try: + data = json.loads(content.decode("utf-8")) if content else None + except (UnicodeDecodeError, json.JSONDecodeError): + data = None + return Resp(status, data, rh, time.monotonic() - started) + + +def basic(username, password): + raw = (username + ":" + password).encode("utf-8") + return "Basic " + base64.b64encode(raw).decode("ascii") + + +def new_password(): + return "Pw-" + uuid.uuid4().hex + + +def register(prefix="t", password=None, base_url=None): + username = (prefix + "_" + uuid.uuid4().hex[:16])[:32] + password = password or new_password() + r = request("POST", "/api/v1/users", base_url=base_url, payload={ + "username": username, + "display_name": "Test " + prefix, + "password": password, + }) + assert r.status == 201, (r.status, r.json) + user = r.json + user["_password"] = password + return user + + +def login(user, base_url=None): + r = request("POST", "/api/v1/auth/sessions", base_url=base_url, + headers={"Authorization": basic(user["username"], user["_password"])}) + assert r.status == 201, (r.status, r.json) + return r.json["token"] + + +def actor(prefix="t", base_url=None): + user = register(prefix, base_url=base_url) + user["_token"] = login(user, base_url=base_url) + return user + + +def create_chat(owner, *members, base_url=None): + r = request("POST", "/api/v1/chats", token=owner["_token"], base_url=base_url, payload={ + "title": "Test chat " + uuid.uuid4().hex[:8], + "member_ids": [owner["id"]] + [m["id"] for m in members], + }) + assert r.status == 201, (r.status, r.json) + return r.json + + +def reachable(base_url): + try: + urlopen(base_url.rstrip("/") + "/health/live", timeout=2).read() + return True + except (URLError, OSError, HTTPError): + return False diff --git a/student-tests/dependency_failure.py b/student-tests/dependency_failure.py new file mode 100644 index 0000000..ec33b2f --- /dev/null +++ b/student-tests/dependency_failure.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Автоматическая проверка недоступности Redis и PostgreSQL. + +Сценарий явно останавливает зависимости, поэтому не входит в discovery +unittest. По умолчанию использует docker compose из корня репозитория: + + python student-tests/dependency_failure.py --base-url http://127.0.0.1:8080 + +Команды остановки/запуска можно переопределить (--stop-redis и т.д.), например +для стенда без Docker. Результат — JSON-сводка (без токенов) в stdout и, +при --output, в файл. + +Ожидаемое поведение: +* Redis недоступен -> API обходит кэш, всё работает через PostgreSQL, + readiness = 200, задержка ограничена таймаутом Redis (250 мс) и + circuit breaker'ом; logout по-прежнему отзывает сессию. +* PostgreSQL недоступна -> /health/live = 200, /health/ready = 503, + запросы к данным -> 503 unavailable за ограниченное время; анонимный + запрос -> 401; неизвестный токен не принимается (503, а не 200). +* После возврата зависимости тот же токен снова работает, данные на месте. +""" +import argparse +import json +import shlex +import subprocess +import sys +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import common # noqa: E402 +from common import actor, basic, create_chat, login, request # noqa: E402 + +ROOT = Path(__file__).resolve().parents[1] +MAX_FAIL_SECONDS = 6.0 # верхняя граница ответа при отказе зависимости +MAX_DEGRADED_SECONDS = 1.5 # верхняя граница ответа при отказе Redis + + +class Check: + def __init__(self): + self.results = [] + + def __call__(self, name, condition, detail=""): + self.results.append({"check": name, "ok": bool(condition), "detail": detail}) + print(("PASS " if condition else "FAIL ") + name + (" — " + detail if detail else ""), flush=True) + return condition + + @property + def ok(self): + return all(r["ok"] for r in self.results) + + +def run(cmd): + print("$ " + cmd, flush=True) + subprocess.run(shlex.split(cmd), cwd=ROOT, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def wait_ready(timeout=90): + deadline = time.monotonic() + timeout + started = time.monotonic() + while time.monotonic() < deadline: + try: + if request("GET", "/health/ready", timeout=3).status == 200: + return time.monotonic() - started + except OSError: + pass + time.sleep(0.5) + return None + + +def is_unavailable(r): + return (r.status == 503 and r.json and r.json["error"]["code"] == "unavailable" + and r.json["error"]["request_id"] == r.headers.get("X-Request-Id")) + + +def main(): + p = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + p.add_argument("--base-url", default="http://127.0.0.1:8080") + p.add_argument("--stop-redis", default="docker compose stop redis") + p.add_argument("--start-redis", default="docker compose up -d --wait redis") + p.add_argument("--stop-postgres", default="docker compose stop postgres") + p.add_argument("--start-postgres", default="docker compose up -d --wait postgres") + p.add_argument("--output") + args = p.parse_args() + common.BASE_URL = args.base_url.rstrip("/") + + check = Check() + summary = {"base_url": common.BASE_URL, "timings": {}} + + alice, bob = actor("dep"), actor("dep") + chat = create_chat(alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + first = request("POST", path, token=alice["_token"], payload={"text": "до отказов"}).json + request("GET", "/api/v1/users/me", token=alice["_token"]) # прогрев кэша + + # 1. Redis недоступен + run(args.stop_redis) + try: + r = request("GET", "/api/v1/users/me", token=alice["_token"]) + check("redis down: existing token still valid via PostgreSQL", r.status == 200, "%.3fs" % r.elapsed) + summary["timings"]["redis_down_first_request_s"] = round(r.elapsed, 3) + timings = [] + for i in range(10): + r = request("POST", path, token=bob["_token"], payload={"text": "redis down %d" % i}) + timings.append(r.elapsed) + if r.status != 201: + break + check("redis down: writes succeed", r.status == 201) + check("redis down: bounded latency", max(timings) < MAX_DEGRADED_SECONDS, + "max %.3fs over %d requests" % (max(timings), len(timings))) + summary["timings"]["redis_down_max_write_s"] = round(max(timings), 3) + check("redis down: readiness stays 200 (cache is not critical)", + request("GET", "/health/ready").status == 200) + token = login(bob) + check("redis down: login works", bool(token)) + check("redis down: logout works", + request("DELETE", "/api/v1/auth/sessions/current", token=token).status == 204) + check("redis down: revoked token rejected", + request("GET", "/api/v1/users/me", token=token).status == 401) + check("redis down: anonymous rejected", request("GET", "/api/v1/users/me").status == 401) + check("redis down: unknown token rejected", + request("GET", "/api/v1/users/me", token="x" * 43).status == 401) + finally: + run(args.start_redis) + time.sleep(6) # больше CACHE_RETRY_AFTER_SECONDS: API снова пробует Redis + check("redis back: requests ok", + request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200) + + # 2. PostgreSQL недоступна + run(args.stop_postgres) + try: + check("postgres down: liveness 200", request("GET", "/health/live").status == 200) + r = request("GET", "/health/ready") + check("postgres down: readiness 503 unavailable", is_unavailable(r), "%.3fs" % r.elapsed) + r = request("GET", "/api/v1/users/me") + check("postgres down: anonymous -> 401 (not trusted)", r.status == 401, "status %d" % r.status) + r = request("GET", "/api/v1/users/me", token="y" * 43) + check("postgres down: unknown token is not accepted (503)", is_unavailable(r), + "status %d, %.3fs" % (r.status, r.elapsed)) + r = request("POST", path, token=alice["_token"], payload={"text": "должно не записаться"}) + check("postgres down: write -> 503 within bound", is_unavailable(r) and r.elapsed < MAX_FAIL_SECONDS, + "status %d, %.3fs" % (r.status, r.elapsed)) + summary["timings"]["postgres_down_write_s"] = round(r.elapsed, 3) + r = request("GET", path, token=alice["_token"]) + check("postgres down: history read -> 503", is_unavailable(r), "status %d" % r.status) + r = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(alice["username"], alice["_password"])}) + check("postgres down: login -> 503 (not 401, not 201)", is_unavailable(r), "status %d" % r.status) + body = json.dumps(r.json, ensure_ascii=False) + check("postgres down: error hides internals", + not any(s in body.lower() for s in ("psycopg", "postgres", "select", "traceback", "5432"))) + finally: + run(args.start_postgres) + recovered = wait_ready() + check("postgres back: readiness recovered", recovered is not None, + "%.1fs" % recovered if recovered is not None else "timeout") + summary["timings"]["postgres_recovery_s"] = round(recovered or -1, 2) + r = request("GET", path + "?limit=100", token=alice["_token"]) + ok = r.status == 200 and r.json["items"][0] == first + texts = [m["text"] for m in r.json["items"]] if r.status == 200 else [] + check("postgres back: same token reads intact history", ok) + check("postgres back: rejected write was not stored", "должно не записаться" not in texts) + + summary["checks"] = check.results + summary["passed"] = check.ok + if args.output: + Path(args.output).write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(("PASS" if check.ok else "FAIL") + ": dependency failure scenario") + sys.exit(0 if check.ok else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/race.py b/student-tests/race.py new file mode 100644 index 0000000..7dfc414 --- /dev/null +++ b/student-tests/race.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +"""Конкурентная запись: 10 клиентов x 10 сообщений (перенесено из lab1, Bearer).""" +import argparse +import base64 +import json +import threading +import urllib.request +import uuid +from concurrent.futures import ThreadPoolExecutor +from urllib.parse import urlencode + + +def request(base_url, method, path, token=None, body=None, headers=None): + headers = dict(headers or {}) + headers["Accept"] = "application/json" + + if token: + headers["Authorization"] = "Bearer " + token + + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + + request = urllib.request.Request( + base_url + path, + data=data, + headers=headers, + method=method, + ) + + with urllib.request.urlopen(request, timeout=10) as response: + return response.status, json.loads(response.read().decode("utf-8")) + + +def create_user(base_url, name): + username = "race_%s_%s" % (name, uuid.uuid4().hex[:8]) + password = "Race-password-" + uuid.uuid4().hex + + status, user = request( + base_url, + "POST", + "/api/v1/users", + body={ + "username": username, + "display_name": "Race " + name, + "password": password, + }, + ) + assert status == 201 + + credential = base64.b64encode((username + ":" + password).encode()).decode() + status, session = request( + base_url, + "POST", + "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert status == 201 + user["token"] = session["token"] + return user + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--base-url", + default="http://127.0.0.1:8080", + ) + args = parser.parse_args() + + base_url = args.base_url.rstrip("/") + + users = [ + create_user(base_url, str(i)) + for i in range(10) + ] + + owner = users[0] + + status, chat = request( + base_url, + "POST", + "/api/v1/chats", + token=owner["token"], + body={ + "title": "Concurrent race test", + "member_ids": [user["id"] for user in users], + }, + ) + + assert status == 201 + + chat_id = chat["id"] + + barrier = threading.Barrier(10) + + def worker(worker_id): + user = users[worker_id] + created = [] + + barrier.wait() + + for message_id in range(10): + text = "race-%d-%d" % (worker_id, message_id) + + status, message = request( + base_url, + "POST", + "/api/v1/chats/%s/messages" % chat_id, + token=user["token"], + body={"text": text}, + ) + + assert status == 201 + created.append(message) + + return created + + with ThreadPoolExecutor(max_workers=10) as executor: + results = list(executor.map(worker, range(10))) + + created = [ + message + for worker_messages in results + for message in worker_messages + ] + + assert len(created) == 100 + + created_ids = {message["id"] for message in created} + created_texts = {message["text"] for message in created} + + assert len(created_ids) == 100 + assert len(created_texts) == 100 + + messages = [] + seen_cursors = set() + cursor = None + page_limit = 13 + + while True: + path = ( + "/api/v1/chats/%s/messages?limit=%d" + % (chat_id, page_limit) + ) + + if cursor is not None: + path += "&" + urlencode({"cursor": cursor}) + + status, page = request( + base_url, + "GET", + path, + token=owner["token"], + ) + + assert status == 200 + + page_messages = page["items"] + messages.extend(page_messages) + + next_cursor = page["next_cursor"] + + if next_cursor is None: + break + + assert next_cursor not in seen_cursors, ( + "Cursor повторился: возможен бесконечный цикл пагинации" + ) + + seen_cursors.add(next_cursor) + cursor = next_cursor + + assert len(messages) == 100 + + history_ids = {message["id"] for message in messages} + history_texts = {message["text"] for message in messages} + + assert len(history_ids) == 100 + assert len(history_texts) == 100 + + assert history_ids == created_ids + assert history_texts == created_texts + + user_ids = {user["id"] for user in users} + + assert all( + message["sender_id"] in user_ids + for message in messages + ) + + print( + "PASS: concurrent write test; " + "10 clients x 10 messages = 100 messages; " + "no lost or duplicate messages" + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/run_all.py b/student-tests/run_all.py new file mode 100644 index 0000000..167838a --- /dev/null +++ b/student-tests/run_all.py @@ -0,0 +1,43 @@ +"""Запуск собственных тестов. + + python student-tests/run_all.py --base-url http://127.0.0.1:8080 + # + истечение сессии на экземпляре с коротким TTL: + python student-tests/run_all.py --expiry-url http://127.0.0.1:8081 + # + отказ Redis/PostgreSQL (останавливает контейнеры!): + python student-tests/run_all.py --expiry-url http://127.0.0.1:8081 --with-failures +""" +import argparse +import os +import subprocess +import sys + +parser = argparse.ArgumentParser() +parser.add_argument("--base-url", default="http://127.0.0.1:8080") +parser.add_argument("--expiry-url", default=os.environ.get("EXPIRY_BASE_URL", "")) +parser.add_argument("--with-failures", action="store_true", + help="run student-tests/dependency_failure.py (stops redis/postgres)") +parser.add_argument("--failure-args", default="", + help="extra arguments for dependency_failure.py (custom stop/start commands)") +args = parser.parse_args() + +env = os.environ.copy() +env["BASE_URL"] = args.base_url.rstrip("/") +if args.expiry_url: + env["EXPIRY_BASE_URL"] = args.expiry_url.rstrip("/") + + +def step(title, cmd): + print("\n== " + title, flush=True) + subprocess.run(cmd, env=env, check=True) + + +step("API, auth, concurrency, rollback, expiry tests", + [sys.executable, "-m", "unittest", "discover", "-s", "student-tests", "-p", "test_*.py", "-v"]) +step("Concurrent write test", [sys.executable, "student-tests/race.py", "--base-url", args.base_url]) +if args.with_failures: + import shlex + step("Dependency failure scenario", + [sys.executable, "student-tests/dependency_failure.py", "--base-url", args.base_url] + + shlex.split(args.failure_args)) + +print("\nALL STUDENT TESTS PASSED", flush=True) diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 0000000..5943901 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,138 @@ +"""Поведенческие тесты API, перенесённые из lab1 и переведённые на Bearer.""" +import base64 +import json +import unittest +import uuid +from urllib.parse import urlencode + +from common import actor, create_chat, request + + +class ApiBehaviorTests(unittest.TestCase): + + def test_malformed_json_returns_400(self): + r = request("POST", "/api/v1/users", raw=b'{"username": ') + self.assertEqual(r.status, 400, r.json) + self.assertIn("request_id", r.json["error"]) + self.assertEqual(r.json["error"]["request_id"], r.headers.get("X-Request-Id")) + + def test_registration_without_password_returns_400(self): + r = request("POST", "/api/v1/users", payload={ + "username": "nopass_" + uuid.uuid4().hex[:10], + "display_name": "No password", + }) + self.assertEqual(r.status, 400, r.json) + + def test_short_password_returns_400(self): + r = request("POST", "/api/v1/users", payload={ + "username": "short_" + uuid.uuid4().hex[:10], + "display_name": "Short", + "password": "elevenchars", + }) + self.assertEqual(r.status, 400, r.json) + + def test_password_never_returned(self): + r = request("POST", "/api/v1/users", payload={ + "username": "secret_" + uuid.uuid4().hex[:10], + "display_name": "Secret", + "password": "Very-secret-password-42", + }) + self.assertEqual(r.status, 201, r.json) + self.assertEqual(set(r.json), {"id", "username", "display_name", "created_at"}) + + def test_duplicate_username_returns_409(self): + payload = { + "username": "duplicate_" + uuid.uuid4().hex[:10], + "display_name": "First User", + "password": "Duplicate-pass-123", + } + self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 201) + self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 409) + + def test_empty_message_returns_400(self): + owner = actor() + chat = create_chat(owner) + r = request("POST", "/api/v1/chats/%s/messages" % chat["id"], + token=owner["_token"], payload={"text": " "}) + self.assertEqual(r.status, 400, r.json) + + def test_sender_id_in_body_rejected(self): + owner = actor() + chat = create_chat(owner) + r = request("POST", "/api/v1/chats/%s/messages" % chat["id"], token=owner["_token"], + payload={"text": "hi", "sender_id": owner["id"]}) + self.assertEqual(r.status, 400, r.json) + + def test_outsider_cannot_access_chat(self): + owner, member, outsider = actor(), actor(), actor() + chat = create_chat(owner, member) + chat_path = "/api/v1/chats/%s" % chat["id"] + self.assertEqual(request("GET", chat_path, token=outsider["_token"]).status, 404) + self.assertEqual(request("GET", chat_path + "/messages", token=outsider["_token"]).status, 404) + r = request("POST", chat_path + "/messages", token=outsider["_token"], + payload={"text": "Unauthorized message"}) + self.assertEqual(r.status, 404) + self.assertEqual(request("GET", chat_path, token=member["_token"]).status, 200) + + def test_naive_timestamp_cursor_returns_400(self): + owner = actor() + chat = create_chat(owner) + payload = { + "resource_id": chat["id"], + "created_at": "2026-10-02T12:00:00", + "item_id": str(uuid.uuid4()), + } + encoded = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat["id"], urlencode({"cursor": encoded})), + token=owner["_token"]) + self.assertEqual(r.status, 400, r.json) + + def test_cursor_from_other_chat_returns_400(self): + owner = actor() + chat_a, chat_b = create_chat(owner), create_chat(owner) + for i in range(3): + request("POST", "/api/v1/chats/%s/messages" % chat_a["id"], token=owner["_token"], + payload={"text": "m%d" % i}) + page = request("GET", "/api/v1/chats/%s/messages?limit=1" % chat_a["id"], token=owner["_token"]).json + self.assertTrue(page["next_cursor"]) + r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat_b["id"], urlencode({"cursor": page["next_cursor"]})), + token=owner["_token"]) + self.assertEqual(r.status, 400, r.json) + + def test_pagination_returns_all_messages_without_duplicates(self): + owner = actor() + chat = create_chat(owner) + path = "/api/v1/chats/%s/messages" % chat["id"] + expected = [] + for index in range(8): + r = request("POST", path, token=owner["_token"], payload={"text": "page-%d" % index}) + self.assertEqual(r.status, 201, r.json) + expected.append(r.json["id"]) + received, cursor = [], None + while True: + query = {"limit": 3} + if cursor: + query["cursor"] = cursor + page = request("GET", path + "?" + urlencode(query), token=owner["_token"]).json + received.extend(m["id"] for m in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + self.assertEqual(received, expected) + + def test_chat_list_pagination(self): + owner = actor() + created = [create_chat(owner)["id"] for _ in range(5)] + got, cursor = [], None + while True: + q = "?limit=2" + ("&" + urlencode({"cursor": cursor}) if cursor else "") + page = request("GET", "/api/v1/chats" + q, token=owner["_token"]).json + got.extend(c["id"] for c in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + self.assertEqual(got, created) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 0000000..1b55bc5 --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,89 @@ +"""Аутентификация: Basic только для входа, Bearer для остального, logout.""" +import base64 +import unittest +import uuid + +from common import actor, basic, login, register, request + + +def assert_challenge(test, r, scheme): + test.assertEqual(r.status, 401, r.json) + test.assertTrue(r.headers.get("WWW-Authenticate", "").startswith(scheme), r.headers.get("WWW-Authenticate")) + test.assertEqual(r.json["error"]["code"], "unauthorized") + + +class AuthTests(unittest.TestCase): + + def test_wrong_password_and_unknown_user_look_the_same(self): + user = register("wp") + wrong = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(user["username"], "Wrong-password-000")}) + unknown = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic("nouser_" + uuid.uuid4().hex[:10], "Wrong-password-000")}) + for r in (wrong, unknown): + assert_challenge(self, r, 'Basic realm="messenger"') + self.assertIn('charset="UTF-8"', r.headers.get("WWW-Authenticate")) + self.assertEqual(wrong.json["error"]["message"], unknown.json["error"]["message"]) + + def test_malformed_basic_headers(self): + for header in (None, "Basic", "Basic !!!notbase64", "Bearer abc", + "Basic " + base64.b64encode(b"no-colon-here").decode()): + headers = {"Authorization": header} if header else {} + r = request("POST", "/api/v1/auth/sessions", headers=headers) + assert_challenge(self, r, "Basic") + + def test_session_shape_and_token_entropy(self): + user = register("shape") + r = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201, r.json) + self.assertEqual(set(r.json), {"token", "token_type", "expires_at", "user"}) + self.assertEqual(r.json["token_type"], "Bearer") + token = r.json["token"] + # 32 случайных байта в base64url = 43 символа (256 бит) + self.assertGreaterEqual(len(token), 43) + self.assertNotIn(user["username"], token) + self.assertNotIn(user["id"], token) + self.assertTrue(r.json["expires_at"].endswith("Z")) + self.assertNotEqual(token, login(user), "each login must issue a new token") + + def test_password_with_colon_and_unicode(self): + password = "пароль:с:двоеточием-🙂" + user = register("colon", password=password) + token = login(user) + self.assertEqual(request("GET", "/api/v1/users/me", token=token).json["id"], user["id"]) + + def test_basic_on_business_endpoint_rejected(self): + user = register("basic") + r = request("GET", "/api/v1/users/me", + headers={"Authorization": basic(user["username"], user["_password"])}) + assert_challenge(self, r, 'Bearer realm="messenger"') + + def test_x_user_id_gives_no_access(self): + user = actor("xuid") + other = actor("xuid") + assert_challenge(self, request("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}), "Bearer") + r = request("GET", "/api/v1/users/me", token=user["_token"], headers={"X-User-Id": other["id"]}) + self.assertEqual(r.json["id"], user["id"]) + + def test_unknown_and_garbage_tokens(self): + for token in ("x" * 43, "", "a b", "z" * 1000): + r = request("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token}) + assert_challenge(self, r, "Bearer") + + def test_logout_revokes_only_current_session(self): + user = register("logout") + t1, t2 = login(user), login(user) + # Прогреваем кэш Redis для t1, чтобы проверить инвалидацию кэша. + self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200) + self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200) + r = request("DELETE", "/api/v1/auth/sessions/current", token=t1) + self.assertEqual(r.status, 204) + self.assertIsNone(r.json) + assert_challenge(self, request("GET", "/api/v1/users/me", token=t1), "Bearer") + assert_challenge(self, request("DELETE", "/api/v1/auth/sessions/current", token=t1), "Bearer") + self.assertEqual(request("GET", "/api/v1/users/me", token=t2).status, 200) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 0000000..0411490 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,80 @@ +"""Гонка регистрации одинакового username и rollback составной операции.""" +import threading +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor + +from common import actor, basic, request + +PARALLEL = 16 + + +class RegistrationRaceTests(unittest.TestCase): + + def test_same_username_parallel_registration(self): + username = "race_" + uuid.uuid4().hex[:12] + barrier = threading.Barrier(PARALLEL) + + def attempt(i): + password = "Race-password-%02d-%s" % (i, uuid.uuid4().hex[:6]) + barrier.wait() + r = request("POST", "/api/v1/users", timeout=30, payload={ + "username": username, "display_name": "Racer %d" % i, "password": password, + }) + return r.status, r.json, password + + with ThreadPoolExecutor(max_workers=PARALLEL) as pool: + results = list(pool.map(attempt, range(PARALLEL))) + + statuses = sorted(s for s, _, _ in results) + self.assertEqual(statuses.count(201), 1, statuses) + self.assertEqual(statuses.count(409), PARALLEL - 1, statuses) + for status, body, _ in results: + if status == 409: + self.assertEqual(body["error"]["code"], "conflict") + + # Победитель входит своим паролем; пароли проигравших не подходят. + winner = next(r for r in results if r[0] == 201) + loser = next(r for r in results if r[0] == 409) + ok = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, winner[2])}) + self.assertEqual(ok.status, 201) + self.assertEqual(ok.json["user"]["id"], winner[1]["id"]) + bad = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, loser[2])}) + self.assertEqual(bad.status, 401) + + +class ChatRollbackTests(unittest.TestCase): + + def _chat_ids(self, owner): + r = request("GET", "/api/v1/chats?limit=100", token=owner["_token"]) + self.assertEqual(r.status, 200) + return [c["id"] for c in r.json["items"]] + + def test_unknown_member_rolls_back_whole_chat(self): + """Чат вставляется первым, затем участники по порядку (сначала сам владелец). + + Неизвестный участник вызывает нарушение внешнего ключа на 2-й строке + chat_members. Без транзакции у владельца остался бы чат с одним + участником; с транзакцией не остаётся ничего. + """ + owner, member = actor("rb"), actor("rb") + before = self._chat_ids(owner) + r = request("POST", "/api/v1/chats", token=owner["_token"], payload={ + "title": "Must roll back", + "member_ids": [owner["id"], member["id"], str(uuid.uuid4())], + }) + self.assertEqual(r.status, 400, r.json) + self.assertEqual(self._chat_ids(owner), before, "partial chat is visible after failed creation") + self.assertEqual(self._chat_ids(member), [], "partial membership is visible to other member") + + def test_duplicate_and_missing_caller_rejected(self): + owner, member = actor("rb"), actor("rb") + for ids in ([owner["id"], owner["id"]], [member["id"]]): + r = request("POST", "/api/v1/chats", token=owner["_token"], + payload={"title": "bad", "member_ids": ids}) + self.assertEqual(r.status, 400, r.json) + self.assertEqual(self._chat_ids(owner), []) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_expiry.py b/student-tests/test_expiry.py new file mode 100644 index 0000000..c560140 --- /dev/null +++ b/student-tests/test_expiry.py @@ -0,0 +1,49 @@ +"""Истечение сессии при коротком SESSION_TTL_SECONDS. + +Нужен отдельный экземпляр API с коротким TTL (compose-профиль ttl, порт 8081): + docker compose --profile ttl up -d api-short-ttl + EXPIRY_BASE_URL=http://127.0.0.1:8081 python -m unittest discover -s student-tests -p test_expiry.py +Без EXPIRY_BASE_URL тест пропускается (основной стенд работает с TTL >= 300). +""" +import datetime as dt +import os +import time +import unittest + +from common import basic, register, request + +EXPIRY_BASE_URL = os.environ.get("EXPIRY_BASE_URL", "").rstrip("/") + + +@unittest.skipUnless(EXPIRY_BASE_URL, "set EXPIRY_BASE_URL to the short-TTL API instance") +class ExpiryTests(unittest.TestCase): + + def test_session_expires_even_when_cached(self): + user = register("exp", base_url=EXPIRY_BASE_URL) + r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL, + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201, r.json) + token = r.json["token"] + expires_at = dt.datetime.fromisoformat(r.json["expires_at"].replace("Z", "+00:00")) + ttl = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds() + self.assertLess(ttl, 30, "EXPIRY_BASE_URL must point to a short-TTL instance") + + # Два запроса подряд: первый кладёт сессию в Redis, второй читает из кэша. + for _ in range(2): + self.assertEqual(request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL).status, 200) + + time.sleep(max(ttl, 0) + 1.5) + r = request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL) + self.assertEqual(r.status, 401, r.json) + self.assertTrue(r.headers.get("WWW-Authenticate", "").startswith("Bearer")) + r = request("DELETE", "/api/v1/auth/sessions/current", token=token, base_url=EXPIRY_BASE_URL) + self.assertEqual(r.status, 401, "logout with expired token must be 401") + + # Новый вход после истечения работает. + r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL, + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_storage_rollback.py b/student-tests/test_storage_rollback.py new file mode 100644 index 0000000..305f0ec --- /dev/null +++ b/student-tests/test_storage_rollback.py @@ -0,0 +1,101 @@ +"""Rollback на уровне хранилища с внедрённым сбоем (нужен прямой доступ к БД). + +Сбой вызывается ПОСЛЕ того, как строки chats и chat_members уже вставлены +внутри транзакции. Проверяем, что в БД не осталось ни чата, ни участников. + +Запуск внутри compose-сети (БД наружу не публикуется): + docker compose run --rm --no-deps -v "$PWD/student-tests:/app/student-tests:ro" \ + api python -m unittest discover -s student-tests -p test_storage_rollback.py -v +Без DATABASE_URL/DATABASE_URL_FILE тест пропускается. +""" +import os +import sys +import unittest +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE")) + + +class InjectedFailure(RuntimeError): + pass + + +@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured") +class StorageRollbackTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + from src.config import load_settings + from src.db import create_pool, wait_and_migrate + from src.security import hash_password + from src.storage import Storage + + settings = load_settings() + wait_and_migrate(settings) + cls.pool = create_pool(settings) + cls.pool.wait(timeout=10) + cls.storage = Storage(cls.pool) + h = hash_password("Rollback-test-password") + cls.users = [ + cls.storage.create_user("rbk_" + uuid.uuid4().hex[:12], "Rollback", h) + for _ in range(3) + ] + + @classmethod + def tearDownClass(cls): + cls.pool.close() + + def count(self, sql, params): + with self.pool.connection() as conn: + return conn.execute(sql, params).fetchone()[0] + + def test_failure_after_inserts_leaves_nothing(self): + title = "rollback-" + uuid.uuid4().hex + original = self.storage._insert_members + seen = {} + + def insert_then_fail(conn, chat_id, member_ids): + original(conn, chat_id, member_ids) + # Внутри транзакции строки видны — значит вставка действительно была. + seen["chats"] = conn.execute("SELECT count(*) FROM chats WHERE title = %s", (title,)).fetchone()[0] + seen["members"] = conn.execute("SELECT count(*) FROM chat_members WHERE chat_id = %s", (chat_id,)).fetchone()[0] + seen["chat_id"] = chat_id + raise InjectedFailure("simulated crash between statements") + + self.storage._insert_members = insert_then_fail + try: + with self.assertRaises(InjectedFailure): + self.storage.create_chat(title, [u.id for u in self.users]) + finally: + self.storage._insert_members = original + + self.assertEqual(seen["chats"], 1) + self.assertEqual(seen["members"], 3) + self.assertEqual(self.count("SELECT count(*) FROM chats WHERE title = %s", (title,)), 0) + self.assertEqual(self.count("SELECT count(*) FROM chat_members WHERE chat_id = %s", (seen["chat_id"],)), 0) + + def test_no_orphan_chats_in_database(self): + orphans = self.count( + "SELECT count(*) FROM chats c WHERE NOT EXISTS " + "(SELECT 1 FROM chat_members m WHERE m.chat_id = c.id)", ()) + self.assertEqual(orphans, 0) + + def test_migrations_are_idempotent(self): + from src.config import load_settings + from src.db import apply_migrations + self.assertEqual(apply_migrations(load_settings()), []) + self.assertEqual(self.count("SELECT count(*) FROM schema_migrations WHERE version = %s", ("001_init",)), 1) + + def test_passwords_stored_as_argon2id(self): + with self.pool.connection() as conn: + stored = conn.execute("SELECT password_hash FROM users WHERE id = %s", + (self.users[0].id,)).fetchone()[0] + self.assertTrue(stored.startswith("$argon2id$"), stored[:10]) + self.assertNotIn("Rollback-test-password", stored) + + +if __name__ == "__main__": + unittest.main(verbosity=2)