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