From ffb98242ff9dbd942a5dd8a48734837f89e9cff7 Mon Sep 17 00:00:00 2001 From: yura Date: Fri, 16 Oct 2026 02:14:47 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=A0=202:=20PostgreSQL,=20Bearer-=D1=81?= =?UTF-8?q?=D0=B5=D1=81=D1=81=D0=B8=D0=B8=20=D0=B8=20=D0=BA=D1=8D=D1=88=20?= =?UTF-8?q?=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B9=20=D0=B2=20Valkey=20(?= =?UTF-8?q?=D0=BD=D0=B0=204)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Перенесён минимум lab1; переход 1 → 2: password при регистрации, Basic только на POST /auth/sessions, Bearer вместо X-User-Id, logout. - PostgreSQL — источник истины: users, chats, chat_members, messages, sessions; миграции с PK/FK/UNIQUE/CHECK и индексами, атомарное создание чата, scrypt для паролей, SHA-256 токенов в БД. - Valkey — кэш проверенных сессий с TTL, tombstone при logout, обход кэша и окно недоверия при отказе. - Ограниченные пулы и таймауты PostgreSQL/Valkey, 503 при отказе БД. - compose.yaml с Docker secrets и именованным томом, restart hook, собственные тесты, EXPLAIN на 110 тыс. сообщений, замер пользы кэша, заполненный REPORT.md и evidence/. Co-Authored-By: Claude Opus 5.5 --- .env.example | 16 +- Dockerfile | 25 ++ Makefile | 19 +- REPORT.md | 242 +++++++++++++++- compose.yaml | 105 +++++++ evidence/cache-bench.txt | 11 + evidence/database.txt | 108 +++++++ evidence/explain.txt | 126 +++++++++ evidence/persistence.txt | 22 ++ evidence/smoke.txt | 8 + evidence/stack.txt | 55 ++++ evidence/student-tests.txt | 108 +++++++ migrations/001_init.sql | 51 ++++ requirements.txt | 4 + scripts/init-secrets.sh | 27 ++ scripts/restart.sh | 11 + src/security.py | 53 ++++ src/server.py | 503 +++++++++++++++++++++++++++++++++ src/session_cache.py | 121 ++++++++ src/store.py | 271 ++++++++++++++++++ student-tests/cache_bench.py | 72 +++++ student-tests/history_bench.py | 156 ++++++++++ student-tests/test_lab2.py | 364 ++++++++++++++++++++++++ 23 files changed, 2461 insertions(+), 17 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/cache-bench.txt create mode 100644 evidence/database.txt create mode 100644 evidence/explain.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/stack.txt create mode 100644 evidence/student-tests.txt create mode 100644 migrations/001_init.sql create mode 100644 requirements.txt create mode 100755 scripts/init-secrets.sh create mode 100755 scripts/restart.sh create mode 100644 src/security.py create mode 100644 src/server.py create mode 100644 src/session_cache.py create mode 100644 src/store.py create mode 100644 student-tests/cache_bench.py create mode 100644 student-tests/history_bench.py create mode 100644 student-tests/test_lab2.py diff --git a/.env.example b/.env.example index 714c8076..c4a9bb80 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,21 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# scripts/init-secrets.sh делает это автоматически и создаёт secrets/. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. +# Строка подключения читается из файла (Docker secret), значение в окружение не попадает. +# Файл создаёт scripts/init-secrets.sh: secrets/database_url -> /run/secrets/database_url. DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: +# Ограниченный пул соединений и таймаут SQL. +DB_POOL_SIZE=10 +DB_STATEMENT_TIMEOUT_MS=5000 +# Источник истины для сессий — PostgreSQL; Valkey — кэш проверенных сессий (SESSION_CACHE=off отключает). SESSION_STORE=postgres +SESSION_CACHE=valkey +# URL Valkey читается из файла (Docker secret secrets/cache_url, создаёт scripts/init-secrets.sh). CACHE_URL_FILE=/run/secrets/cache_url +# Срок жизни записи кэша (не больше остатка сессии), таймаут операций и пауза обхода после отказа. +SESSION_CACHE_TTL_SECONDS=30 +CACHE_TIMEOUT_MS=250 +CACHE_RETRY_SECONDS=5 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..8cda23fd --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +# Lab2: мессенджер на Python 3.12 + PostgreSQL (драйвер psycopg 3). +FROM python:3.12.7-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +# Сначала зависимости с закреплёнными версиями — слой кэшируется, пока не изменится requirements.txt. +COPY requirements.txt /app/ +RUN pip install --no-cache-dir -r requirements.txt + +COPY src/ /app/src/ +COPY migrations/ /app/migrations/ + +# Запуск без root; сервер — основной процесс контейнера (PID 1), корректно обрабатывает SIGTERM. +RUN useradd --no-create-home --uid 10001 app +USER app + +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \ + CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"] +CMD ["python", "/app/src/server.py"] diff --git a/Makefile b/Makefile index 9ecb223e..4e07d066 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence secrets up down student-test student-bench help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +24,20 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --- Цели студента (lab2) --- +secrets: + sh scripts/init-secrets.sh + +up: secrets + docker compose --env-file .env up -d --build --wait + +down: + docker compose --env-file .env down + +student-test: + $(PYTHON) student-tests/test_lab2.py --base-url "$(BASE_URL)" $(STUDENT_ARGS) + +student-bench: + $(PYTHON) student-tests/history_bench.py --base-url "$(BASE_URL)" + $(PYTHON) student-tests/cache_bench.py --base-url "$(BASE_URL)" --label valkey diff --git a/REPORT.md b/REPORT.md index e42f2b05..03529293 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,253 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Лазарев Юрий Сергеевич, БПИ2303 +- Целевая оценка; выбранный трек 5, если нужен: **4**, трек 5 не заявлен - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: Python 3.12 (стандартная библиотека: `http.server`, `hashlib.scrypt`, `secrets`, `hmac`), `psycopg[binary]==3.2.3`, `psycopg-pool==3.2.4`, `redis==5.2.1` (клиент протокола RESP, работает с Valkey); образы `python:3.12.7-slim`, `postgres:16.4-alpine`, `valkey/valkey:8.0.2-alpine`. Документация PostgreSQL (transactions, EXPLAIN, constraints), Valkey (persistence, eviction), RFC 7617. Код перенесён из моей lab1 и доработан с помощью ИИ-ассистента (Claude), проверен и запущен автором. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требования: Docker Engine 28 с Compose v2 (проверено: Docker Desktop 28.0.4, Compose v2.34.0, macOS), Python 3.9+ на хосте только для тестов, `make`. Порты `127.0.0.1:8080` и `127.0.0.1:8081` (тест TTL) должны быть свободны. + +```sh +# 1. Локальные синтетические секреты и .env (значения не печатаются; повторный запуск ничего не перезаписывает) +sh scripts/init-secrets.sh # или: make secrets +# secrets/postgres_password, secrets/database_url, secrets/valkey.conf, secrets/cache_url (каталог в .gitignore) + +# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Valkey; --wait ждёт healthy +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait # или: make up + +# 3. Готовность +curl -si http://localhost:8080/health/ready # 200 {"status": "ok"} + +# 4. Публичные проверки +make check +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh + +# 5. Собственные проверки: границы, гонка, откат, TTL, отказ БД, кэш и отказ Valkey, рестарт +docker compose --env-file .env --profile ttl up -d --wait api-short-ttl # API с SESSION_TTL_SECONDS=2 на :8081 +python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence +docker compose --env-file .env --profile ttl stop api-short-ttl + +# 6. План запроса истории на 110 000 сообщений + обход истории через API (добавляет синтетические данные) +python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500 + +# 7. Польза кэша: транзакции PostgreSQL и задержка на 1000 проверок токена +python3 student-tests/cache_bench.py --label valkey +SESSION_CACHE=off docker compose --env-file .env up -d --wait api +python3 student-tests/cache_bench.py --label off +docker compose --env-file .env up -d --wait api # вернуть кэш +``` + +**Миграции** применяются автоматически при старте API (каталог `migrations/`, таблица `schema_migrations`, advisory lock). Отдельный запуск без старта сервера: + +```sh +docker compose --env-file .env run --rm api python /app/src/server.py --migrate-only +``` + +**Безопасная остановка** (данные и том сохраняются): `docker compose --env-file .env --profile ttl down` (или `make down`). + +**Намеренное удаление учебных данных** (необратимо, удаляет том `mtusi-lab2_pgdata`): `docker compose --env-file .env --profile ttl down -v`. Если удалить `secrets/`, но оставить том, пароль в томе разойдётся с новым секретом — тогда нужно удалить и том. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент (curl / tests) + │ HTTP 127.0.0.1:8080, Basic только на POST /auth/sessions, далее Bearer + ▼ +api (mtusi-messenger:lab2, Python 3.12, uid 10001, PID 1) + │ 1) проверка токена: Valkey (кэш) ──промах/отказ──► 2) PostgreSQL + ├──────────────► valkey (valkey:8.0.2-alpine) — кэш сессий, без persistence, пул ≤10, таймаут 250 мс + ▼ +postgres (postgres:16.4-alpine) — источник истины, пул ≤10, ожидание ≤5 с, statement_timeout 5 с + └── volume pgdata → /var/lib/postgresql/data +``` + +| Роль | Service | Образ/версия | Health/readiness | Volume | Сеть/порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| api | `api` | сборка из `Dockerfile`, база `python:3.12.7-slim` | `HEALTHCHECK` → `/health/ready` | нет (stateless) | `127.0.0.1:8080→8080` | secrets `database_url`, `cache_url` → `DATABASE_URL_FILE`, `CACHE_URL_FILE` | +| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` (именованный) | внутренняя сеть, 5432 | secret `postgres_password` → `POSTGRES_PASSWORD_FILE` | +| redis_or_valkey | `valkey` | `valkey/valkey:8.0.2-alpine` | `valkey-cli ping` (с паролем) | нет: persistence выключено намеренно | внутренняя сеть, 6379 | secret `valkey.conf` (`requirepass`); без пароля — `NOAUTH` | +| api (TTL-тест) | `api-short-ttl`, профиль `ttl` | тот же образ | — | нет | `127.0.0.1:8081→8080` | те же секреты | + +### Схема и транзакции (уровень 3) + +**Источник истины — PostgreSQL**: пользователи, чаты, участники, сообщения и сессии. В памяти API состояния нет. + +Схема (`migrations/001_init.sql`): + +- `users`: PK, `UNIQUE (username)`, CHECK формата username и длины display_name; `password_hash` — scrypt. +- `chats`: PK, CHECK длины title. +- `chat_members`: PK `(chat_id, user_id)`, FK на `chats` и `users`, `position` — порядок `member_ids`; индекс `(user_id, chat_id)` для списка чатов пользователя. +- `messages`: PK, FK на чат и отправителя, CHECK 1–4000; индекс `(chat_id, created_at, id)` — обоснование ниже. +- `sessions`: PK `token_hash` (SHA-256 токена), FK на `users`, `expires_at`, `revoked_at`; индекс `expires_at`. + +Транзакционные границы: + +- **Создание чата**: проверка участников, `INSERT chats` и все `INSERT chat_members` — одна транзакция. Ошибка, включая нарушение FK, откатывает её целиком. +- **Сообщение**: в одной транзакции `SELECT ... FOR UPDATE` строки чата с проверкой членства и `INSERT`. Вставки в один чат сериализуются, `created_at = clock_timestamp()` растёт в порядке фиксации, и keyset-курсор не пропускает конкурентные вставки. Ограничение: порядок зависит от часов сервера БД. +- **Регистрация**: гонку одинакового username решает `UNIQUE` в БД (`UniqueViolation` → 409), без «SELECT, потом INSERT». +- **Миграции**: каждый файл и его запись в `schema_migrations` — одна транзакция; процессы сериализуются `pg_advisory_lock`. + +### Аутентификация и сессии + +- Пароль 12–128 code points хешируется `hashlib.scrypt` (N=2^15, r=8, p=1, соль 16 байт). Проверка — `hmac.compare_digest`; для неизвестного username считается фиктивный хеш (одинаковое время ответа). bcrypt не выбран из-за усечения до 72 байт. +- `POST /api/v1/auth/sessions` принимает только Basic. Любая ошибка — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. +- Токен — `secrets.token_urlsafe(32)` (256 бит). В PostgreSQL и Valkey хранится только SHA-256 токена. +- `expires_at = now() + SESSION_TTL_SECONDS` вычисляет БД; logout ставит `revoked_at`. Рестарт TTL не продлевает. +- Остальные endpoint требуют Bearer; Basic и `X-User-Id` дают 401, `X-User-Id` рядом с Bearer игнорируется. Чужой и несуществующий чат одинаково дают 404. + +### Valkey: роль, источник истины, expiry и инвалидация (уровень 4) + +**Роль** — кэш проверенных сессий (`src/session_cache.py`). Проверка Bearer-токена выполняется на каждом защищённом запросе, поэтому без кэша каждый запрос — это минимум одна транзакция PostgreSQL. **Источник истины остаётся PostgreSQL**, в Valkey лежат только производные копии: + +- ключ `sess:` — сам токен в Valkey не попадает; +- значение `{"user": {...}, "exp": }` либо `"revoked"`. + +**Путь проверки токена** (`current_user` в `src/server.py`): + +1. `GET sess:` в Valkey: + - копия → пользователь, PostgreSQL не трогаем; + - `"revoked"` → 401; + - промах или ошибка → шаг 2. +2. `SELECT` из `sessions` (действующая, не отозвана, не истекла). Затем `SET sess: ... PX= NX`. + +**Политика expiry**: + +- Положительная запись живёт `min(SESSION_CACHE_TTL_SECONDS=30, остаток сессии)` (PX в мс), поэтому кэш не переживает сессию. При чтении `exp` дополнительно сверяется с часами. +- Tombstone `"revoked"` живёт 31 с — дольше любой положительной записи. +- `maxmemory 64mb`, `allkeys-lru`: вытеснение любой записи безопасно. Вытесненная копия означает промах и чтение из БД. Вытесненный tombstone тоже даёт промах, а БД отвечает «отозвана». + +**Инвалидация (logout)**: + +1. `UPDATE sessions SET revoked_at` — COMMIT в PostgreSQL. +2. `SET sess: "revoked"` поверх возможной копии (не `DEL`). + +Кэш после промаха заполняется только через `SET NX`. Поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone. Кроме того, кэш не заполняется, если между чтением БД и записью прошло больше 1 с. + +**Persistence Valkey выключено намеренно** (`save ""`, `appendonly no`). Valkey — не единственное хранилище сессий, а кэш над PostgreSQL. После рестарта или `FLUSHALL` кэш пуст: сессии читаются из БД и снова кэшируются, действующие токены работают, отозванные остаются отозванными. Это проверено публичным persistence-тестом (restart hook перезапускает и Valkey) и тестом `FLUSHALL`. + +**Отказ Valkey**: + +- Любая ошибка или таймаут (250 мс на соединение и операцию) → запрос обслуживается из PostgreSQL. Следующие 5 с кэш не опрашивается (circuit breaker), чтобы не платить таймаутом на каждом запросе. +- `/health/ready` остаётся 200: Valkey не критичен для обязательного пути. +- Если не удалось записать tombstone (Valkey завис или недоступен во время logout), процесс 31 с не доверяет положительным записям кэша. Устаревшая копия могла остаться в Valkey, но за это время она гарантированно истечёт. +- Анонимный или неизвестный токен при отказе Valkey не проходит: решение всегда принимает PostgreSQL. + +**Ограничение**: окно недоверия хранится в памяти процесса. В lab2 API один, и защита полная. В lab3 при нескольких репликах о неудавшейся инвалидации узнает только одна реплика. Тогда нужен общий сигнал (например, эпоха кэша в PostgreSQL) или отказ от logout при недоступном Valkey. + +### Пулы, таймауты, параметризация (уровень 4) + +- Все SQL-запросы параметризованы (`%s` в psycopg, значения отдельно от текста запроса). Ключи Valkey строятся из hex-хеша. +- PostgreSQL: `ConnectionPool(min_size=1, max_size=DB_POOL_SIZE=10, timeout=5)`, `connect_timeout=5`, `statement_timeout=DB_STATEMENT_TIMEOUT_MS=5000`. Перед выдачей соединение проверяется (`check_connection`), поэтому после рестарта БД нет ложных 503. +- Valkey: `BlockingConnectionPool(max_connections=10, timeout=0.25)`, `socket_timeout` и `socket_connect_timeout` 250 мс. +- Нет БД → `503 unavailable` за ≤5 с (ожидание пула и connect_timeout), а не зависание или 500. + +### Что перенесено из lab1 и что изменено + +Из lab1 перенесён каркас HTTP-сервера на `http.server`: маршрутизация, единый формат ошибок, `X-Request-Id`, валидация полей и длин в code points, 415 для не-JSON, keyset-курсор с привязкой к ресурсу, логирование без тел запросов, SIGTERM, non-root образ. + +Изменено (переход 1 → 2): `password` при регистрации; Basic → Bearer-сессия вместо `X-User-Id`; logout; in-memory хранилище заменено PostgreSQL (`src/store.py`); добавлены кэш сессий в Valkey (`src/session_cache.py`), миграции, Compose, Docker secrets, restart hook и собственные тесты. + +### Соответствие `.env.example` реальной конфигурации + +| Переменная | Где используется | Значение | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT`, `APP_ENV` | `src/server.py` | `0.0.0.0`, `8080`, `lab` | +| `SESSION_TTL_SECONDS` | `create_session` | 3600 (в `api-short-ttl` — 2) | +| `DATABASE_URL_FILE` | `database_conninfo` | `/run/secrets/database_url` | +| `DB_POOL_SIZE`, `DB_STATEMENT_TIMEOUT_MS` | `src/store.py` | 10, 5000 | +| `SESSION_STORE` | информационно: где хранятся сессии | `postgres` (источник истины) | +| `SESSION_CACHE` | `cache_url()` | `valkey`; `off` отключает кэш (для сравнения) | +| `CACHE_URL_FILE` | `cache_url()` | `/run/secrets/cache_url` | +| `SESSION_CACHE_TTL_SECONDS`, `CACHE_TIMEOUT_MS`, `CACHE_RETRY_SECONDS` | `src/session_cache.py` | 30, 250, 5 | ## Доказательства критериев +### Уровень 3 + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Структура skeleton | `make check` | `PASS: offline skeleton structure...` | [evidence/smoke.txt](evidence/smoke.txt) | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | [evidence/smoke.txt](evidence/smoke.txt) | +| Данные и действующие сессии переживают рестарт API и всех хранилищ без удаления томов | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`; `StartedAt` у api, postgres и valkey изменился; в логах PostgreSQL `shut down` → `ready to accept`, у Valkey `SIGTERM` → `Ready`; том тот же | [evidence/persistence.txt](evidence/persistence.txt) | +| После рестарта отозванный токен остаётся отозванным, история та же | `test_lab2.py --persistence` | 5 × OK | [evidence/student-tests.txt](evidence/student-tests.txt) | +| PK/FK, UNIQUE username, 4 таблицы | `\d` таблиц | ключи, `users_username_key`, CHECK, индексы | [evidence/database.txt](evidence/database.txt) | +| Миграции с нуля и повторно без дублей | первый старт на пустом томе; `--migrate-only` × 2 | `migration applied: 001_init.sql`; счётчики до и после равны | [evidence/database.txt](evidence/database.txt) | +| Создание чата атомарно | чат с неизвестным 3-м участником | 400, списки чатов не изменились, следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Basic только на входе, Bearer на остальных, `X-User-Id` не даёт доступ | тесты auth + smoke | Basic на `/users/me` → 401; только `X-User-Id` → 401; владелец не меняется | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Срок жизни и отзыв | TTL = 2; logout | через 3 с 401; logout 204 → 401 → повторный 401 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Password KDF | `users.password_hash` | все хеши `scrypt N=2^15 r=8 p=1`; в `sessions` только 32-байтовые SHA-256 | [evidence/database.txt](evidence/database.txt) | +| Secrets/volumes не в Git | `git status --ignored`, `git check-ignore` | `.env` и все файлы `secrets/` игнорируются | [evidence/stack.txt](evidence/stack.txt) | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### Уровень 4 + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| Valkey реально используется (кэш сессий с TTL) | `test_lab2.py --cache` | после входа в Valkey копия сессии; 50 запросов → 50 попаданий, 0 промахов | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Кэш осмысленный (снимает нагрузку с источника истины) | `cache_bench.py`, 1000 проверок токена × 3 повтора | транзакций PostgreSQL: **3–13** с кэшем против **1693–1789** без; p50 0,80–0,86 мс против 1,08–1,16 мс | [evidence/cache-bench.txt](evidence/cache-bench.txt) | +| Описаны источник истины, expiry, инвалидация | раздел «Valkey» выше | logout → tombstone, отозванный токен сразу 401 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Рестарт/flush Valkey не теряет сессии (persistence не нужно: Valkey — кэш) | `FLUSHALL`; restart hook | действующий токен работает из БД, отозванный 401, кэш заново заполняется | [evidence/student-tests.txt](evidence/student-tests.txt), [evidence/persistence.txt](evidence/persistence.txt) | +| Параметризованные запросы, ограниченный пул, таймауты | код `src/store.py`, `src/session_cache.py` | пулы ≤10, таймауты 5 с / 250 мс, `statement_timeout` | раздел «Пулы» выше | +| Гонка регистрации одинакового username | 20 параллельных `POST /users` | ровно один 201, 19 × 409 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Rollback составной операции | чат с неизвестным участником | ни чата, ни участников; следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Индекс истории обоснован `EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 сообщений | `history_bench.py`: 110 205 сообщений, один чат на 100 000 и 20 по 500 | см. таблицу ниже: keyset-страница на глубине 90 000 — Index Scan, 51 строка, 7 буферов, 0,058 мс | [evidence/explain.txt](evidence/explain.txt) | +| Пагинация не сканирует всю историю на каждой странице | обход 100 000 сообщений через API, limit=100 | 1000 страниц без потерь и повторов; медиана первых 20 страниц 3,14 мс, последних 20 — 2,83 мс | [evidence/explain.txt](evidence/explain.txt) | +| Автопроверка expiry при коротком TTL | `--expiry-url` (TTL = 2) | 200 → через 3 с 401 с `WWW-Authenticate: Bearer` | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Автопроверка logout и неверного пароля | `test_lab2.py` | logout 204/401/401; неверный пароль 401 Basic | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Автопроверка недоступности БД | `--db-outage` | ready 503, live 200, `/chats` 503 за <10 с, вход 503, неизвестный токен не проходит; после старта прежний токен работает | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Автопроверка недоступности Valkey | `--cache` (stop valkey) | ready 200; токен работает через БД за <2 с; без токена и с чужим 401; вход 201, logout 204 → 401; после старта токен, отозванный во время отказа, остаётся 401 | [evidence/student-tests.txt](evidence/student-tests.txt) | +| Зависание Valkey во время logout не «воскрешает» токен | `--cache` (pause valkey) | logout 204; в Valkey осталась устаревшая копия, но через 6 с (breaker закрыт) токен всё равно 401; в журнале `positive entries distrusted for 31s` | [evidence/student-tests.txt](evidence/student-tests.txt) | + +### EXPLAIN (ANALYZE, BUFFERS) — сводка + +Запрос — ровно тот, что выполняет приложение: + +```sql +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +ORDER BY created_at, id LIMIT 51 +``` + +Данные: 110 205 строк, таблица 22 MB, индекс 11 MB; большой чат — 100 000 сообщений. + +| Вариант | План | Прочитано строк | Буферов | Время выполнения | +| --- | --- | --- | --- | --- | +| Первая страница, индекс | Index Scan `messages_chat_order_idx` | 51 | 5 | 0,064 мс | +| **Keyset после 90 000-го, индекс** (как в приложении) | Index Scan, условие `ROW(created_at, id) > ROW(...)` в Index Cond | 51 | 7 | 0,058 мс | +| OFFSET 90000, индекс (так приложение не делает) | Index Scan, затем отбрасывание | 90 051 | 4 726 | 12,6 мс | +| Первая страница без индекса | Parallel Seq Scan + Sort top-N | вся таблица | 2 836 | 12,3 мс | +| Keyset без индекса | Seq Scan, `Rows Removed by Filter: 100205` | вся таблица | 2 792 | 7,7 мс | + +Вывод: составной индекс `(chat_id, created_at, id)` совпадает с фильтром и сортировкой. Страница любой глубины — это спуск по B-дереву и чтение `limit + 1` записей, без сортировки. Стоимость не зависит ни от глубины, ни от размера чата. `OFFSET` растёт линейно с глубиной, а без индекса каждая страница читает всю таблицу. + +Стоимость индекса: 11 MB на 110 тыс. строк и дополнительная запись в B-дерево при каждой вставке. Заливка 110 тыс. строк с индексом заняла 1,8 с; отдельно стоимость записи на «4» не измерялась. + +Ограничения замера: все страницы в shared buffers (`shared hit`), холодный кэш и диск не измерялись; один прогон на ноутбуке без лимитов CPU/RAM. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Стенд: MacBook (macOS), Docker Desktop 28.0.4, лимиты CPU/RAM на контейнеры не заданы, настройки PostgreSQL и Valkey по умолчанию, кроме указанных выше. Замеры latency последовательные (один клиент), это не нагрузочный тест. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `scripts/restart.sh`: штатный рестарт API, PostgreSQL и Valkey | данные и сессии сохранены, прежний токен работает | public persistence PASS; те же пользователь, чат и история; отозванный токен 401 | ~3–4 с до `ready`; потерь нет; кэш пуст и заполняется заново | +| `docker compose stop postgres` | ready 503, бизнес-запросы 503 за ограниченное время | ready 503, live 200, `/chats` 503, вход 503; `/users/me` — 200 из кэша сессий, пока жива копия (≤30 с), иначе 503 (отзыв без БД невозможен: logout тоже 503) | после `start` — несколько секунд; потерь нет | +| `docker compose stop valkey` | API продолжает работать через PostgreSQL | все операции работают, ready 200, ответ <2 с (одна попытка 250 мс, далее breaker 5 с) | после `start` через 5 с кэш снова используется | +| `FLUSHALL` в Valkey | кэш пуст, корректность сохранена | действующий токен работает, отозванный 401 | мгновенно | +| `docker compose pause valkey` во время logout | отзыв фиксируется в БД, устаревшая копия не принимается | logout 204; устаревшая копия в Valkey не принята (31 с недоверия) | — | +| Сессия с `SESSION_TTL_SECONDS=2` | через 2 с — 401 | 401 на обоих экземплярах API (запись кэша живёт не дольше сессии) | — | + +Гарантии durability: подтверждённое сообщение — это успешный COMMIT. При `fsync=on` и `synchronous_commit=on` (по умолчанию) WAL сброшен на диск до ответа, поэтому рестарт и падение процесса БД не теряют подтверждённых записей. Потерю тома или Docker-host это не покрывает. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Выдерживается: рестарт или пересоздание контейнеров API, PostgreSQL и Valkey при сохранённом томе; временная недоступность PostgreSQL (503 и восстановление без перезапуска API); полная недоступность, зависание или очистка Valkey. +- Не выдерживается: потеря тома или Docker-host (бэкапов нет); единственные экземпляры PostgreSQL, Valkey и API. +- Окно недоверия кэшу после неудачной инвалидации локально для процесса; для нескольких реплик в lab3 нужен общий механизм (см. раздел «Valkey»). +- Во время отказа PostgreSQL `/users/me` может быть отдан из кэша до 30 с — это осознанный выбор: копия соответствует действующей сессии, а отозвать её без БД нельзя. +- HTTP без TLS допустим только на `127.0.0.1` с синтетическими данными. +- Истёкшие и отозванные сессии не удаляются из таблицы автоматически (индекс `sessions_expires_idx` подготовлен для периодической очистки). +- `history_bench.py` при каждом запуске добавляет ~110 тыс. синтетических сообщений в учебную БД. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..19befac6 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,105 @@ +# Lab2: API + PostgreSQL (источник истины) + Valkey (кэш сессий). Секреты — файлы в ./secrets (не коммитятся), создаются scripts/init-secrets.sh. +name: mtusi-lab2 + +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data # данные переживают перезапуск/пересоздание контейнера + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + stop_grace_period: 30s # даём PostgreSQL штатно завершиться (checkpoint) + restart: unless-stopped + + # Кэш проверенных сессий. Источник истины — PostgreSQL, поэтому persistence намеренно + # выключено: после рестарта/flush кэш пуст, сессии читаются из БД и снова кэшируются. + valkey: + image: valkey/valkey:8.0.2-alpine + command: + - valkey-server + - /run/secrets/valkey.conf # requirepass из секрета + - --save + - "" # без RDB-снимков + - --appendonly + - "no" # без AOF + - --maxmemory + - 64mb + - --maxmemory-policy + - allkeys-lru # при нехватке памяти вытесняются старые записи + secrets: + - valkey.conf + healthcheck: + test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(sed -n 's/^requirepass //p' /run/secrets/valkey.conf)\" ping | grep -q PONG"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + + api: + build: . + image: mtusi-messenger:lab2 + environment: + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: ${APP_PORT:-8080} + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-postgres} + DATABASE_URL_FILE: /run/secrets/database_url + DB_POOL_SIZE: ${DB_POOL_SIZE:-10} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + SESSION_CACHE: ${SESSION_CACHE:-valkey} + CACHE_URL_FILE: /run/secrets/cache_url + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-30} + CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-250} + CACHE_RETRY_SECONDS: ${CACHE_RETRY_SECONDS:-5} + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8080:8080" # только localhost: Basic по HTTP — учебный стенд + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_started # Valkey не критичен: API стартует и без него + restart: unless-stopped + + # Отдельный экземпляр API с коротким TTL — только для проверки истечения сессии. + # Запуск: docker compose --profile ttl up -d api-short-ttl (порт 8081, та же БД). + api-short-ttl: + profiles: ["ttl"] + image: mtusi-messenger:lab2 + environment: + SESSION_TTL_SECONDS: 2 + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8081:8080" + depends_on: + postgres: + condition: service_healthy + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + valkey.conf: + file: ./secrets/valkey.conf + cache_url: + file: ./secrets/cache_url + +volumes: + pgdata: diff --git a/evidence/cache-bench.txt b/evidence/cache-bench.txt new file mode 100644 index 00000000..aabc806a --- /dev/null +++ b/evidence/cache-bench.txt @@ -0,0 +1,11 @@ +# 2026-10-15T23:09:37Z 1000 последовательных GET /users/me одним токеном, 3 повтора на режим +{"label": "valkey #1", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.8, "p95_ms": 1.72} +{"label": "valkey #2", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.85, "p95_ms": 2.05} +{"label": "valkey #3", "requests": 1000, "postgres_xact_commit_delta": 3, "p50_ms": 0.86, "p95_ms": 1.83} +$ SESSION_CACHE=off docker compose up -d --wait api +INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=off +{"label": "off #1", "requests": 1000, "postgres_xact_commit_delta": 1789, "p50_ms": 1.16, "p95_ms": 2.28} +{"label": "off #2", "requests": 1000, "postgres_xact_commit_delta": 1693, "p50_ms": 1.09, "p95_ms": 1.98} +{"label": "off #3", "requests": 1000, "postgres_xact_commit_delta": 1699, "p50_ms": 1.08, "p95_ms": 2.02} +$ docker compose up -d --wait api (возврат SESSION_CACHE=valkey) +INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=valkey diff --git a/evidence/database.txt b/evidence/database.txt new file mode 100644 index 00000000..f0a4cf92 --- /dev/null +++ b/evidence/database.txt @@ -0,0 +1,108 @@ +# 2026-10-12T14:22:38Z +--- 1. Миграции с нуля (пустой том, первый старт API): +api-1 | 2026-10-12 14:21:13,412 INFO migration applied: 001_init.sql +api-1 | 2026-10-12 14:21:13,412 INFO schema version: 001_init.sql + +--- 2. Повторный запуск миграций не дублирует данные +до: + users | chats | messages | migrations +-------+-------+----------+------------ + 11 | 5 | 103 | 1 +(1 row) + +$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 1) +2026-10-12 14:22:39,348 INFO schema version: 001_init.sql +2026-10-12 14:22:39,348 INFO migrations are up to date, exiting (--migrate-only) +$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 2) +2026-10-12 14:22:40,518 INFO schema version: 001_init.sql +2026-10-12 14:22:40,518 INFO migrations are up to date, exiting (--migrate-only) +после: + users | chats | messages | migrations +-------+-------+----------+------------ + 11 | 5 | 103 | 1 +(1 row) + + version | applied_at +--------------+------------------------------- + 001_init.sql | 2026-10-12 14:21:13.401972+00 +(1 row) + +--- 3. Схема: ключи, ограничения, индексы + Table "public.users" + Column | Type | Collation | Nullable | Default +---------------+--------------------------+-----------+----------+--------- + id | uuid | | not null | + username | text | | not null | + display_name | text | | not null | + password_hash | text | | not null | + created_at | timestamp with time zone | | not null | +Indexes: + "users_pkey" PRIMARY KEY, btree (id) + "users_username_key" UNIQUE CONSTRAINT, btree (username) +Check constraints: + "users_display_name_len" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100) + "users_username_format" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text) +Referenced by: + TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) + TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) + TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) + + Table "public.chat_members" + Column | Type | Collation | Nullable | Default +----------+---------+-----------+----------+--------- + chat_id | uuid | | not null | + user_id | uuid | | not null | + position | integer | | not null | +Indexes: + "chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id) + "chat_members_user_idx" btree (user_id, chat_id) +Check constraints: + "chat_members_position_check" CHECK ("position" >= 0) +Foreign-key constraints: + "chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE + "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) + + Table "public.messages" + Column | Type | Collation | Nullable | Default +------------+--------------------------+-----------+----------+--------- + id | uuid | | not null | + chat_id | uuid | | not null | + sender_id | uuid | | not null | + text | text | | not null | + created_at | timestamp with time zone | | not null | +Indexes: + "messages_pkey" PRIMARY KEY, btree (id) + "messages_chat_order_idx" btree (chat_id, created_at, id) +Check constraints: + "messages_text_check" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000) +Foreign-key constraints: + "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE + "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) + + Table "public.sessions" + Column | Type | Collation | Nullable | Default +------------+--------------------------+-----------+----------+--------- + token_hash | bytea | | not null | + user_id | uuid | | not null | + created_at | timestamp with time zone | | not null | + expires_at | timestamp with time zone | | not null | + revoked_at | timestamp with time zone | | | +Indexes: + "sessions_pkey" PRIMARY KEY, btree (token_hash) + "sessions_expires_idx" btree (expires_at) +Check constraints: + "sessions_check" CHECK (expires_at > created_at) +Foreign-key constraints: + "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) + +--- 4. Пароли: только scrypt-хеш (показаны параметры), токены: только SHA-256 (32 байта) + kdf_params | count +-----------------------+------- + scrypt N=2^15 r=8 p=1 | 11 +(1 row) + + hash_bytes | sessions | revoked +------------+----------+--------- + 32 | 14 | 2 +(1 row) + diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..9fd3fa3f --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,126 @@ +# 2026-10-15T23:09:01Z MacBook, Docker Desktop 28.0.4, без CPU/RAM-лимитов, postgres:16.4-alpine (настройки по умолчанию) +$ python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500 + +==================================================================================================== +1. Заливка данных +==================================================================================================== +залито за 1.8 с +messages_total | chats_with_messages | in_big_chat | table_size | index_size +----------------+---------------------+-------------+------------+------------ + 110205 | 26 | 100000 | 22 MB | 11 MB +(1 row) + +==================================================================================================== +2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51) +==================================================================================================== +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id LIMIT 51 +QUERY PLAN +------------------------------------------------------------------------------------------------------- + Limit (actual time=0.026..0.038 rows=51 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_order_idx on messages (actual time=0.025..0.035 rows=51 loops=1) + Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) + Buffers: shared hit=5 + Planning: + Buffers: shared hit=137 + Planning Time: 0.396 ms + Execution Time: 0.064 ms +(9 rows) + +==================================================================================================== +2b. С индексом: страница после 90000-го сообщения, keyset-курсор (как в приложении) +==================================================================================================== +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' AND (created_at, id) > ('2026-01-01 00:01:30+00', '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid) ORDER BY created_at, id LIMIT 51 +QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (actual time=0.018..0.029 rows=51 loops=1) + Buffers: shared hit=7 + -> Index Scan using messages_chat_order_idx on messages (actual time=0.017..0.026 rows=51 loops=1) + Index Cond: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid))) + Buffers: shared hit=7 + Planning: + Buffers: shared hit=136 + Planning Time: 0.352 ms + Execution Time: 0.058 ms +(9 rows) + +==================================================================================================== +2c. Для сравнения: та же глубина через OFFSET 90000 (так приложение НЕ делает) +==================================================================================================== +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id OFFSET 90000 LIMIT 51 +QUERY PLAN +----------------------------------------------------------------------------------------------------------- + Limit (actual time=12.582..12.591 rows=51 loops=1) + Buffers: shared hit=4726 + -> Index Scan using messages_chat_order_idx on messages (actual time=0.019..10.068 rows=90051 loops=1) + Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) + Buffers: shared hit=4726 + Planning: + Buffers: shared hit=137 + Planning Time: 0.377 ms + Execution Time: 12.607 ms +(9 rows) + +==================================================================================================== +2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются) +==================================================================================================== +--- первая страница без индекса + QUERY PLAN +----------------------------------------------------------------------------------------------- + Limit (actual time=10.974..12.247 rows=51 loops=1) + Buffers: shared hit=2836 + -> Gather Merge (actual time=10.973..12.241 rows=51 loops=1) + Workers Planned: 1 + Workers Launched: 1 + Buffers: shared hit=2836 + -> Sort (actual time=9.575..9.579 rows=51 loops=2) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 39kB + Buffers: shared hit=2836 + Worker 0: Sort Method: top-N heapsort Memory: 40kB + -> Parallel Seq Scan on messages (actual time=0.019..6.242 rows=50000 loops=2) + Filter: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) + Rows Removed by Filter: 5102 + Buffers: shared hit=2792 + Planning: + Buffers: shared hit=104 + Planning Time: 0.367 ms + Execution Time: 12.294 ms +(19 rows) + +--- keyset-страница без индекса + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (actual time=7.631..7.636 rows=51 loops=1) + Buffers: shared hit=2792 + -> Sort (actual time=7.630..7.632 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 45kB + Buffers: shared hit=2792 + -> Seq Scan on messages (actual time=4.642..7.102 rows=10000 loops=1) + Filter: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid))) + Rows Removed by Filter: 100205 + Buffers: shared hit=2792 + Planning Time: 0.060 ms + Execution Time: 7.668 ms +(12 rows) +indexname +------------------------- + messages_chat_order_idx + messages_pkey +(2 rows) + +==================================================================================================== +3. Полный обход истории большого чата через API (limit=100) +==================================================================================================== +{ + "pages": 1000, + "messages_read": 100000, + "expected": 100000, + "first_20_pages_median_ms": 3.14, + "last_20_pages_median_ms": 2.83, + "all_pages_p50_ms": 2.8, + "all_pages_p95_ms": 4.33, + "all_pages_max_ms": 10.96 +} +PASS: все 100000 сообщений прочитаны без потерь и повторов diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..3b0a19c1 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,22 @@ +# 2026-10-15T23:10:29Z +--- до: контейнеры +/mtusi-lab2-api-1 started=2026-10-15T23:10:13.308098346Z +/mtusi-lab2-postgres-1 started=2026-10-15T23:08:12.796745137Z +/mtusi-lab2-valkey-1 started=2026-10-15T23:08:12.79643622Z +$ make test-persistence ACTION_SCRIPT=scripts/restart.sh +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +--- после: контейнеры (StartedAt изменился у всех трёх => перезапущены API, PostgreSQL и Valkey) +/mtusi-lab2-api-1 started=2026-10-15T23:10:33.226933382Z +/mtusi-lab2-postgres-1 started=2026-10-15T23:10:31.075516256Z +/mtusi-lab2-valkey-1 started=2026-10-15T23:10:31.076417256Z +--- том pgdata сохранён: +mtusi-lab2_pgdata created=2026-10-12T14:21:10Z +--- логи PostgreSQL о перезапуске: +postgres-1 | 2026-10-15 23:10:30.838 UTC [1] LOG: database system is shut down +postgres-1 | 2026-10-15 23:10:31.171 UTC [29] LOG: database system was shut down at 2026-10-15 23:10:30 UTC +postgres-1 | 2026-10-15 23:10:31.174 UTC [1] LOG: database system is ready to accept connections +--- логи Valkey о перезапуске: +valkey-1 | 1:signal-handler (1792105830) Received SIGTERM scheduling shutdown... +valkey-1 | 1:M 15 Oct 2026 23:10:31.135 * Ready to accept connections tcp diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..803365ed --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,8 @@ +# 2026-10-15T23:10:28Z +$ make check +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. + +$ make test +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/stack.txt b/evidence/stack.txt new file mode 100644 index 00000000..96bdbee6 --- /dev/null +++ b/evidence/stack.txt @@ -0,0 +1,55 @@ +# 2026-10-15T23:11:46Z +Docker Engine 28.0.4 +Docker Compose version v2.34.0-desktop.1 + +$ docker compose ps +SERVICE IMAGE STATUS PORTS +api mtusi-messenger:lab2 Up 11 seconds (healthy) 127.0.0.1:8080->8080/tcp +postgres postgres:16.4-alpine Up 13 seconds (healthy) 5432/tcp +valkey valkey/valkey:8.0.2-alpine Up 13 seconds (healthy) 6379/tcp + +$ docker volume ls (именованные тома стенда) +mtusi-lab2_pgdata + +$ Valkey: persistence выключено намеренно (кэш, источник истины — PostgreSQL) +save +appendonly no +maxmemory-policy allkeys-lru +$ Valkey без пароля не отвечает: +NOAUTH Authentication required. + + +$ процесс API — PID 1, не root +uid=10001(app) gid=10001(app) groups=10001(app) +python /app/src/server.py + +$ git status --short --ignored + M .env.example + M Makefile + M REPORT.md +?? Dockerfile +?? compose.yaml +?? evidence/cache-bench.txt +?? evidence/database.txt +?? evidence/explain.txt +?? evidence/persistence.txt +?? evidence/smoke.txt +?? evidence/stack.txt +?? evidence/student-tests.txt +?? migrations/ +?? requirements.txt +?? scripts/init-secrets.sh +?? scripts/restart.sh +?? src/ +?? student-tests/ +!! .env +!! secrets/ +!! src/__pycache__/ +!! student-tests/__pycache__/ + +$ git check-ignore secrets/* .env +secrets/cache_url +secrets/database_url +secrets/postgres_password +secrets/valkey.conf +.env diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..26c4754d --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,108 @@ +# 2026-10-15T23:10:42Z +$ python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence +OK регистрация без password -> 400 (ожидалось 400) +OK password 11 символов -> 400 (ожидалось 400) +OK password 129 символов -> 400 (ожидалось 400) +OK password не строка -> 400 (ожидалось 400) +OK дубликат username -> 409 (ожидалось 409) +OK User не содержит пароль/хеш -> ['created_at', 'display_name', 'id', 'us… (ожидалось ['created_at', 'display_name', 'id', 'us…) +OK malformed JSON -> 400 (ожидалось 400) +OK неверный пароль -> 401 (ожидалось 401) +OK challenge Basic -> True (ожидалось True) +OK неизвестный пользователь -> 401 (ожидалось 401) +OK вход без Authorization -> 401 (ожидалось 401) +OK вход с Bearer вместо Basic -> 401 (ожидалось 401) +OK мусор вместо base64 -> 401 (ожидалось 401) +OK пароль с двоеточием и Unicode -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25) +OK два входа дают разные токены -> True (ожидалось True) +OK без токена -> 401 (ожидалось 401) +OK challenge Bearer -> True (ожидалось True) +OK случайный токен -> 401 (ожидалось 401) +OK Basic на бизнес-endpoint -> 401 (ожидалось 401) +OK только X-User-Id -> 401 (ожидалось 401) +OK X-User-Id не меняет владельца -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25) +OK logout -> 204 (ожидалось 204) +OK отозванный токен -> 401 (ожидалось 401) +OK повторный logout -> 401 (ожидалось 401) +OK другая сессия того же пользователя жива -> 200 (ожидалось 200) +OK чат: создатель не участник -> 400 (ожидалось 400) +OK чат: неизвестный участник -> 400 (ожидалось 400) +OK чат: дубликат участника -> 400 (ожидалось 400) +OK порядок member_ids сохранён -> ['50babb13-8c3d-4066-9146-f2961f042e25',… (ожидалось ['50babb13-8c3d-4066-9146-f2961f042e25',…) +OK чужой чат (Ева) -> 404 (ожидалось 404) +OK запись в чужой чат (Ева) -> 404 (ожидалось 404) +OK пустое сообщение -> 400 (ожидалось 400) +OK sender_id в теле -> 400 (ожидалось 400) +OK 4001 символ -> 400 (ожидалось 400) +OK 100 параллельных POST: ошибок -> 0 (ожидалось 0) +OK 100 параллельных POST: уникальных -> 100 (ожидалось 100) +OK история отсортирована (created_at, id) -> True (ожидалось True) +OK cursor от другого чата -> 400 (ожидалось 400) +OK мусорный cursor -> 400 (ожидалось 400) +OK limit=0 -> 400 (ожидалось 400) +OK неверный UUID в пути -> 400 (ожидалось 400) +OK гонка 20 регистраций: ровно один 201 -> 1 (ожидалось 1) +OK гонка 20 регистраций: остальные 409 -> 19 (ожидалось 19) +OK чат с неизвестным 3-м участником -> 400 (ожидалось 400) +OK после ошибки чат не появился у создателя -> [] (ожидалось []) +OK после ошибки чат не появился у участника b -> ['f719daa9-38c4-45b4-9e11-72582a3ab25d'] (ожидалось ['f719daa9-38c4-45b4-9e11-72582a3ab25d']) +OK следующее создание чата работает -> (201, ['50f22c4f-7abb-4395-9921-1bb23c95… (ожидалось (201, ['50f22c4f-7abb-4395-9921-1bb23c95…) +OK TTL=2: вход -> 201 (ожидалось 201) +OK TTL=2: сразу после входа токен работает -> 200 (ожидалось 200) +OK TTL=2: через 3 с токен истёк -> 401 (ожидалось 401) +OK challenge Bearer -> True (ожидалось True) +OK TTL=2: истёкший токен не работает и на основном API -> 401 (ожидалось 401) +--- остановка PostgreSQL: docker compose stop postgres +OK БД нет: /health/ready -> (503, 'unavailable') (ожидалось (503, 'unavailable')) +OK БД нет: /health/live -> 200 (ожидалось 200) +OK БД нет: список чатов с токеном -> 503, не 200 -> (503, 'unavailable') (ожидалось (503, 'unavailable')) +OK БД нет: ответ ограничен по времени (<10 с) -> True (ожидалось True) +OK БД нет: /users/me -> 200 из кэша или 503 -> True (ожидалось True) +OK БД нет: неизвестный токен не проходит -> True (ожидалось True) +OK БД нет: анонимный запрос не проходит -> True (ожидалось True) +OK БД нет: вход -> 503 -> 503 (ожидалось 503) +OK БД вернулась: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…) +OK кэш: после входа в Valkey лежит копия сессии -> True (ожидалось True) +OK кэш: в Valkey нет самого токена/пароля -> True (ожидалось True) +OK кэш: 50 запросов -> 50 попаданий в Valkey -> (50, 0) (ожидалось (50, 0)) +OK кэш: logout -> 204 (ожидалось 204) +OK кэш: в Valkey tombstone вместо копии -> revoked (ожидалось revoked) +OK кэш: отозванный токен сразу 401 -> 401 (ожидалось 401) +OK FLUSHALL: действующий токен работает (из БД) -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…) +OK FLUSHALL: отозванный токен по-прежнему 401 -> 401 (ожидалось 401) +OK FLUSHALL: кэш снова заполнен после промаха -> True (ожидалось True) +--- остановка Valkey: docker compose stop valkey +OK Valkey нет: /health/ready 200 (не критичен) -> 200 (ожидалось 200) +OK Valkey нет: токен работает через БД -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…) +OK Valkey нет: ответ быстрый (<2 с) -> True (ожидалось True) +OK Valkey нет: список чатов -> 200 (ожидалось 200) +OK Valkey нет: без токена 401 -> 401 (ожидалось 401) +OK Valkey нет: чужой токен 401 -> 401 (ожидалось 401) +OK Valkey нет: отозванный токен 401 -> 401 (ожидалось 401) +OK Valkey нет: вход 201 -> True (ожидалось True) +OK Valkey нет: logout 204 -> 204 (ожидалось 204) +OK Valkey нет: после logout 401 -> 401 (ожидалось 401) +OK Valkey вернулся: токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…) +OK Valkey вернулся: кэш снова заполняется -> True (ожидалось True) +OK Valkey вернулся: токен, отозванный при отказе, 401 -> 401 (ожидалось 401) +--- зависание Valkey во время logout: docker compose pause valkey +OK Valkey завис: logout всё равно 204 (отзыв в БД) -> 204 (ожидалось 204) +OK Valkey ожил: в нём осталась устаревшая копия -> True (ожидалось True) +OK Valkey ожил: устаревшая копия не принята, 401 -> 401 (ожидалось 401) +OK Valkey ожил: действующий токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…) +--- перезапуск API и PostgreSQL: scripts/restart.sh +OK после рестарта: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…) +OK после рестарта: чат на месте -> {'id': 'f719daa9-38c4-45b4-9e11-72582a3a… (ожидалось {'id': 'f719daa9-38c4-45b4-9e11-72582a3a…) +OK после рестарта: история та же -> [{'id': 'c0e23a76-540f-46db-81a4-dbee552… (ожидалось [{'id': 'c0e23a76-540f-46db-81a4-dbee552…) +OK после рестарта: отозванный токен всё ещё отозван -> 401 (ожидалось 401) +OK после рестарта: вход по паролю работает -> 201 (ожидалось 201) +ИТОГО: ВСЕ ПРОВЕРКИ ПРОШЛИ + +--- журнал API во время отказов Valkey (без токенов и тел запросов): +2026-10-15 23:10:56,857 WARNING database unavailable request_id=4ab5c512a16341c4bf7cc58c88e683e3 +2026-10-15 23:11:01,873 WARNING database unavailable request_id=5c558c1c14714272a4563a46f3c2a88b +2026-10-15 23:11:06,888 WARNING database unavailable request_id=a20e46964d9046cb9aacf37b77904c45 +2026-10-15 23:11:18,939 WARNING cache unavailable op=get; bypassing cache for 5s +2026-10-15 23:11:19,032 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s +2026-10-15 23:11:25,882 WARNING cache unavailable op=get; bypassing cache for 5s +2026-10-15 23:11:26,156 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..b301bafb --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,51 @@ +-- Lab2, миграция 001: начальная схема. Источник истины — PostgreSQL. +-- Применяется приложением один раз (таблица schema_migrations, advisory lock), +-- в одной транзакции вместе с отметкой о версии. + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, -- scrypt$logN$r$p$salt$hash, не plaintext + 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_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL +); + +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 CHECK (position >= 0), -- порядок участников как в запросе + PRIMARY KEY (chat_id, user_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 CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL +); +-- Keyset-пагинация истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) +-- ORDER BY created_at, id LIMIT n — читает только нужную страницу индекса. +CREATE INDEX messages_chat_order_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, -- SHA-256 от токена; сам токен не хранится + user_id uuid NOT NULL REFERENCES users(id), + created_at timestamptz NOT NULL, + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CHECK (expires_at > created_at) +); +-- Для обслуживания: удаление истёкших сессий (DELETE ... WHERE expires_at < now()). +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..0a08885f --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +# Закреплённые версии: драйвер и пул PostgreSQL, клиент Redis-протокола для Valkey. +psycopg[binary]==3.2.3 +psycopg-pool==3.2.4 +redis==5.2.1 diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..d1aed208 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,27 @@ +#!/bin/sh +# Создаёт локальные синтетические секреты для учебного стенда (каталог secrets/ в .gitignore). +# Повторный запуск не перезаписывает существующие файлы: пароль БД в volume уже задан. +set -eu +cd "$(dirname "$0")/.." +mkdir -p secrets +chmod 700 secrets +if [ ! -f secrets/postgres_password ]; then + python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")' > secrets/postgres_password + echo "created secrets/postgres_password" +fi +if [ ! -f secrets/database_url ]; then + printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password)" > secrets/database_url + echo "created secrets/database_url" +fi +if [ ! -f secrets/valkey.conf ]; then + # Пароль Valkey передаётся через конфиг-файл (Docker secret), а не аргументом командной строки. + VALKEY_PASSWORD=$(python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")') + printf 'requirepass %s\n' "$VALKEY_PASSWORD" > secrets/valkey.conf + printf 'redis://:%s@valkey:6379/0' "$VALKEY_PASSWORD" > secrets/cache_url + echo "created secrets/valkey.conf and secrets/cache_url" +fi +# Файлы монтируются в контейнеры как Docker secrets; процессы там работают не от uid хоста, +# поэтому файлы читаемы, а доступ ограничивает каталог secrets/ (700). +chmod 644 secrets/postgres_password secrets/database_url secrets/valkey.conf secrets/cache_url +[ -f .env ] || { cp .env.example .env; echo "created .env from .env.example"; } +echo "secrets ready (values are not printed)" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..e91c1c48 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,11 @@ +#!/bin/sh +# Перезапуск API и всех используемых хранилищ (PostgreSQL, Valkey) с сохранением volume pgdata. +# Не выполняет down -v, не пересоздаёт БД и не меняет данные. +set -eu +cd "$(dirname "$0")/.." +# Сначала останавливаем API, затем хранилища (PostgreSQL — штатный shutdown с checkpoint); +# поднимаем в обратном порядке. Valkey без persistence стартует с пустым кэшем. +docker compose --env-file .env stop api +docker compose --env-file .env stop postgres valkey +docker compose --env-file .env start postgres valkey +docker compose --env-file .env start api diff --git a/src/security.py b/src/security.py new file mode 100644 index 00000000..f9078acf --- /dev/null +++ b/src/security.py @@ -0,0 +1,53 @@ +"""Пароли (scrypt из стандартной библиотеки) и сессионные токены.""" +import base64 +import hashlib +import hmac +import os +import secrets + +# Параметры scrypt: N=2^15, r=8, p=1 (~32 МБ памяти и ~0.1 с на проверку). +SCRYPT_LOG_N = 15 +SCRYPT_R = 8 +SCRYPT_P = 1 +_MAXMEM = 128 * 1024 * 1024 + + +def _scrypt(password, salt, log_n, r, p): + return hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2 ** log_n, r=r, p=p, + maxmem=_MAXMEM, dklen=32) + + +def hash_password(password): + """Возвращает строку scrypt$logN$r$p$salt$hash; plaintext нигде не хранится.""" + salt = os.urandom(16) + digest = _scrypt(password, salt, SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P) + return "scrypt$%d$%d$%d$%s$%s" % ( + SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P, + base64.b64encode(salt).decode(), base64.b64encode(digest).decode()) + + +def verify_password(password, stored): + try: + scheme, log_n, r, p, salt, digest = stored.split("$") + if scheme != "scrypt": + return False + expected = base64.b64decode(digest) + actual = _scrypt(password, base64.b64decode(salt), int(log_n), int(r), int(p)) + except (ValueError, TypeError): + return False + return hmac.compare_digest(actual, expected) # сравнение за постоянное время + + +# Хеш несуществующего пользователя: неверный логин тратит столько же времени, +# сколько неверный пароль, и не выдаёт, существует ли username. +DUMMY_HASH = hash_password(secrets.token_urlsafe(16)) + + +def new_token(): + """Непрозрачный случайный токен: 32 байта = 256 бит энтропии.""" + return secrets.token_urlsafe(32) + + +def token_hash(token): + """В БД лежит только SHA-256 токена: утечка таблицы не даёт готовых сессий.""" + return hashlib.sha256(token.encode("utf-8")).digest() diff --git a/src/server.py b/src/server.py new file mode 100644 index 00000000..d70cc8c4 --- /dev/null +++ b/src/server.py @@ -0,0 +1,503 @@ +#!/usr/bin/env python3 +"""MTUSI Messenger, lab2: REST API с PostgreSQL и сессиями. + +Отличия от lab1: + * данные лежат в PostgreSQL и переживают перезапуск API и БД; + * регистрация требует password (хранится только scrypt-хеш); + * POST /api/v1/auth/sessions (Basic) выдаёт Bearer-токен; + * все защищённые endpoint принимают только Authorization: Bearer; + * X-User-Id игнорируется. + +Общий каркас (маршрутизация, формат ошибок, X-Request-Id, валидация, keyset-курсор) +перенесён из lab1 (app/server.py); хранилище в памяти заменено на store.py. +""" +import base64 +import binascii +import json +import logging +import os +import re +import signal +import sys +import threading +import time +import uuid +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from urllib.parse import parse_qs, urlsplit + +import psycopg +from psycopg.conninfo import make_conninfo +from psycopg_pool import PoolTimeout + +import security +from session_cache import REVOKED, SessionCache +from store import Conflict, Store, UnknownMember, format_ts + +HOST = os.environ.get("APP_HOST", "0.0.0.0") +PORT = int(os.environ.get("APP_PORT", "8080")) +APP_ENV = os.environ.get("APP_ENV", "lab") +SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) +MIGRATIONS_DIR = os.environ.get("MIGRATIONS_DIR", str(Path(__file__).resolve().parents[1] / "migrations")) +MAX_BODY_BYTES = 1024 * 1024 + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +DEFAULT_LIMIT = 50 +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + +logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") +log = logging.getLogger("messenger") + + +def database_conninfo(): + """Строка подключения к PostgreSQL. + + Порядок: DATABASE_URL_FILE (Docker secret, рекомендуемый путь) → DATABASE_URL → + набор POSTGRES_*. Значение секрета нигде не логируется. + """ + path = os.environ.get("DATABASE_URL_FILE") + if path: + url = Path(path).read_text(encoding="utf-8").strip() + else: + url = os.environ.get("DATABASE_URL", "") + if url: + # connect_timeout ограничивает ожидание недоступной БД при открытии соединения. + return make_conninfo(url, connect_timeout=5) + return make_conninfo( + host=os.environ.get("POSTGRES_HOST", "localhost"), + port=os.environ.get("POSTGRES_PORT", "5432"), + dbname=os.environ.get("POSTGRES_DB", "messenger"), + user=os.environ.get("POSTGRES_USER", "messenger"), + password=os.environ.get("POSTGRES_PASSWORD", ""), + connect_timeout=5, + ) + + +STORE = Store(database_conninfo(), + pool_size=int(os.environ.get("DB_POOL_SIZE", "10")), + statement_timeout_ms=int(os.environ.get("DB_STATEMENT_TIMEOUT_MS", "5000"))) + + +def cache_url(): + """URL Valkey из CACHE_URL_FILE (Docker secret). SESSION_CACHE=off отключает кэш.""" + if os.environ.get("SESSION_CACHE", "valkey").lower() == "off": + return "" + path = os.environ.get("CACHE_URL_FILE") + if path: + return Path(path).read_text(encoding="utf-8").strip() + return os.environ.get("CACHE_URL", "") + + +SESSION_CACHE = SessionCache( + cache_url(), + ttl_seconds=int(os.environ.get("SESSION_CACHE_TTL_SECONDS", "30")), + timeout_ms=int(os.environ.get("CACHE_TIMEOUT_MS", "250")), + retry_seconds=float(os.environ.get("CACHE_RETRY_SECONDS", "5"))) + + +# -------------------------------------------------------------------------- +# Ошибки API +# -------------------------------------------------------------------------- +class ApiError(Exception): + def __init__(self, status, code, message, headers=None): + super().__init__(message) + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + + +def bad_request(message="Неверный запрос"): + return ApiError(400, "invalid_request", message) + + +def unauthorized(challenge=BEARER_CHALLENGE): + # Одинаковый ответ для любых причин: не раскрываем, что именно не так. + return ApiError(401, "unauthorized", "Требуется действительная аутентификация", + {"WWW-Authenticate": challenge}) + + +def not_found(): + return ApiError(404, "not_found", "Объект не найден") + + +# -------------------------------------------------------------------------- +# Валидация +# -------------------------------------------------------------------------- +def parse_uuid(value): + try: + return str(uuid.UUID(value)) + except (ValueError, TypeError, AttributeError): + return None + + +def require_object(body, allowed, required): + if not isinstance(body, dict): + raise bad_request("Тело запроса должно быть JSON-объектом") + if set(body) - set(allowed): + raise bad_request("Лишние поля в запросе") + if any(k not in body for k in required): + raise bad_request("Не хватает обязательных полей") + + +def require_text(value, field, max_len, min_len=1): + if not isinstance(value, str): + raise bad_request("Поле %s должно быть строкой" % field) + if not value.strip(): + raise bad_request("Поле %s не должно быть пустым" % field) + if "\x00" in value: + raise bad_request("Поле %s содержит недопустимый символ" % field) + if not min_len <= len(value) <= max_len: # len() считает Unicode code points + raise bad_request("Поле %s имеет недопустимую длину" % field) + return value + + +def encode_cursor(kind, scope, key): + raw = json.dumps({"k": kind, "s": scope, "t": key[0], "i": key[1]}, separators=(",", ":")) + return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=") + + +def decode_cursor(cursor, kind, scope): + try: + padded = cursor + "=" * (-len(cursor) % 4) + data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii"))) + if data["k"] != kind or data["s"] != scope: + raise ValueError + t, i = data["t"], parse_uuid(data["i"]) + if not isinstance(t, int) or isinstance(t, bool) or i is None or abs(t) > 10 ** 17: + raise ValueError + return (t, i) + except (ValueError, KeyError, TypeError, UnicodeError, binascii.Error): + raise bad_request("Неверный cursor") + + +def page_params(query): + def single(name): + values = query.get(name) + if values is None: + return None + if len(values) != 1: + raise bad_request("Параметр %s указан несколько раз" % name) + return values[0] + + limit_raw = single("limit") + if limit_raw is None: + limit = DEFAULT_LIMIT + else: + if not re.fullmatch(r"[0-9]{1,3}", limit_raw) or not 1 <= int(limit_raw) <= 100: + raise bad_request("limit должен быть целым от 1 до 100") + limit = int(limit_raw) + cursor = single("cursor") + if cursor == "": + raise bad_request("Неверный cursor") + return limit, cursor + + +# -------------------------------------------------------------------------- +# Обработчики +# -------------------------------------------------------------------------- +def h_live(req): + return 200, {"status": "ok"} + + +def h_ready(req): + # Критичная зависимость одна — PostgreSQL. Без неё обслуживать запросы нельзя. + # Valkey не критичен: при его отказе сессии проверяются напрямую в PostgreSQL. + try: + STORE.ping() + except Exception: + raise ApiError(503, "unavailable", "Сервис временно недоступен") + return 200, {"status": "ok"} + + +def h_create_user(req): + body = req.json_body() + fields = ("username", "display_name", "password") + require_object(body, fields, fields) + username = body["username"] + if not isinstance(username, str) or not USERNAME_RE.fullmatch(username): + raise bad_request("username должен соответствовать [a-z0-9_]{3,32}") + display_name = require_text(body["display_name"], "display_name", 100) + password = require_text(body["password"], "password", 128, min_len=12) + try: + return 201, STORE.create_user(username, display_name, security.hash_password(password)) + except Conflict: + raise ApiError(409, "conflict", "Имя пользователя уже занято") + + +def h_create_session(req): + """Вход: только Authorization: Basic, без JSON body.""" + header = req.headers.get("Authorization", "") + scheme, _, encoded = header.partition(" ") + failure = unauthorized(BASIC_CHALLENGE) + if scheme.lower() != "basic": + raise failure + try: + decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8") + except (binascii.Error, ValueError, UnicodeError): + raise failure + username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо + if not sep: + raise failure + user, stored_hash = (None, None) + if USERNAME_RE.fullmatch(username): + user, stored_hash = STORE.get_credentials(username) + # Проверяем scrypt всегда (для неизвестного логина — с фиктивным хешем): + # время ответа не выдаёт, существует ли пользователь. + ok = security.verify_password(password, stored_hash or security.DUMMY_HASH) + if user is None or not ok: + raise failure + token = security.new_token() + th = security.token_hash(token) + started = time.monotonic() + expires_at = STORE.create_session(user["id"], th, SESSION_TTL_SECONDS) # источник истины + SESSION_CACHE.put(th, user, expires_at.timestamp(), started) # прогрев кэша + return 201, {"token": token, "token_type": "Bearer", "expires_at": format_ts(expires_at), "user": user} + + +def h_delete_session(req): + req.current_user() + STORE.revoke_session(req.token_hash) # 1) COMMIT отзыва в PostgreSQL + SESSION_CACHE.revoke(req.token_hash) # 2) tombstone в Valkey поверх возможной копии + return 204, None + + +def h_me(req): + return 200, req.current_user() + + +def h_create_chat(req): + user = req.current_user() + body = req.json_body() + require_object(body, ("title", "member_ids"), ("title", "member_ids")) + title = require_text(body["title"], "title", 100) + members = body["member_ids"] + if not isinstance(members, list) or not 1 <= len(members) <= 100: + raise bad_request("member_ids должен быть списком из 1–100 UUID") + normalized = [] + for m in members: + mid = parse_uuid(m) if isinstance(m, str) else None + if mid is None: + raise bad_request("member_ids должен содержать UUID-строки") + normalized.append(mid) + if len(set(normalized)) != len(normalized): + raise bad_request("Дубликаты в member_ids") + if user["id"] not in normalized: + raise bad_request("Создатель должен входить в member_ids") + try: + return 201, STORE.create_chat(title, normalized) + except UnknownMember: + raise bad_request("Неизвестный участник чата") + + +def h_list_chats(req): + user = req.current_user() + limit, cursor = page_params(req.query) + after = decode_cursor(cursor, "chats", user["id"]) if cursor else None + items, last = STORE.list_chats(user["id"], after, limit) + return 200, {"items": items, "next_cursor": encode_cursor("chats", user["id"], last) if last else None} + + +def _chat_or_404(user, chat_id): + chat = STORE.get_chat_for(user["id"], chat_id) + if chat is None: + raise not_found() + return chat + + +def h_get_chat(req, chat_id): + user = req.current_user() + return 200, _chat_or_404(user, req.path_uuid(chat_id)) + + +def h_create_message(req, chat_id): + user = req.current_user() + cid = req.path_uuid(chat_id) + _chat_or_404(user, cid) # сначала доступ: посторонний получает 404 + body = req.json_body() + require_object(body, ("text",), ("text",)) + text = require_text(body["text"], "text", 4000) + message = STORE.add_message(user["id"], cid, text) + if message is None: + raise not_found() + return 201, message + + +def h_list_messages(req, chat_id): + user = req.current_user() + cid = req.path_uuid(chat_id) + _chat_or_404(user, cid) + limit, cursor = page_params(req.query) + after = decode_cursor(cursor, "messages", cid) if cursor else None + items, last = STORE.list_messages(cid, after, limit) + return 200, {"items": items, "next_cursor": encode_cursor("messages", cid, last) if last else None} + + +ROUTES = [ + ("GET", re.compile(r"^/health/live$"), h_live), + ("GET", re.compile(r"^/health/ready$"), h_ready), + ("POST", re.compile(r"^/api/v1/users$"), h_create_user), + ("GET", re.compile(r"^/api/v1/users/me$"), h_me), + ("POST", re.compile(r"^/api/v1/auth/sessions$"), h_create_session), + ("DELETE", re.compile(r"^/api/v1/auth/sessions/current$"), h_delete_session), + ("POST", re.compile(r"^/api/v1/chats$"), h_create_chat), + ("GET", re.compile(r"^/api/v1/chats$"), h_list_chats), + ("GET", re.compile(r"^/api/v1/chats/([^/]+)$"), h_get_chat), + ("POST", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_create_message), + ("GET", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_list_messages), +] + + +class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + server_version = "mtusi-messenger/2.0" + sys_version = "" + + def json_body(self): + ctype = (self.headers.get("Content-Type") or "").split(";")[0].strip().lower() + if ctype != "application/json": + raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json") + try: + return json.loads(self._body.decode("utf-8")) + except (UnicodeDecodeError, ValueError): + raise bad_request("Некорректный JSON") + + def current_user(self): + """Только Bearer-токен действующей сессии. Basic и X-User-Id доступа не дают.""" + scheme, _, token = self.headers.get("Authorization", "").partition(" ") + token = token.strip() + if scheme.lower() != "bearer" or not token: + raise unauthorized() + self.token_hash = security.token_hash(token) + cached = SESSION_CACHE.get(self.token_hash) # 1) Valkey: hit / tombstone / промах + if cached is REVOKED: + raise unauthorized() + if cached is not None: + return cached + started = time.monotonic() + found = STORE.get_session_user(self.token_hash) # 2) промах → PostgreSQL + if found is None: + raise unauthorized() + user, expires_at = found + SESSION_CACHE.put(self.token_hash, user, expires_at.timestamp(), started) + return user + + def path_uuid(self, value): + parsed = parse_uuid(value) + if parsed is None: + raise bad_request("Неверный UUID в пути") + return parsed + + def _read_body(self): + length = self.headers.get("Content-Length") + if length is None: + return b"" + try: + n = int(length) + except ValueError: + raise bad_request("Неверный Content-Length") + if n < 0: + raise bad_request("Неверный Content-Length") + if n > MAX_BODY_BYTES: + self.close_connection = True + raise ApiError(413, "payload_too_large", "Тело запроса слишком большое") + return self.rfile.read(n) + + def _dispatch(self, method): + self.request_id = uuid.uuid4().hex + started = time.monotonic() + parts = urlsplit(self.path) + path = parts.path + headers = {} + try: + self._body = self._read_body() + self.query = parse_qs(parts.query, keep_blank_values=True) + for m, pattern, func in ROUTES: + match = pattern.match(path) + if match and m == method: + status, payload = func(self, *match.groups()) + break + else: + raise not_found() + except ApiError as err: + status, payload, headers = err.status, self._error(err.code, err.message), err.headers + except (psycopg.OperationalError, PoolTimeout): + # БД недоступна: честный 503, а не «успех» или 500. + log.warning("database unavailable request_id=%s", self.request_id) + status, payload = 503, self._error("unavailable", "Сервис временно недоступен") + except Exception: + log.exception("unhandled error request_id=%s", self.request_id) + status, payload = 500, self._error("internal_error", "Внутренняя ошибка сервера") + self._send(status, payload, headers) + # В лог не попадают тела запросов, пароли, токены и тексты сообщений. + log.info("%s %s -> %d %.1fms request_id=%s", method, path, status, + (time.monotonic() - started) * 1000, self.request_id) + + def _error(self, code, message): + return {"error": {"code": code, "message": message, "request_id": self.request_id}} + + def _send(self, status, payload, headers): + self.send_response(status) + self.send_header("X-Request-Id", self.request_id) + for name, value in headers.items(): + self.send_header(name, value) + if payload is None: # 204: без тела + self.end_headers() + return + data = json.dumps(payload, ensure_ascii=False).encode("utf-8") + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(data))) + self.end_headers() + self.wfile.write(data) + + def do_GET(self): + self._dispatch("GET") + + def do_POST(self): + self._dispatch("POST") + + def do_PUT(self): + self._dispatch("PUT") + + def do_PATCH(self): + self._dispatch("PATCH") + + def do_DELETE(self): + self._dispatch("DELETE") + + def log_message(self, fmt, *args): + pass + + +class Server(ThreadingHTTPServer): + request_queue_size = 1024 + daemon_threads = True + + +def main(): + STORE.open() + STORE.migrate(MIGRATIONS_DIR) + if "--migrate-only" in sys.argv[1:]: + # Отдельный запуск миграций: docker compose run --rm api python /app/src/server.py --migrate-only + log.info("migrations are up to date, exiting (--migrate-only)") + STORE.close() + return + server = Server((HOST, PORT), Handler) + + def stop(signum, frame): + log.info("signal %d received, shutting down", signum) + threading.Thread(target=server.shutdown, daemon=True).start() + + signal.signal(signal.SIGTERM, stop) + signal.signal(signal.SIGINT, stop) + log.info("listening on %s:%d env=%s session_ttl=%ds session_cache=%s", HOST, PORT, APP_ENV, + SESSION_TTL_SECONDS, "valkey" if SESSION_CACHE.enabled else "off") + server.serve_forever() + server.server_close() + STORE.close() + log.info("stopped") + + +if __name__ == "__main__": + main() diff --git a/src/session_cache.py b/src/session_cache.py new file mode 100644 index 00000000..694e1999 --- /dev/null +++ b/src/session_cache.py @@ -0,0 +1,121 @@ +"""Кэш сессий в Valkey (уровень 4). + +Роль: ускорить проверку Bearer-токена, которая выполняется на КАЖДОМ защищённом запросе. +Источник истины — таблица sessions в PostgreSQL; Valkey хранит только производные копии. + +Ключ: sess: (сам токен в Valkey не попадает) +Значение: {"user": {...}, "exp": } либо "revoked" + +Политика expiry: + * положительная запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток сессии) — PX в мс, + поэтому кэш не переживает саму сессию; при чтении "exp" дополнительно сверяется с часами; + * запись "revoked" (tombstone) живёт SESSION_CACHE_TTL_SECONDS + 1 с — дольше любой + положительной записи, созданной до отзыва. + +Инвалидация (logout): сначала UPDATE sessions SET revoked_at в PostgreSQL (COMMIT), затем +SET sess: "revoked" поверх положительной записи. Заполнение кэша после промаха делается +SET NX, поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone. + +Отказ Valkey: любая ошибка/таймаут (по умолчанию 250 мс) → запрос обслуживается из PostgreSQL, +кэш обходится CACHE_RETRY_SECONDS секунд (простой circuit breaker). Если не удалось записать +tombstone, процесс SESSION_CACHE_TTL_SECONDS+1 секунд не доверяет положительным записям кэша: +устаревшая запись могла остаться в Valkey, но за это время она гарантированно истечёт. +""" +import json +import logging +import threading +import time + +import redis + +log = logging.getLogger("messenger.cache") + +PREFIX = "sess:" +REVOKED = object() # результат get(): сессия отозвана (tombstone) +MISS = None # результат get(): нет данных/кэш недоступен → идти в PostgreSQL +_TOMBSTONE = b"revoked" + + +class SessionCache: + def __init__(self, url, ttl_seconds=30, timeout_ms=250, retry_seconds=5.0, pool_size=10): + self.enabled = bool(url) + self.ttl = ttl_seconds + self.retry_seconds = retry_seconds + self._lock = threading.Lock() + self._skip_until = 0.0 # circuit breaker: до этого момента кэш не опрашиваем + self._distrust_until = 0.0 # до этого момента положительные записи игнорируем + self.client = None + if self.enabled: + timeout = timeout_ms / 1000.0 + # Ограниченный пул: не более pool_size соединений, ожидание свободного — timeout. + pool = redis.BlockingConnectionPool.from_url( + url, max_connections=pool_size, timeout=timeout, + socket_timeout=timeout, socket_connect_timeout=timeout) + self.client = redis.Redis(connection_pool=pool) + + # --- служебное --- + def _available(self): + return self.enabled and time.monotonic() >= self._skip_until + + def _failed(self, op, invalidation=False): + now = time.monotonic() + with self._lock: + self._skip_until = now + self.retry_seconds + if invalidation: + self._distrust_until = max(self._distrust_until, now + self.ttl + 1) + log.warning("cache unavailable op=%s; bypassing cache for %.0fs%s", op, self.retry_seconds, + "; positive entries distrusted for %ds" % (self.ttl + 1) if invalidation else "") + + @staticmethod + def _key(token_hash): + return PREFIX + token_hash.hex() + + # --- API --- + def get(self, token_hash): + """Пользователь из кэша, REVOKED или MISS.""" + if not self._available(): + return MISS + try: + raw = self.client.get(self._key(token_hash)) + except redis.RedisError: + self._failed("get") + return MISS + if raw is None: + return MISS + if raw == _TOMBSTONE: + return REVOKED + if time.monotonic() < self._distrust_until: + return MISS + try: + data = json.loads(raw) + if data["exp"] <= time.time(): + return MISS + return data["user"] + except (ValueError, KeyError, TypeError): + return MISS + + def put(self, token_hash, user, expires_epoch, read_started): + """Заполнить кэш после чтения действующей сессии из PostgreSQL.""" + if not self._available(): + return + # Если между чтением БД и записью в кэш прошло подозрительно много времени, + # данные могли устареть (например, logout + истечение tombstone) — не кэшируем. + if time.monotonic() - read_started > 1.0: + return + ttl_ms = int(min(self.ttl, expires_epoch - time.time()) * 1000) + if ttl_ms <= 0: + return + value = json.dumps({"user": user, "exp": expires_epoch}, separators=(",", ":")) + try: + self.client.set(self._key(token_hash), value, px=ttl_ms, nx=True) + except redis.RedisError: + self._failed("set") + + def revoke(self, token_hash): + """Tombstone после COMMIT отзыва в PostgreSQL. Пробуем даже при открытом breaker.""" + if not self.enabled: + return + try: + self.client.set(self._key(token_hash), _TOMBSTONE, ex=self.ttl + 1) + except redis.RedisError: + self._failed("revoke", invalidation=True) diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..366d6204 --- /dev/null +++ b/src/store.py @@ -0,0 +1,271 @@ +"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии. + +Источник истины — база данных. В памяти процесса состояния нет, поэтому +перезапуск API (и самой БД с сохранённым volume) не теряет данные. +""" +import datetime as dt +import logging +import time +import uuid +from pathlib import Path + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +log = logging.getLogger("messenger.store") + +EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc) +MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций + + +class Conflict(Exception): + pass + + +class UnknownMember(Exception): + pass + + +def format_ts(value): + """datetime -> RFC 3339 UTC с микросекундами и суффиксом Z.""" + return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + +def to_micros(value): + delta = value - EPOCH + return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds + + +def from_micros(micros): + return EPOCH + dt.timedelta(microseconds=micros) + + +def _user(row): + # Пароль/hash и сессионные данные никогда не входят в User. + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": format_ts(row["created_at"]), + } + + +def _chat(row): + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": [str(m) for m in row["member_ids"]], + "created_at": format_ts(row["created_at"]), + } + + +def _message(row): + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": format_ts(row["created_at"]), + } + + +CHAT_COLUMNS = """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) AS member_ids""" + + +class Store: + def __init__(self, conninfo, pool_size=10, statement_timeout_ms=5000): + # Ограниченный пул: не более pool_size соединений; ожидание свободного — до 5 с, + # затем PoolTimeout → 503. statement_timeout обрывает зависший SQL. + # check: перед выдачей соединение проверяется. После перезапуска PostgreSQL + # «мёртвые» соединения отбрасываются, и запрос не получает ложный 503. + self.pool = ConnectionPool( + conninfo, min_size=1, max_size=pool_size, timeout=5, + kwargs={"row_factory": dict_row, + "options": "-c statement_timeout=%d" % statement_timeout_ms}, + open=False, + check=ConnectionPool.check_connection) + + # --- запуск --- + def open(self, wait_seconds=60): + """Ждём готовности БД (она может стартовать дольше API) и открываем пул.""" + self.pool.open() + deadline = time.monotonic() + wait_seconds + while True: + try: + with self.pool.connection() as conn: + conn.execute("SELECT 1") + return + except Exception as exc: + if time.monotonic() > deadline: + raise + log.info("database is not ready yet (%s), retrying", type(exc).__name__) + time.sleep(1) + + def close(self): + self.pool.close() + + def migrate(self, directory): + """Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз.""" + files = sorted(Path(directory).glob("*.sql")) + with self.pool.connection() as conn: + # Advisory-блокировка (сессионная): несколько процессов не применят миграции одновременно. + conn.autocommit = True + conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,)) + try: + conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""") + done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")} + for path in files: + if path.name in done: + continue + # Каждая миграция и её отметка — одна транзакция: либо целиком, либо никак. + with conn.transaction(): + conn.execute(path.read_text(encoding="utf-8")) + conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,)) + log.info("migration applied: %s", path.name) + log.info("schema version: %s", files[-1].name if files else "none") + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,)) + conn.autocommit = False + + def ping(self): + with self.pool.connection() as conn: + conn.execute("SELECT 1") + + # --- пользователи --- + def create_user(self, username, display_name, password_hash): + try: + with self.pool.connection() as conn: + row = conn.execute( + """INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, clock_timestamp()) + RETURNING id, username, display_name, created_at""", + (uuid.uuid4(), username, display_name, password_hash)).fetchone() + except psycopg.errors.UniqueViolation: + # Уникальность гарантирует сама БД — гонка двух регистраций безопасна. + raise Conflict() + return _user(row) + + def get_credentials(self, username): + with self.pool.connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,)).fetchone() + if row is None: + return None, None + return _user(row), row["password_hash"] + + # --- сессии --- + def create_session(self, user_id, token_hash, ttl_seconds): + with self.pool.connection() as conn: + row = conn.execute( + """INSERT INTO sessions (token_hash, user_id, created_at, expires_at) + VALUES (%s, %s, now(), now() + make_interval(secs => %s)) + RETURNING expires_at""", + (token_hash, user_id, ttl_seconds)).fetchone() + return row["expires_at"] + + def get_session_user(self, token_hash): + """(пользователь, expires_at) действующей сессии или None (неизвестна/истекла/отозвана).""" + with self.pool.connection() as conn: + row = conn.execute( + """SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at + FROM sessions s JOIN users u ON u.id = s.user_id + WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""", + (token_hash,)).fetchone() + return (_user(row), row["expires_at"]) if row else None + + def revoke_session(self, token_hash): + with self.pool.connection() as conn: + conn.execute( + "UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL", + (token_hash,)) + + # --- чаты --- + def create_chat(self, title, member_ids): + """Чат и его участники создаются в одной транзакции (атомарно).""" + chat_id = uuid.uuid4() + # Блок `with pool.connection()` = одна транзакция: COMMIT при выходе без исключения, + # ROLLBACK при любом исключении. Чат без участников (или наоборот) не появится. + try: + with self.pool.connection() as conn: + found = conn.execute( + "SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"] + if found != len(member_ids): + raise UnknownMember() + conn.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())", + (chat_id, title)) + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat_id, m, i) for i, m in enumerate(member_ids)]) + row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone() + except psycopg.errors.ForeignKeyViolation: + # Внешний ключ — последняя линия защиты: транзакция откатывается целиком. + raise UnknownMember() + return _chat(row) + + def get_chat_for(self, user_id, chat_id): + """Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы).""" + with self.pool.connection() as conn: + row = conn.execute( + "SELECT " + CHAT_COLUMNS + """ FROM chats c + WHERE c.id = %s AND EXISTS ( + SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)""", + (chat_id, user_id)).fetchone() + return _chat(row) if row else None + + def list_chats(self, user_id, after, limit): + params = [user_id] + where = "" + if after: + where = "AND (c.created_at, c.id) > (%s, %s::uuid)" + params += [from_micros(after[0]), after[1]] + params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница + with self.pool.connection() as conn: + rows = conn.execute( + "SELECT " + CHAT_COLUMNS + """ FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall() + return self._page(rows, limit, _chat) + + # --- сообщения --- + def add_message(self, user_id, chat_id, text): + with self.pool.connection() as conn: + # FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому + # created_at растёт в порядке фиксации и keyset-курсор не пропускает записи. + allowed = conn.execute( + """SELECT 1 FROM chats c WHERE c.id = %s AND EXISTS ( + SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s) + FOR UPDATE OF c""", (chat_id, user_id)).fetchone() + if allowed is None: + return None + row = conn.execute( + """INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES (%s, %s, %s, %s, clock_timestamp()) + RETURNING id, chat_id, sender_id, text, created_at""", + (uuid.uuid4(), chat_id, user_id, text)).fetchone() + return _message(row) + + def list_messages(self, chat_id, after, limit): + params = [chat_id] + where = "" + if after: + where = "AND (created_at, id) > (%s, %s::uuid)" + params += [from_micros(after[0]), after[1]] + params.append(limit + 1) + with self.pool.connection() as conn: + rows = conn.execute( + "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s " + + where + " ORDER BY created_at, id LIMIT %s", params).fetchall() + return self._page(rows, limit, _message) + + @staticmethod + def _page(rows, limit, convert): + has_more = len(rows) > limit + rows = rows[:limit] + last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None + return [convert(r) for r in rows], last diff --git a/student-tests/cache_bench.py b/student-tests/cache_bench.py new file mode 100644 index 00000000..ba6161ec --- /dev/null +++ b/student-tests/cache_bench.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +"""Польза кэша сессий: нагрузка на PostgreSQL и задержка проверки токена. + + python3 student-tests/cache_bench.py --label valkey [--requests 1000] + +Делает N последовательных GET /api/v1/users/me одним токеном и считает: + * прирост xact_commit в pg_stat_database (сколько транзакций выполнила БД); + * p50/p95 задержки. +Сравнение: запустить при SESSION_CACHE=valkey и при SESSION_CACHE=off (см. REPORT.md). +Фоновый шум: healthcheck API (~1 SELECT 1 раз в 5 с). +""" +import argparse +import base64 +import json +import statistics +import subprocess +import time +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +p = argparse.ArgumentParser() +p.add_argument("--base-url", default="http://localhost:8080") +p.add_argument("--label", required=True) +p.add_argument("--requests", type=int, default=1000) +args = p.parse_args() +BASE = args.base_url.rstrip("/") + + +def api(method, path, body=None, headers=None): + h = dict(headers or {}) + data = json.dumps(body).encode() if body is not None else None + if data: + h["Content-Type"] = "application/json" + with urllib.request.urlopen(urllib.request.Request(BASE + path, data=data, headers=h, method=method), + timeout=30) as r: + return json.loads(r.read() or b"null") + + +def commits(): + time.sleep(1.5) # статистика PostgreSQL публикуется с задержкой до ~1 с + out = subprocess.run( + ["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres", "psql", + "-U", "messenger", "-d", "messenger", "-X", "-A", "-t", "-c", + "SELECT xact_commit FROM pg_stat_database WHERE datname = 'messenger'"], + cwd=ROOT, check=True, capture_output=True, text=True) + return int(out.stdout.strip()) + + +name, pw = "cb_" + uuid.uuid4().hex[:10], "T3st-" + uuid.uuid4().hex +api("POST", "/api/v1/users", {"username": name, "display_name": "Cache bench", "password": pw}) +token = api("POST", "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + base64.b64encode((name + ":" + pw).encode()).decode()})["token"] +auth = {"Authorization": "Bearer " + token} +for _ in range(20): # прогрев соединений + api("GET", "/api/v1/users/me", headers=auth) + +before = commits() +lat = [] +for _ in range(args.requests): + t0 = time.perf_counter() + api("GET", "/api/v1/users/me", headers=auth) + lat.append((time.perf_counter() - t0) * 1000) +after = commits() +lat.sort() +print(json.dumps({ + "label": args.label, "requests": args.requests, + "postgres_xact_commit_delta": after - before, + "p50_ms": round(statistics.median(lat), 2), + "p95_ms": round(lat[int(len(lat) * 0.95) - 1], 2), +}, ensure_ascii=False)) diff --git a/student-tests/history_bench.py b/student-tests/history_bench.py new file mode 100644 index 00000000..e6d69d49 --- /dev/null +++ b/student-tests/history_bench.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на большом объёме + замер пагинации через API. + + python3 student-tests/history_bench.py [--big 100000] [--small-chats 20] [--small-size 500] + +1. Через API создаёт двух синтетических пользователей, большой чат и N маленьких чатов. +2. Через psql (docker compose exec postgres) заливает сообщения: generate_series, одна транзакция. + Неравномерно: один чат на --big сообщений, остальные по --small-size. +3. Печатает EXPLAIN (ANALYZE, BUFFERS) ровно того SQL, который выполняет приложение: + первая страница, «глубокая» страница по keyset-курсору, та же глубина через OFFSET; + затем те же запросы БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK). +4. Проходит всю историю большого чата через API (limit=100) и сравнивает задержку первых и + последних страниц: при keyset-пагинации она не растёт с номером страницы. + +Каждый запуск добавляет синтетические данные в учебную БД (API курса не удаляет сообщения). +""" +import argparse +import base64 +import json +import statistics +import subprocess +import time +import urllib.parse +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +parser = argparse.ArgumentParser() +parser.add_argument("--base-url", default="http://localhost:8080") +parser.add_argument("--big", type=int, default=100_000) +parser.add_argument("--small-chats", type=int, default=20) +parser.add_argument("--small-size", type=int, default=500) +args = parser.parse_args() +BASE = args.base_url.rstrip("/") + + +def api(method, path, body=None, headers=None): + h = dict(headers or {}) + data = None + if body is not None: + data = json.dumps(body).encode() + h["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, data=data, headers=h, method=method) + with urllib.request.urlopen(req, timeout=30) as r: + raw = r.read() + return json.loads(raw) if raw else None + + +def psql(sql, tuples_only=False): + cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-v", "ON_ERROR_STOP=1"] + if tuples_only: + cmd += ["-A", "-t"] + out = subprocess.run(cmd, input=sql, cwd=ROOT, check=True, capture_output=True, text=True) + return out.stdout.strip() + + +def user(label): + name = "bench_%s_%s" % (label, uuid.uuid4().hex[:8]) + pw = "T3st-" + uuid.uuid4().hex + u = api("POST", "/api/v1/users", {"username": name, "display_name": "Bench " + label, "password": pw}) + cred = base64.b64encode((name + ":" + pw).encode()).decode() + s = api("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}) + return u, {"Authorization": "Bearer " + s["token"]} + + +def section(title): + print("\n" + "=" * 100 + "\n" + title + "\n" + "=" * 100) + + +# ---------- 1. данные ---------- +a, ha = user("a") +b, _ = user("b") +big = api("POST", "/api/v1/chats", {"title": "Большой чат", "member_ids": [a["id"], b["id"]]}, ha) +small = [api("POST", "/api/v1/chats", {"title": "Малый %d" % i, "member_ids": [a["id"], b["id"]]}, ha) + for i in range(args.small_chats)] + +section("1. Заливка данных") +started = time.monotonic() +values = ",".join("('%s'::uuid)" % c["id"] for c in small) # UUID получены от нашего API +psql(""" +BEGIN; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), '{big}'::uuid, + CASE WHEN n % 2 = 0 THEN '{a}'::uuid ELSE '{b}'::uuid END, + 'synthetic message #' || n || ' ' || repeat('x', (n * 7919) % 200), + timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond' +FROM generate_series(1, {big_n}) AS n; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), c.id, '{a}'::uuid, 'small chat message #' || n, + timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond' +FROM (VALUES {values}) AS c(id), generate_series(1, {small_n}) AS n; +COMMIT; +ANALYZE messages; +""".format(big=big["id"], a=a["id"], b=b["id"], big_n=args.big, small_n=args.small_size, values=values)) +print("залито за %.1f с" % (time.monotonic() - started)) +print(psql("""SELECT count(*) AS messages_total, + count(DISTINCT chat_id) AS chats_with_messages, + (SELECT count(*) FROM messages WHERE chat_id = '{big}') AS in_big_chat, + pg_size_pretty(pg_relation_size('messages')) AS table_size, + pg_size_pretty(pg_relation_size('messages_chat_order_idx')) AS index_size + FROM messages""".format(big=big["id"]))) + +# ---------- 2. EXPLAIN ---------- +deep_offset = int(args.big * 0.9) +cur_ts, cur_id = psql("""SELECT created_at, id FROM messages WHERE chat_id = '{big}' + ORDER BY created_at, id OFFSET {off} LIMIT 1""".format( + big=big["id"], off=deep_offset - 1), tuples_only=True).split("|") + +COLS = "SELECT id, chat_id, sender_id, text, created_at FROM messages" +Q_FIRST = COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id LIMIT 51".format(c=big["id"]) +Q_KEYSET = (COLS + " WHERE chat_id = '{c}' AND (created_at, id) > ('{t}', '{i}'::uuid)" + " ORDER BY created_at, id LIMIT 51").format(c=big["id"], t=cur_ts, i=cur_id) +Q_OFFSET = (COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id OFFSET {o} LIMIT 51").format( + c=big["id"], o=deep_offset) +EXPLAIN = "EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) " + +for title, q in [ + ("2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51)", Q_FIRST), + ("2b. С индексом: страница после %d-го сообщения, keyset-курсор (как в приложении)" % deep_offset, Q_KEYSET), + ("2c. Для сравнения: та же глубина через OFFSET %d (так приложение НЕ делает)" % deep_offset, Q_OFFSET)]: + section(title) + print(q) + print(psql(EXPLAIN + q)) + +section("2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются)") +print(psql("BEGIN;\nDROP INDEX messages_chat_order_idx;\n" + "\\echo '--- первая страница без индекса'\n" + EXPLAIN + Q_FIRST + ";\n" + "\\echo '--- keyset-страница без индекса'\n" + EXPLAIN + Q_KEYSET + ";\nROLLBACK;")) +print(psql("SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1")) + +# ---------- 3. пагинация через API ---------- +section("3. Полный обход истории большого чата через API (limit=100)") +path = "/api/v1/chats/%s/messages?limit=100" % big["id"] +latencies, total, cursor = [], 0, None +while True: + url = path + ("&cursor=" + urllib.parse.quote(cursor, safe="") if cursor else "") + t0 = time.perf_counter() + page = api("GET", url, headers=ha) + latencies.append((time.perf_counter() - t0) * 1000) + total += len(page["items"]) + cursor = page["next_cursor"] + if not cursor: + break +first, last = latencies[1:21], latencies[-20:] # первая страница — прогрев +print(json.dumps({ + "pages": len(latencies), "messages_read": total, "expected": args.big, + "first_20_pages_median_ms": round(statistics.median(first), 2), + "last_20_pages_median_ms": round(statistics.median(last), 2), + "all_pages_p50_ms": round(statistics.median(latencies), 2), + "all_pages_p95_ms": round(sorted(latencies)[int(len(latencies) * 0.95) - 1], 2), + "all_pages_max_ms": round(max(latencies), 2), +}, ensure_ascii=False, indent=1)) +assert total == args.big, "пагинация потеряла или задублировала сообщения" +print("PASS: все %d сообщений прочитаны без потерь и повторов" % total) diff --git a/student-tests/test_lab2.py b/student-tests/test_lab2.py new file mode 100644 index 00000000..b8ce72da --- /dev/null +++ b/student-tests/test_lab2.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 +"""Собственные проверки lab2 (только stdlib): аутентификация, границы, транзакции, сохранность. + + python3 student-tests/test_lab2.py # граничные проверки, гонка, атомарность + python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 # + истечение (SESSION_TTL_SECONDS=2) + python3 student-tests/test_lab2.py --db-outage # + остановка PostgreSQL -> 503, восстановление + python3 student-tests/test_lab2.py --persistence # + перезапуск API и БД через scripts/restart.sh + +Токены и пароли не печатаются. Флаги --db-outage/--persistence управляют docker compose. +""" +import argparse +import base64 +import json +import subprocess +import sys +import threading +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +parser = argparse.ArgumentParser() +parser.add_argument("--base-url", default="http://localhost:8080") +parser.add_argument("--persistence", action="store_true") +parser.add_argument("--expiry-url", default=None, help="экземпляр API с SESSION_TTL_SECONDS=2") +parser.add_argument("--db-outage", action="store_true") +parser.add_argument("--cache", action="store_true", + help="проверки Valkey: отказ, FLUSHALL, зависание при logout (docker compose)") +args = parser.parse_args() +BASE = args.base_url.rstrip("/") +ROOT = Path(__file__).resolve().parents[1] +fails = 0 + + +def call(method, path, body=None, token=None, headers=None, raw=None, base=None): + h = dict(headers or {}) + if token: + h["Authorization"] = "Bearer " + token + data = raw if raw is not None else (json.dumps(body, ensure_ascii=False).encode() if body is not None else None) + if data is not None: + h.setdefault("Content-Type", "application/json") + req = urllib.request.Request((base or BASE) + path, data=data, headers=h, method=method) + try: + resp = urllib.request.urlopen(req, timeout=30) + except urllib.error.HTTPError as err: + resp = err + with resp: + text = resp.read() + assert resp.headers.get("X-Request-Id"), "нет X-Request-Id" + return resp.code, (json.loads(text) if text else None), resp.headers + + +def expect(name, got, want): + global fails + ok = got == want + fails += not ok + short = lambda v: (str(v)[:40] + "…") if len(str(v)) > 40 else str(v) + print("%-4s %-46s -> %s (ожидалось %s)" % ("OK" if ok else "FAIL", name, short(got), short(want))) + + +def basic(username, password): + return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()} + + +def register(prefix, password): + username = prefix + uuid.uuid4().hex[:8] + code, user, _ = call("POST", "/api/v1/users", {"username": username, "display_name": "Тест", "password": password}) + assert code == 201, code + return user + + +def login(username, password): + code, session, _ = call("POST", "/api/v1/auth/sessions", headers=basic(username, password)) + assert code == 201, code + return session["token"] + + +PW_A, PW_B = "Пароль:с:двоеточием-Ω1", "T3st-" + uuid.uuid4().hex +a, b, e = register("a_", PW_A), register("b_", PW_B), register("e_", PW_B) +ta, tb, te = login(a["username"], PW_A), login(b["username"], PW_B), login(e["username"], PW_B) + +# --- регистрация --- +users = "/api/v1/users" +expect("регистрация без password", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x"})[0], 400) +expect("password 11 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 11})[0], 400) +expect("password 129 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 129})[0], 400) +expect("password не строка", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": 123456789012})[0], 400) +expect("дубликат username", call("POST", users, {"username": a["username"], "display_name": "x", "password": PW_B})[0], 409) +expect("User не содержит пароль/хеш", sorted(a), ["created_at", "display_name", "id", "username"]) +expect("malformed JSON", call("POST", users, raw=b"{bad")[0], 400) + +# --- вход --- +sess = "/api/v1/auth/sessions" +code, _, hdr = call("POST", sess, headers=basic(a["username"], "wrong-password-123")) +expect("неверный пароль", code, 401) +expect(" challenge Basic", hdr.get("WWW-Authenticate", "").startswith("Basic"), True) +expect("неизвестный пользователь", call("POST", sess, headers=basic("no_such_user_x", PW_B))[0], 401) +expect("вход без Authorization", call("POST", sess)[0], 401) +expect("вход с Bearer вместо Basic", call("POST", sess, token=ta)[0], 401) +expect("мусор вместо base64", call("POST", sess, headers={"Authorization": "Basic !!!"})[0], 401) +expect("пароль с двоеточием и Unicode", call("GET", "/api/v1/users/me", token=ta)[1]["id"], a["id"]) +t1, t2 = login(b["username"], PW_B), login(b["username"], PW_B) +expect("два входа дают разные токены", t1 != t2 and len(t1) >= 43, True) + +# --- Bearer --- +me = "/api/v1/users/me" +code, _, hdr = call("GET", me) +expect("без токена", code, 401) +expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True) +expect("случайный токен", call("GET", me, token="x" * 43)[0], 401) +expect("Basic на бизнес-endpoint", call("GET", me, headers=basic(a["username"], PW_A))[0], 401) +expect("только X-User-Id", call("GET", me, headers={"X-User-Id": a["id"]})[0], 401) +expect("X-User-Id не меняет владельца", call("GET", me, token=ta, headers={"X-User-Id": e["id"]})[1]["id"], a["id"]) + +# --- logout --- +expect("logout", call("DELETE", sess + "/current", token=t1)[0], 204) +expect("отозванный токен", call("GET", me, token=t1)[0], 401) +expect("повторный logout", call("DELETE", sess + "/current", token=t1)[0], 401) +expect("другая сессия того же пользователя жива", call("GET", me, token=t2)[0], 200) + +# --- чаты и сообщения --- +chats = "/api/v1/chats" +expect("чат: создатель не участник", call("POST", chats, {"title": "t", "member_ids": [b["id"]]}, ta)[0], 400) +expect("чат: неизвестный участник", call("POST", chats, {"title": "t", "member_ids": [a["id"], str(uuid.uuid4())]}, ta)[0], 400) +expect("чат: дубликат участника", call("POST", chats, {"title": "t", "member_ids": [a["id"], a["id"]]}, ta)[0], 400) +chat = call("POST", chats, {"title": "Проверка", "member_ids": [a["id"], b["id"]]}, ta)[1] +chat2 = call("POST", chats, {"title": "t2", "member_ids": [a["id"]]}, ta)[1] +expect("порядок member_ids сохранён", chat["member_ids"], [a["id"], b["id"]]) +msgs = "/api/v1/chats/%s/messages" % chat["id"] +expect("чужой чат (Ева)", call("GET", chats + "/" + chat["id"], token=te)[0], 404) +expect("запись в чужой чат (Ева)", call("POST", msgs, {"text": "x"}, te)[0], 404) +expect("пустое сообщение", call("POST", msgs, {"text": " "}, ta)[0], 400) +expect("sender_id в теле", call("POST", msgs, {"text": "x", "sender_id": b["id"]}, ta)[0], 400) +expect("4001 символ", call("POST", msgs, {"text": "я" * 4001}, ta)[0], 400) + +errors = [] + + +def send(i): + try: + code, _, _ = call("POST", msgs, {"text": "m%d 👋" % i}, ta if i % 2 else tb) + if code != 201: + errors.append(code) + except Exception as exc: + errors.append(type(exc).__name__) + + +threads = [threading.Thread(target=send, args=(i,)) for i in range(100)] +[t.start() for t in threads] +[t.join() for t in threads] + + +def read_all(token, limit=7): + seen, cursor = [], None + while True: + _, page, _ = call("GET", msgs + "?limit=%d" % limit + ("&cursor=" + cursor if cursor else ""), token=token) + seen += page["items"] + cursor = page["next_cursor"] + if not cursor: + return seen + + +history = read_all(tb) +expect("100 параллельных POST: ошибок", len(errors), 0) +expect("100 параллельных POST: уникальных", len({m["id"] for m in history}), 100) +expect("история отсортирована (created_at, id)", + history == sorted(history, key=lambda m: (m["created_at"], uuid.UUID(m["id"]).int)), True) +first = call("GET", msgs + "?limit=1", token=ta)[1] +expect("cursor от другого чата", call("GET", "/api/v1/chats/%s/messages?cursor=%s" % (chat2["id"], first["next_cursor"]), token=ta)[0], 400) +expect("мусорный cursor", call("GET", msgs + "?cursor=abc", token=ta)[0], 400) +expect("limit=0", call("GET", msgs + "?limit=0", token=ta)[0], 400) +expect("неверный UUID в пути", call("GET", chats + "/xyz", token=ta)[0], 400) + +# --- гонка регистрации одного username --- +race_name = "race_" + uuid.uuid4().hex[:10] +race_codes = [] + + +def register_same(): + try: + race_codes.append(call("POST", "/api/v1/users", + {"username": race_name, "display_name": "Гонка", "password": PW_B})[0]) + except Exception as exc: + race_codes.append(type(exc).__name__) + + +threads = [threading.Thread(target=register_same) for _ in range(20)] +[t.start() for t in threads] +[t.join() for t in threads] +expect("гонка 20 регистраций: ровно один 201", sorted(race_codes).count(201), 1) +expect("гонка 20 регистраций: остальные 409", sorted(race_codes).count(409), 19) + +# --- атомарность создания чата: ошибка не оставляет «полу-чата» --- +def chat_ids(token): + _, page, _ = call("GET", chats + "?limit=100", token=token) + return [c["id"] for c in page["items"]] + + +fresh_pw = "T3st-" + uuid.uuid4().hex +fresh = register("f_", fresh_pw) +tf = login(fresh["username"], fresh_pw) +before = chat_ids(tf) +before_b = chat_ids(tb) +code = call("POST", chats, {"title": "откат", "member_ids": [fresh["id"], b["id"], str(uuid.uuid4())]}, tf)[0] +expect("чат с неизвестным 3-м участником", code, 400) +expect("после ошибки чат не появился у создателя", chat_ids(tf), before) +expect("после ошибки чат не появился у участника b", chat_ids(tb), before_b) +code, ok_chat, _ = call("POST", chats, {"title": "после отката", "member_ids": [fresh["id"]]}, tf) +expect("следующее создание чата работает", (code, chat_ids(tf)), (201, before + [ok_chat["id"]])) + +# --- истечение сессии (отдельный экземпляр API с SESSION_TTL_SECONDS=2) --- +if args.expiry_url: + eb = args.expiry_url.rstrip("/") + code, s, _ = call("POST", sess, headers=basic(a["username"], PW_A), base=eb) + expect("TTL=2: вход", code, 201) + expect("TTL=2: сразу после входа токен работает", call("GET", me, token=s["token"], base=eb)[0], 200) + time.sleep(3) + code, _, hdr = call("GET", me, token=s["token"], base=eb) + expect("TTL=2: через 3 с токен истёк", code, 401) + expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True) + expect("TTL=2: истёкший токен не работает и на основном API", call("GET", me, token=s["token"])[0], 401) + +# --- недоступность PostgreSQL --- +if args.db_outage: + print("--- остановка PostgreSQL: docker compose stop postgres") + compose = ["docker", "compose", "--env-file", str(ROOT / ".env")] + subprocess.run(compose + ["stop", "postgres"], cwd=ROOT, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + try: + code, body, _ = call("GET", "/health/ready") + expect("БД нет: /health/ready", (code, body["error"]["code"]), (503, "unavailable")) + expect("БД нет: /health/live", call("GET", "/health/live")[0], 200) + started = time.monotonic() + code, body, _ = call("GET", chats, token=ta) + expect("БД нет: список чатов с токеном -> 503, не 200", (code, body["error"]["code"]), (503, "unavailable")) + expect("БД нет: ответ ограничен по времени (<10 с)", time.monotonic() - started < 10, True) + # /users/me может быть отдан из кэша сессий (копия действующей сессии, отзыв без БД невозможен) + expect("БД нет: /users/me -> 200 из кэша или 503", call("GET", me, token=ta)[0] in (200, 503), True) + expect("БД нет: неизвестный токен не проходит", call("GET", me, token="y" * 43)[0] in (401, 503), True) + expect("БД нет: анонимный запрос не проходит", call("GET", me)[0] in (401, 503), True) + expect("БД нет: вход -> 503", call("POST", sess, headers=basic(a["username"], PW_A))[0], 503) + finally: + subprocess.run(compose + ["start", "postgres"], cwd=ROOT, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + deadline = time.monotonic() + 60 + while call("GET", "/health/ready")[0] != 200: + assert time.monotonic() < deadline, "БД не восстановилась" + time.sleep(1) + expect("БД вернулась: прежний токен работает", call("GET", me, token=ta)[1], a) + + +# --- Valkey: роль кэша, отказ, flush, зависание при logout --- +if args.cache: + compose = ["docker", "compose", "--env-file", str(ROOT / ".env")] + + def dc(*cmd): + subprocess.run(compose + list(cmd), cwd=ROOT, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + def vcli(*cmd): + """valkey-cli внутри контейнера; пароль читается там же из секрета и не печатается.""" + out = subprocess.run(compose + ["exec", "-T", "valkey", "sh", "-c", + 'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" ' + '/run/secrets/valkey.conf)" "$@"', "_"] + list(cmd), + cwd=ROOT, check=True, capture_output=True, text=True) + return out.stdout.strip() + + def stats(): + info = dict(l.split(":", 1) for l in vcli("INFO", "stats").splitlines() if ":" in l) + return int(info["keyspace_hits"]), int(info["keyspace_misses"]) + + import hashlib + + def cache_value(token): + return vcli("GET", "sess:" + hashlib.sha256(token.encode()).hexdigest()) + + pw = "T3st-" + uuid.uuid4().hex + cu = register("c_", pw) + tc = login(cu["username"], pw) + expect("кэш: после входа в Valkey лежит копия сессии", cu["id"] in cache_value(tc), True) + expect("кэш: в Valkey нет самого токена/пароля", tc not in vcli("--scan", "--pattern", "*") and True, True) + h0, m0 = stats() + for _ in range(50): + call("GET", me, token=tc) + h1, m1 = stats() + expect("кэш: 50 запросов -> 50 попаданий в Valkey", (h1 - h0, m1 - m0), (50, 0)) + + # logout мгновенно виден через кэш + t2 = login(cu["username"], pw) + call("GET", me, token=t2) + expect("кэш: logout", call("DELETE", sess + "/current", token=t2)[0], 204) + expect("кэш: в Valkey tombstone вместо копии", cache_value(t2), "revoked") + expect("кэш: отозванный токен сразу 401", call("GET", me, token=t2)[0], 401) + + # FLUSHALL: кэш пуст, сессии читаются из PostgreSQL + vcli("FLUSHALL") + expect("FLUSHALL: действующий токен работает (из БД)", call("GET", me, token=tc)[1], cu) + expect("FLUSHALL: отозванный токен по-прежнему 401", call("GET", me, token=t2)[0], 401) + expect("FLUSHALL: кэш снова заполнен после промаха", cu["id"] in cache_value(tc), True) + + # Valkey остановлен: API работает через PostgreSQL + print("--- остановка Valkey: docker compose stop valkey") + dc("stop", "valkey") + try: + expect("Valkey нет: /health/ready 200 (не критичен)", call("GET", "/health/ready")[0], 200) + started = time.monotonic() + expect("Valkey нет: токен работает через БД", call("GET", me, token=tc)[1], cu) + expect("Valkey нет: ответ быстрый (<2 с)", time.monotonic() - started < 2, True) + expect("Valkey нет: список чатов", call("GET", chats, token=tc)[0], 200) + expect("Valkey нет: без токена 401", call("GET", me)[0], 401) + expect("Valkey нет: чужой токен 401", call("GET", me, token="z" * 43)[0], 401) + expect("Valkey нет: отозванный токен 401", call("GET", me, token=t2)[0], 401) + t3 = login(cu["username"], pw) + expect("Valkey нет: вход 201", bool(t3), True) + expect("Valkey нет: logout 204", call("DELETE", sess + "/current", token=t3)[0], 204) + expect("Valkey нет: после logout 401", call("GET", me, token=t3)[0], 401) + finally: + dc("start", "valkey") + deadline = time.monotonic() + 30 + while "PONG" not in vcli("PING"): + assert time.monotonic() < deadline, "Valkey не поднялся" + time.sleep(0.5) + time.sleep(6) # дольше CACHE_RETRY_SECONDS: приложение снова опрашивает кэш + expect("Valkey вернулся: токен работает", call("GET", me, token=tc)[1], cu) + expect("Valkey вернулся: кэш снова заполняется", cu["id"] in cache_value(tc), True) + expect("Valkey вернулся: токен, отозванный при отказе, 401", call("GET", me, token=t3)[0], 401) + + # Самый опасный случай: Valkey «завис» (pause) во время logout -> tombstone не записан, + # в Valkey осталась положительная копия сессии. Она не должна «воскресить» токен. + t4 = login(cu["username"], pw) + call("GET", me, token=t4) + print("--- зависание Valkey во время logout: docker compose pause valkey") + dc("pause", "valkey") + try: + expect("Valkey завис: logout всё равно 204 (отзыв в БД)", call("DELETE", sess + "/current", token=t4)[0], 204) + finally: + dc("unpause", "valkey") + expect("Valkey ожил: в нём осталась устаревшая копия", cu["id"] in cache_value(t4), True) + time.sleep(6) # breaker закрыт, кэш снова опрашивается + expect("Valkey ожил: устаревшая копия не принята, 401", call("GET", me, token=t4)[0], 401) + expect("Valkey ожил: действующий токен работает", call("GET", me, token=tc)[1], cu) + + +if args.persistence: + print("--- перезапуск API и PostgreSQL: scripts/restart.sh") + subprocess.run([str(ROOT / "scripts" / "restart.sh")], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + deadline = time.monotonic() + 90 + while True: + try: + if call("GET", "/health/ready")[0] == 200: + break + except Exception: + pass + assert time.monotonic() < deadline, "сервер не поднялся" + time.sleep(1) + expect("после рестарта: прежний токен работает", call("GET", me, token=ta)[1], a) + expect("после рестарта: чат на месте", call("GET", chats + "/" + chat["id"], token=tb)[1], chat) + expect("после рестарта: история та же", read_all(tb), history) + expect("после рестарта: отозванный токен всё ещё отозван", call("GET", me, token=t1)[0], 401) + expect("после рестарта: вход по паролю работает", call("POST", sess, headers=basic(a["username"], PW_A))[0], 201) + +print("ИТОГО:", "ВСЕ ПРОВЕРКИ ПРОШЛИ" if not fails else "%d ПРОВАЛОВ" % fails) +sys.exit(1 if fails else 0) -- 2.54.0