diff --git a/.dockerignore b/.dockerignore index bc16e55..82449c1 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,10 @@ __pycache__ node_modules evidence .DS_Store +tests +student-tests +contracts +scripts +infra +examples +*.md diff --git a/.env.example b/.env.example index 714c807..8c2a5f9 100644 --- a/.env.example +++ b/.env.example @@ -7,5 +7,15 @@ SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +# В этом решении сессии хранятся в Redis (см. auth.py, REPORT.md). +SESSION_STORE=redis CACHE_URL_FILE=/run/secrets/cache_url + + +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_WAIT_SECONDS=3 +DB_CONNECT_TIMEOUT_SECONDS=3 +DB_STATEMENT_TIMEOUT_MS=5000 +REDIS_POOL_MAX=20 +REDIS_TIMEOUT_MS=500 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..4a203a8 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.sh text eol=lf +*.sql text eol=lf +*.conf text eol=lf +*.example text eol=lf +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a7189..9795f36 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,7 @@ data/ backups/ # Runtime/build artifacts .venv/ +venv/ __pycache__/ *.py[cod] node_modules/ @@ -28,5 +29,3 @@ coverage/ .DS_Store .idea/ .vscode/ -# Keep small, sanitized evidence summaries in evidence/ under version control. -# Inspect git diff --cached: ignore rules are not a secret scanner. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..a3d5cb2 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,24 @@ +FROM python:3.11.13-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 + +WORKDIR /app + +COPY requirements.txt . + +RUN pip install --no-cache-dir --only-binary=:all: -r requirements.txt + +COPY main.py settings.py errors.py db.py auth.py ./ +COPY migrations/ ./migrations/ + +RUN useradd --create-home --shell /usr/sbin/nologin appuser + +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=5s --start-period=20s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=4)" + +CMD ["python", "main.py"] diff --git a/REPORT.md b/REPORT.md index e42f2b0..8fe929e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,159 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Бабиченко Максим, БВТ2303 +- Целевая оценка; 4 +- Commit/PR: <<ссылка на Merge Request>> +- Использованные источники, библиотеки и помощь ИИ: FastAPI, Uvicorn, Pydantic, psycopg 3 и psycopg-pool, argon2-cffi, redis-py (точные версии в requirements.txt); образы python:3.11.13-slim, postgres:17.11-alpine, redis:7.4.11-alpine; документация PostgreSQL (транзакции, индексы, EXPLAIN), документация Redis (persistence, AOF), RFC 7617 (Basic). Помощь ИИ: использовался как консультант по git и PowerShell, для разбора ошибок Docker (монтирование секретов, пароль PostgreSQL в старом volume) ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Проверял на Windows 11, все команды в PowerShell. Версии: Docker 28.1.1 (Docker Compose v2.35.1-desktop.1), Python <> (Python нужен только для тестов, приложение работает в контейнере). + +```powershell +git clone https://gitea.privcloud.tech/Kalibr/mtusi2026lab2.git +cd mtusi2026lab2 +git checkout solution/bvt2303-babichenko +Copy-Item .env.example .env +python scripts/init_secrets.py # случайные пароли в secrets/ (папка в .gitignore) +docker compose up -d --build --wait # api, postgres, redis; ждём статус healthy +docker compose ps + +python scripts/check_contract.py +python tests/smoke.py --base-url http://127.0.0.1:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080 +python student-tests/test_api.py +python student-tests/test_race.py +python student-tests/test_db.py +python student-tests/test_expiry.py +python student-tests/test_failures.py +python student-tests/redis_info.py +python student-tests/explain.py # пишет evidence/explain-history.txt +``` + +Это те же проверки, что в Makefile, только без make (на моём Windows его нет): `make check` = `python scripts/check_contract.py`, `make test` = `python tests/smoke.py ...`, `make test-persistence ACTION_SCRIPT=...` = `python tests/resilience.py --mode persistence ...`. Где make есть: `make check`, `make test BASE_URL=http://127.0.0.1:8080`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080`. Адрес 127.0.0.1 вместо localhost: на Windows localhost сначала пробует IPv6 и отвечает медленнее. + +На Linux/macOS вместо `scripts/restart.cmd` указывается `scripts/restart.sh`. Restart-скриптов два, потому что тест запускает hook напрямую, без shell, а Python на Windows не умеет запускать `.sh` (ошибка WinError 193). Команда в обоих одна: `docker compose restart`. + +Миграции применяет само приложение при старте, отдельной команды нет. Секреты создаются один раз скриптом `scripts/init_secrets.py`, значения на экран не выводятся. + +Остановка без потери данных: `docker compose down` (контейнеры удаляются, volumes `pgdata` и `redisdata` остаются, следующий `docker compose up -d --wait` поднимает те же данные). Намеренное удаление учебных данных: `docker compose down -v`, затем удалить папку `secrets` и снова запустить `python scripts/init_secrets.py`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +Клиент --HTTP--> api (FastAPI, порт 8080 только на 127.0.0.1) + |--> postgres пользователи, чаты, участники, сообщения (volume pgdata) + |--> redis сессии: session: -> id пользователя (AOF, volume redisdata) +``` + +PostgreSQL и Redis наружу не опубликованы, к ним ходит только API внутри сети Compose. + +| Роль | Сервис Compose | Версия | Health / готовность | Volume | Сеть / порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| API | `api` (собирается из Dockerfile) | python:3.11.13-slim | `/health/ready` (Docker HEALTHCHECK) | нет | `127.0.0.1:8080` на хосте | читает `/run/secrets/database_url` и `/run/secrets/cache_url` | +| База данных | `postgres` | postgres:17.11-alpine | `pg_isready` | `pgdata` | только сеть Compose, 5432 | `POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password` | +| Сессии | `redis` | redis:7.4.11-alpine | `redis-cli ping` с паролем | `redisdata` (AOF) | только сеть Compose, 6379 | `include /run/secrets/redis_auth` (requirepass) | + +Bootstrap: секреты — `python scripts/init_secrets.py` (повторный запуск ничего не меняет), схема — миграции при старте API (повторный старт ничего не применяет). Redis подготовки не требует. + +Что перенесено из lab1 и что изменилось: +- `main.py` остался главным файлом: модели Pydantic, формат ошибок, X-Request-Id, курсоры и маршруты из lab1. Вместо словарей `users`, `chats`, `messages` маршруты вызывают функции из `db.py`. +- Новые файлы: `db.py` (пул соединений, миграции, SQL-запросы), `auth.py` (Argon2id, разбор Basic/Bearer, сессии в Redis), `settings.py` (настройки из окружения и секретов), `errors.py` (ошибка API с кодом), `migrations/001_init.sql`, `compose.yaml`, `infra/redis.conf`, скрипты в `scripts/`. +- Вход: регистрация с `password`, `POST /api/v1/auth/sessions` только с Basic, дальше только `Authorization: Bearer`. `X-User-Id` больше ничего не значит. Токен проверяется в middleware до разбора тела, поэтому без токена всегда 401, а не 400 или 404. +- Свои тесты lab1 лежали в `tests/test_lab1.py`. По CONTRIBUTING публичную папку `tests/` переносить нельзя, поэтому свои тесты теперь в `student-tests/` и переведены на пароль и Bearer. +- Контейнер теперь запускается командой `python main.py`: хост и порт берутся из окружения, при SIGTERM uvicorn ждёт начатые запросы не дольше 5 с. + +Схема БД (`migrations/001_init.sql`): +- `users`: PK `id`, UNIQUE `username`, CHECK формата username и длины display_name, `password_hash`. +- `chats`; `chat_members` с PK (chat_id, user_id) и FK на `chats` и `users`; индекс по `user_id` для списка чатов. +- `messages`: FK (chat_id, sender_id) -> `chat_members`, то есть база сама не даст записать сообщение от того, кто не в чате. Индекс `(chat_id, created_at, id)` под историю. + +Транзакции: +- регистрация: один INSERT. Повтор username ловит уникальный индекс (ответ 409), без проверки «есть ли такой» в коде, которая пропустила бы две одновременные регистрации; +- создание чата: одна транзакция, сначала INSERT чата, потом всех участников. Если участника нет, FK падает, транзакция откатывается целиком, ответ 400; +- сообщение: один INSERT; если отправитель не в чате, срабатывает FK и ответ 404. + +Миграции: файлы `migrations/*.sql` применяются при старте API по порядку. Применённые записываются в `schema_migrations`, повторный старт ничего не применяет. Файл и запись о нём в одной транзакции. `pg_advisory_lock` не даёт двум API применять миграции одновременно. + +Сессии и роль Redis: +- источник истины для сессий — Redis, это единственное хранилище сессий (README допускает такой вариант при включённой persistence). Ключ `session:`, значение — id пользователя. Сам токен нигде не хранится; +- истечение: у ключа абсолютное время истечения (`SET ... PXAT`), равное `expires_at` из ответа. Redis удаляет ключ сам, рестарт срок не продлевает; +- сброс: logout удаляет ключ (`DEL`). `FLUSHALL` или удаление volume `redisdata` удалят все сессии, всем придётся войти заново; пользователи и сообщения в PostgreSQL при этом не пострадают; +- сохранность: раз Redis — единственное хранилище сессий, одного TTL мало, включён AOF с `appendfsync always`: Redis отвечает «OK» только после записи на диск. Поэтому после рестарта Redis действующие токены работают, и даже после аварийного `docker compose kill redis`; +- `maxmemory-policy noeviction`: при нехватке памяти Redis откажет во входе (503), но не удалит молча чужие сессии; +- Redis закрыт паролем (`requirepass` из секрета `secrets/redis_auth`). + +Пароли и токены: пароль хешируется Argon2id (m=12 МиБ, t=3, p=1, один из вариантов OWASP) с солью. Токен — 32 случайных байта (256 бит). Для ключа в Redis используется быстрый SHA-256: токен случайный, подбирать его бессмысленно. Неверный пароль и несуществующий пользователь дают одинаковый 401, и для несуществующего пароль тоже проверяется, чтобы время ответа было одинаковым. + +Пул и таймауты: PostgreSQL — пул psycopg от 1 до 10 соединений, ожидание соединения 3 с, подключение 3 с, `statement_timeout` 5 с, соединение проверяется перед выдачей. Redis — пул до 20 соединений, таймауты 500 мс, без повторов. Все SQL-запросы параметризованные (`%s`). + +Health: `/health/live` — процесс жив. `/health/ready` — отвечают и PostgreSQL, и Redis: без любого из них обычный запрос обслужить нельзя. Docker healthcheck API проверяет `/health/ready`. + +Durability: PostgreSQL с `fsync=on` и `synchronous_commit=on` (значения по умолчанию, в compose.yaml записаны явно). 201 отдаётся после COMMIT, а COMMIT — после записи WAL на диск. Данные в именованном volume `pgdata`. + +Соответствие `.env.example`: + +| Переменная | Что делает в этом решении | +| --- | --- | +| APP_HOST, APP_PORT, APP_ENV | где слушает API (0.0.0.0:8080), APP_ENV пишется в лог при старте | +| SESSION_TTL_SECONDS | срок жизни сессии, 3600 с; тест истечения временно запускает API с 2 с | +| DATABASE_URL_FILE | путь к секрету с адресом PostgreSQL (`/run/secrets/database_url`) | +| SESSION_STORE=redis | сессии хранятся в Redis (другие значения не поддерживаются) | +| CACHE_URL_FILE | путь к секрету с адресом Redis (`/run/secrets/cache_url`) | +| DB_*, REDIS_* | дополнительные: размеры пулов и таймауты | + +Секреты передаются файлами через `secrets:` в Compose (`/run/secrets/...`), а не значениями переменных, поэтому их нет в `docker inspect`. `.env` и `secrets/` в `.gitignore`. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | evidence/smoke.txt | +| Skeleton и контракт не изменены | `python scripts/check_contract.py` | PASS | evidence/check.txt | +| 3: минимум lab1 сохранён, переход на новую аутентификацию | smoke; `python student-tests/test_api.py` (тесты lab1 переведены на пароль и Bearer) | smoke PASS; 18 passed, 0 failed | evidence/smoke.txt, evidence/student-tests.txt | +| 3: данные и сессии переживают рестарт API и хранилищ без удаления volumes | `docker compose ps`; resilience.py с `scripts/restart.cmd`; `docker compose ps` | PASS; ID контейнеров те же, время Up у api, postgres и redis сбросилось | evidence/persistence.txt | +| 3: PostgreSQL: users, chats, members, messages; PK/FK; уникальный username | `migrations/001_init.sql`; `python student-tests/test_db.py` | UNIQUE (username); прямой INSERT сообщения от не-участника отклонён по FK | evidence/db.txt | +| 3: миграции с нуля | `docker compose up` на пустом volume, `docker compose logs api` | «Migrations applied: 001_init.sql» | evidence/stack.txt | +| 3: повторный запуск миграций без дублирования | test_db.py (рестарт api) | «Migrations applied: none», в schema_migrations одна запись | evidence/db.txt | +| 3: создание чата атомарно | test_db.py (test_create_chat_rolls_back) | 400; строки чата нет, хотя счётчик вставок в chats вырос: вставка была и откатилась | evidence/db.txt | +| 3: Basic только на POST /auth/sessions | test_api.py (test_bearer_required) | Basic на /users/me -> 401 с WWW-Authenticate: Bearer | evidence/student-tests.txt | +| 3: остальные endpoint требуют Bearer, X-User-Id не даёт доступ | test_api.py (test_bearer_required, test_x_user_id_ignored) | только X-User-Id -> 401; X-User-Id рядом с токеном не меняет пользователя | evidence/student-tests.txt | +| 3: срок жизни сессии и logout | `python student-tests/test_expiry.py`; test_api.py (test_logout) | после TTL 2 с -> 401 и ключа в Redis нет; после logout -> 401, вторая сессия работает | evidence/expiry.txt, evidence/student-tests.txt | +| 3: пароль хешируется password KDF | test_db.py (test_password_is_argon2id) | `$argon2id$v=19$m=12288,t=3,p=1$...` | evidence/db.txt | +| 3: secrets и volumes не попадают в Git | `git check-ignore -v .env secrets/database_url` | оба файла игнорируются | evidence/stack.txt | +| 4: Redis реально используется (источник истины, expiry, сброс описаны выше) | `docker compose exec redis ...`: число ключей session:*, TTL ключа, настройки AOF | ключи session:* есть, TTL около 3600 с, appendonly yes, appendfsync always | evidence/redis.txt | +| 4: параметризованные запросы | `db.py` | все значения через `%s`, SQL не склеивается со вводом | код | +| 4: ограниченный пул и таймауты | `db.py`, `auth.py`, `settings.py` | PostgreSQL: пул 1–10, 3 с / 3 с / 5 с; Redis: пул 20, 500 мс | код | +| 4: гонка регистрации одного username | `python student-tests/test_race.py` | 20 параллельных запросов: 201 x1, 409 x19 | evidence/race.txt | +| 4: rollback составной операции | test_db.py | см. строку «создание чата атомарно» | evidence/db.txt | +| 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений | `python student-tests/explain.py` (20 000 сообщений, большой чат 15 000) | Index Scan по messages_history, 51 строка, 4 буфера | evidence/explain-history.txt | +| 4: пагинация без полного scan истории | explain.py, запросы 2–4 | keyset после 10 000-го сообщения: 6 буферов; OFFSET 10000: 10 051 строка и 257 буферов; без индекса: Seq Scan по всей таблице и Sort, 255 буферов | evidence/explain-history.txt | +| 4: автопроверка expiry при коротком SESSION_TTL_SECONDS | test_expiry.py (API пересоздаётся с TTL=2) | до истечения 200, после 401 | evidence/expiry.txt | +| 4: автопроверка logout | test_api.py (test_logout) | 204, потом 401, повторный logout 401 | evidence/student-tests.txt | +| 4: автопроверка неверного пароля | test_api.py (test_wrong_password) | одинаковый 401 для неверного пароля и неизвестного пользователя | evidence/student-tests.txt | +| 4: недоступность Redis | `python student-tests/test_failures.py redis` | ready 503; с токеном 503; с чужим токеном 503, а не 200; без токена 401; регистрация 201 | evidence/failures.txt | +| 4: persistence Redis выдерживает проверяемый рестарт | resilience.py (restart всего стенда); test_failures.py redis (test_redis_crash: `docker compose kill redis`, затем start) | прежний токен работает и после обычного рестарта, и после аварийной остановки | evidence/persistence.txt, evidence/failures.txt | +| 4: недоступность БД, аноним не становится доверенным | `python student-tests/test_failures.py postgres` | ready 503; бизнес-запросы 503 без подробностей; без токена и с чужим токеном 401; после старта БД прежний токен работает | evidence/failures.txt | +| Выбранный трек 5 | | не выбран | | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Компьютер: <<процессор, память>>, Windows 11, Docker Desktop без отдельных лимитов. Дата прогона: 9 октября 2026. Нагрузочных экспериментов нет, трек 5 не выбран. Ниже проверки отказов уровня 4. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| restart hook: `docker compose restart` (api, postgres, redis), volumes на месте | данные и токен живы | тот же токен читает то же сообщение | около 3,6 с (real 00:03.587); потерь нет | +| `docker compose stop redis` | без проверки сессии никого не пускаем | ready 503, запросы с токеном 503, без токена 401, регистрация 201 | после `start redis` прежний токен работает сразу; сессии не потеряны (AOF) | +| `docker compose kill redis` (SIGKILL, без корректной остановки) | сессии не теряются | сессия, выданная до сбоя, работает после `start redis` | потерь нет: каждая запись в AOF на диске до ответа «OK» | +| `docker compose stop postgres` | ограниченная ошибка, анонимов не пускаем | ready 503, бизнес-запросы 503, без токена и с чужим токеном 401 | после `start postgres` токен и сообщения на месте; запросы во время отказа не сохранены (получили 503) | +| 20 одновременных регистраций одного username | один победитель | 201 x1, 409 x19 | дублей нет | +| 10 клиентов x 10 сообщений одновременно | ровно 100 сообщений | 100, все id уникальны | потерь нет | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Одна PostgreSQL и один Redis, без реплик и бэкапов. Упал любой из них — API отвечает 503. +- Если Redis недоступен, не работает никто из вошедших: сессии хранятся только там. Цена — простая схема: один источник истины для сессий. +- Если потерять volume `redisdata` или выполнить `FLUSHALL`, все пользователи разлогинятся (данные в PostgreSQL останутся). +- Время сообщения — время начала транзакции. При одновременных вставках сообщение, закоммиченное позже, может получить более раннее время, и клиент, уже пролиставший историю дальше, его не увидит. Это ограничение keyset-пагинации по времени. +- API подключается к PostgreSQL владельцем базы. Отдельная роль с минимальными правами — в lab7. +- Basic по HTTP передаёт пароль открыто (base64 — не шифрование). Допустимо только на локальном стенде, TLS — в lab7. diff --git a/auth.py b/auth.py new file mode 100644 index 0000000..fa62d84 --- /dev/null +++ b/auth.py @@ -0,0 +1,140 @@ +import base64 +import binascii +import hashlib +import logging +import secrets +from dataclasses import dataclass +from datetime import datetime, timedelta, timezone +from uuid import UUID + +import redis +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError +from redis.backoff import NoBackoff +from redis.retry import Retry + +import settings +from errors import BASIC_CHALLENGE, unauthorized, unavailable + +log = logging.getLogger("messenger.auth") + +hasher = PasswordHasher(time_cost=3, memory_cost=12 * 1024, parallelism=1) + +DUMMY_HASH = hasher.hash("there-is-no-such-user") + +PASSWORD_MIN_LENGTH = 12 +PASSWORD_MAX_LENGTH = 128 + + +def hash_password(password: str) -> str: + return hasher.hash(password) + + +def password_matches(password_hash: str | None, password: str) -> bool: + try: + hasher.verify(password_hash or DUMMY_HASH, password) + except (VerificationError, InvalidHashError): + return False + return password_hash is not None + +def parse_basic(header: str | None) -> tuple[str, str] | None: + """'Basic base64(username:password)' -> (username, password) или None. + + Пароль может содержать двоеточие, поэтому делим по первому двоеточию (RFC 7617). + """ + scheme, _, value = (header or "").strip().partition(" ") + if scheme.lower() != "basic" or not value or len(value) > 1024: + return None + try: + decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + return None + username, colon, password = decoded.partition(":") + if not colon or not username or not username.isascii(): + return None + return username, password + + +def parse_bearer(header: str | None) -> str | None: + scheme, _, value = (header or "").strip().partition(" ") + value = value.strip() + if scheme.lower() != "bearer" or not value or len(value) > 512 or " " in value: + return None + return value + + + +KEY_PREFIX = "session:" + +_redis = redis.Redis( + connection_pool=redis.BlockingConnectionPool.from_url( + settings.REDIS_URL or "redis://localhost:6379/0", + max_connections=settings.REDIS_POOL_MAX, + timeout=settings.REDIS_TIMEOUT_MS / 1000, + socket_timeout=settings.REDIS_TIMEOUT_MS / 1000, + socket_connect_timeout=settings.REDIS_TIMEOUT_MS / 1000, + retry=Retry(NoBackoff(), 0), + decode_responses=True, + ) +) + + +@dataclass(frozen=True) +class Session: + user_id: UUID + key: str + + +def session_key(token: str) -> str: + return KEY_PREFIX + hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def create_session(user_id: UUID) -> tuple[str, datetime]: + """Новая сессия: случайный токен и абсолютное время истечения.""" + token = secrets.token_urlsafe(32) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.SESSION_TTL_SECONDS) + try: + _redis.set(session_key(token), str(user_id), pxat=int(expires_at.timestamp() * 1000)) + except redis.RedisError as exc: + log.warning("Redis is unavailable on login: %s", type(exc).__name__) + raise unavailable() from None + return token, expires_at + + +def check_bearer(header: str | None) -> Session: + """Проверка токена для каждого защищённого запроса: 401 — не пускаем, 503 — Redis недоступен.""" + token = parse_bearer(header) + if token is None: + raise unauthorized("Bearer token is required") + key = session_key(token) + try: + user_id = _redis.get(key) + except redis.RedisError as exc: + log.warning("Redis is unavailable: %s", type(exc).__name__) + raise unavailable() from None + if user_id is None: + raise unauthorized("Session is invalid or expired") + return Session(UUID(user_id), key) + + +def delete_session(session: Session) -> None: + try: + _redis.delete(session.key) + except redis.RedisError: + raise unavailable() from None + + +def ping_redis() -> None: + try: + _redis.ping() + except redis.RedisError: + raise unavailable() from None + + +def login_failed(): + return unauthorized("Invalid username or password", BASIC_CHALLENGE) + + +def close() -> None: + _redis.close() + _redis.connection_pool.disconnect() diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..bae31fd --- /dev/null +++ b/compose.yaml @@ -0,0 +1,58 @@ +name: messenger-lab2 + +services: + api: + build: . + image: messenger-lab2-api + env_file: .env + environment: + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + secrets: [database_url, cache_url] + ports: ["127.0.0.1:8080:8080"] + depends_on: + postgres: {condition: service_healthy} + redis: {condition: service_healthy} + restart: unless-stopped + stop_grace_period: 10s + + postgres: + image: postgres:17.11-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + command: ["postgres", "-c", "fsync=on", "-c", "synchronous_commit=on"] + secrets: [postgres_password] + volumes: ["pgdata:/var/lib/postgresql/data"] + healthcheck: + test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 10s + restart: unless-stopped + stop_grace_period: 30s + + redis: + image: redis:7.4.11-alpine + command: ["redis-server", "/usr/local/etc/redis/redis.conf"] + volumes: + - ./infra/redis.conf:/usr/local/etc/redis/redis.conf:ro + - redisdata:/data + secrets: [redis_auth] + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(sed -n 's/^requirepass //p' /run/secrets/redis_auth)\" redis-cli ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 12 + restart: unless-stopped + +volumes: + pgdata: {} + redisdata: {} + +secrets: + postgres_password: {file: ./secrets/postgres_password} + database_url: {file: ./secrets/database_url} + cache_url: {file: ./secrets/cache_url} + redis_auth: {file: ./secrets/redis_auth} diff --git a/db.py b/db.py new file mode 100644 index 0000000..1b82471 --- /dev/null +++ b/db.py @@ -0,0 +1,213 @@ +import logging +import time +from contextlib import contextmanager +from datetime import datetime +from uuid import UUID, uuid4 + +import psycopg +from psycopg import errors as pg_errors +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout + +import settings +from errors import bad_request, conflict, not_found, unavailable + +log = logging.getLogger("messenger.db") + + +pool = ConnectionPool( + conninfo=settings.DATABASE_URL, + min_size=settings.DB_POOL_MIN, + max_size=settings.DB_POOL_MAX, + timeout=settings.DB_POOL_WAIT_SECONDS, + kwargs={ + "connect_timeout": settings.DB_CONNECT_TIMEOUT_SECONDS, + "row_factory": dict_row, + "options": f"-c statement_timeout={settings.DB_STATEMENT_TIMEOUT_MS}" + " -c idle_in_transaction_session_timeout=10000 -c TimeZone=UTC", + }, + + check=ConnectionPool.check_connection, + open=False, +) + + +@contextmanager +def connection(wait_seconds: float | None = None): + """Соединение из пула. В конце блока COMMIT, при исключении ROLLBACK. + + Если база недоступна, клиент получает 503 без подробностей. + """ + try: + with pool.connection(timeout=wait_seconds) as conn: + yield conn + except (psycopg.OperationalError, PoolTimeout) as exc: + log.warning("PostgreSQL is unavailable: %s", type(exc).__name__) + raise unavailable() from None + + +def ping() -> None: + with connection(wait_seconds=1) as conn: + conn.execute("SELECT 1") + + + +MIGRATIONS_LOCK = 20260202 + + +def run_migrations() -> list[str]: + files = sorted(settings.MIGRATIONS_DIR.glob("*.sql")) + applied = [] + with psycopg.connect(settings.DATABASE_URL, autocommit=True, + connect_timeout=settings.DB_CONNECT_TIMEOUT_SECONDS) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK,)) + try: + conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now())""") + done = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")} + for path in 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,)) + applied.append(path.name) + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK,)) + return applied + + +def wait_and_migrate(max_wait_seconds: int = 60) -> None: + """При запуске стенда PostgreSQL может стартовать позже API: ждём его, а не падаем.""" + deadline = time.monotonic() + max_wait_seconds + while True: + try: + applied = run_migrations() + log.info("Migrations applied: %s", ", ".join(applied) if applied else "none (schema is up to date)") + return + except psycopg.OperationalError: + if time.monotonic() > deadline: + raise + log.warning("PostgreSQL is not ready yet, retry in 1 s") + time.sleep(1) + + + +USER_COLUMNS = "id, username, display_name, created_at" + + +def create_user(username: str, display_name: str, password_hash: str) -> dict: + try: + with connection() as conn: + return conn.execute( + f"""INSERT INTO users (id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) RETURNING {USER_COLUMNS}""", + (uuid4(), username, display_name, password_hash), + ).fetchone() + except pg_errors.UniqueViolation: + raise conflict("Username already exists") from None + + +def get_user(user_id: UUID) -> dict | None: + with connection() as conn: + return conn.execute(f"SELECT {USER_COLUMNS} FROM users WHERE id = %s", (user_id,)).fetchone() + + +def get_user_with_password(username: str) -> dict | None: + with connection() as conn: + return conn.execute( + f"SELECT {USER_COLUMNS}, password_hash FROM users WHERE username = %s", (username,) + ).fetchone() + + + +CHAT_COLUMNS = """c.id, c.title, c.created_at, + ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.user_id) AS member_ids""" + + +def create_chat(title: str, member_ids: list[UUID]) -> dict: + chat_id = uuid4() + members = sorted(member_ids) + try: + with connection() as conn: + with conn.transaction(): + row = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at", + (chat_id, title), + ).fetchone() + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(chat_id, member_id) for member_id in members], + ) + except pg_errors.ForeignKeyViolation: + raise bad_request("Unknown member") from None + return {**row, "member_ids": members} + + +def get_chat(chat_id: UUID, user_id: UUID) -> dict: + with connection() as conn: + chat = conn.execute( + f"""SELECT {CHAT_COLUMNS} FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE c.id = %s""", + (user_id, chat_id), + ).fetchone() + if chat is None: + raise not_found("Chat not found") + return chat + + +def list_chats(user_id: UUID, after: tuple[datetime, UUID] | None, limit: int) -> list[dict]: + """Чаты пользователя после курсора. Возвращает до limit+1 строк: лишняя значит «есть ещё».""" + where, params = "", [user_id] + if after is not None: + where = "WHERE (c.created_at, c.id) > (%s, %s)" + params += list(after) + with connection() as conn: + return conn.execute( + f"""SELECT {CHAT_COLUMNS} FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + {where} + ORDER BY c.created_at, c.id + LIMIT %s""", + (*params, limit + 1), + ).fetchall() + + + +MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at" + + +def add_message(chat_id: UUID, sender_id: UUID, text: str) -> dict: + try: + with connection() as conn: + return conn.execute( + f"""INSERT INTO messages (id, chat_id, sender_id, text) + VALUES (%s, %s, %s, %s) RETURNING {MESSAGE_COLUMNS}""", + (uuid4(), chat_id, sender_id, text), + ).fetchone() + except pg_errors.ForeignKeyViolation: + raise not_found("Chat not found") from None + + +def list_messages(chat_id: UUID, user_id: UUID, after: tuple[datetime, UUID] | None, limit: int) -> list[dict]: + """История чата после курсора (keyset-пагинация), до limit+1 строк.""" + where, params = "chat_id = %s", [chat_id] + if after is not None: + where += " AND (created_at, id) > (%s, %s)" + params += list(after) + with connection() as conn: + member = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id) + ).fetchone() + if member is None: + raise not_found("Chat not found") + return conn.execute( + f"""SELECT {MESSAGE_COLUMNS} FROM messages + WHERE {where} + ORDER BY created_at, id + LIMIT %s""", + (*params, limit + 1), + ).fetchall() diff --git a/errors.py b/errors.py new file mode 100644 index 0000000..02a9730 --- /dev/null +++ b/errors.py @@ -0,0 +1,32 @@ +# Что сервер пишет в WWW-Authenticate при 401: какую схему входа он ждёт. +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' # только POST /auth/sessions +BEARER_CHALLENGE = 'Bearer realm="messenger"' # все остальные защищённые запросы + + +class ApiError(Exception): + def __init__(self, status_code: int, code: str, message: str, headers: dict | None = None): + super().__init__(message) + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers or {} + + +def bad_request(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(message: str = "Unauthorized", challenge: str = BEARER_CHALLENGE) -> ApiError: + return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge}) + + +def not_found(message: str) -> ApiError: + return ApiError(404, "not_found", message) + + +def conflict(message: str) -> ApiError: + return ApiError(409, "conflict", message) + + +def unavailable(message: str = "Service temporarily unavailable") -> ApiError: + return ApiError(503, "unavailable", message) diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..80f5d36 Binary files /dev/null and b/evidence/check.txt differ diff --git a/evidence/db.txt b/evidence/db.txt new file mode 100644 index 0000000..8e99167 Binary files /dev/null and b/evidence/db.txt differ diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 0000000..7f68aef Binary files /dev/null and b/evidence/expiry.txt differ diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 0000000..d4cc7fb --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,74 @@ +=== Data volume + messages_total | messages_in_big_chat +----------------+---------------------- + 20116 | 15000 + + +=== History index + indexdef +---------------------------------------------------------------------------------------- + CREATE INDEX messages_history ON public.messages USING btree (chat_id, created_at, id) + + +=== 1. First page: limit=50, the app asks for 51 rows to know if there is a next page + QUERY PLAN +------------------------------------------------------------------------------------------------ + Limit (actual time=0.007..0.012 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_history on messages (actual time=0.007..0.009 rows=51 loops=1) + Index Cond: (chat_id = '6a75871f-4837-4b3c-b7c8-1c36de87da98'::uuid) + Buffers: shared hit=4 + Planning: + Buffers: shared hit=8 + Planning Time: 0.155 ms + Execution Time: 0.028 ms + + +=== 2. Page after the 10000th message by keyset cursor (this is what the app does) + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (actual time=0.006..0.012 rows=51 loops=1) + Buffers: shared hit=6 + -> Index Scan using messages_history on messages (actual time=0.006..0.010 rows=51 loops=1) + Index Cond: ((chat_id = '6a75871f-4837-4b3c-b7c8-1c36de87da98'::uuid) AND (ROW(created_at, id) > ROW('2026-09-01 02:46:40+00'::timestamp with time zone, 'd867a7e3-2b56-475a-81c9-19729e8336c2'::uuid))) + Buffers: shared hit=6 + Planning Time: 0.038 ms + Execution Time: 0.031 ms + + +=== 3. The same page with OFFSET 10000 (the app does NOT do this) + QUERY PLAN +--------------------------------------------------------------------------------------------------- + Limit (actual time=0.716..0.721 rows=51 loops=1) + Buffers: shared hit=257 + -> Index Scan using messages_history on messages (actual time=0.008..0.521 rows=10051 loops=1) + Index Cond: (chat_id = '6a75871f-4837-4b3c-b7c8-1c36de87da98'::uuid) + Buffers: shared hit=257 + Planning Time: 0.028 ms + Execution Time: 0.765 ms + + +=== 4. Query 2 without the index (index is dropped only inside this transaction) + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (actual time=0.862..0.865 rows=51 loops=1) + Buffers: shared hit=255 + -> Sort (actual time=0.861..0.863 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 31kB + Buffers: shared hit=255 + -> Seq Scan on messages (actual time=0.289..0.686 rows=5000 loops=1) + Filter: ((chat_id = '6a75871f-4837-4b3c-b7c8-1c36de87da98'::uuid) AND (ROW(created_at, id) > ROW('2026-09-01 02:46:40+00'::timestamp with time zone, 'd867a7e3-2b56-475a-81c9-19729e8336c2'::uuid))) + Rows Removed by Filter: 15116 + Buffers: shared hit=255 + Planning: + Buffers: shared hit=4 + Planning Time: 0.051 ms + Execution Time: 0.884 ms + + +=== ROLLBACK: test data removed, index is back + explain_users_left +-------------------- + 0 + diff --git a/evidence/failures.txt b/evidence/failures.txt new file mode 100644 index 0000000..de478df Binary files /dev/null and b/evidence/failures.txt differ diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..2c5670c Binary files /dev/null and b/evidence/persistence.txt differ diff --git a/evidence/race.txt b/evidence/race.txt new file mode 100644 index 0000000..c60b734 Binary files /dev/null and b/evidence/race.txt differ diff --git a/evidence/redis.txt b/evidence/redis.txt new file mode 100644 index 0000000..f4fea52 Binary files /dev/null and b/evidence/redis.txt differ diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..04938cf Binary files /dev/null and b/evidence/smoke.txt differ diff --git a/evidence/stack.txt b/evidence/stack.txt new file mode 100644 index 0000000..183002d Binary files /dev/null and b/evidence/stack.txt differ diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 0000000..1440c6b Binary files /dev/null and b/evidence/student-tests.txt differ diff --git a/infra/redis.conf b/infra/redis.conf new file mode 100644 index 0000000..9e99f43 --- /dev/null +++ b/infra/redis.conf @@ -0,0 +1,26 @@ +# Redis в этой работе — ХРАНИЛИЩЕ СЕССИЙ (источник истины для Bearer-токенов). +# Поэтому, в отличие от кэша, здесь включено сохранение на диск: сессии должны +# пережить перезапуск Redis. + +bind 0.0.0.0 +port 6379 +protected-mode yes +dir /data + +# AOF (append only file): каждая команда записи дописывается в журнал на диске. +# appendfsync always — Redis отвечает «OK» на SET только после fsync журнала, +# то есть выданный токен уже лежит на диске. Записей мало (только вход и выход), +# поэтому цена fsync на каждую незаметна на фоне проверки пароля Argon2id. +appendonly yes +appendfsync always +# RDB-снимки не нужны: всё восстанавливается из AOF. +save "" + +# Память ограничена. noeviction: при нехватке памяти Redis откажет в новой записи +# (вход получит 503), но НЕ будет молча удалять чужие действующие сессии. +maxmemory 64mb +maxmemory-policy noeviction + +# Пароль (строка "requirepass ...") лежит в секрете, который создаёт scripts/init_secrets.py. +# Без пароля подключиться нельзя. Подключается include последним, чтобы его нельзя было переопределить. +include /run/secrets/redis_auth diff --git a/main.py b/main.py new file mode 100644 index 0000000..1f3cf57 --- /dev/null +++ b/main.py @@ -0,0 +1,435 @@ +"""Мессенджер, lab2: HTTP API по contracts/openapi.json. + +Что изменилось с lab1: +- данные (users, chats, messages) теперь в PostgreSQL, а не в словарях: см. db.py; +- регистрация принимает password, вход — POST /auth/sessions с Basic, выход — DELETE; +- текущий пользователь определяется только по Bearer-токену (сессии в Redis, см. auth.py), + заголовок X-User-Id больше ничего не значит. +Модели, формат ошибок, X-Request-Id и курсоры остались из lab1. +""" +import base64 +import binascii +import json +import logging +import time +import uuid +from contextlib import asynccontextmanager +from datetime import datetime +from uuid import UUID + +import uvicorn +from fastapi import FastAPI, Header, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from pydantic import BaseModel, ConfigDict, Field, field_validator +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +import auth +import db +import settings +from errors import ApiError, bad_request, unauthorized + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s") +log = logging.getLogger("messenger") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + settings.check() + await run_in_threadpool(db.wait_and_migrate) + db.pool.open() + log.info("Started: env=%s, session TTL=%s s, sessions in Redis", settings.APP_ENV, settings.SESSION_TTL_SECONDS) + yield + db.pool.close() + auth.close() + log.info("Stopped: connections closed, data stays in PostgreSQL and Redis") + + +app = FastAPI(lifespan=lifespan) + + + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=auth.PASSWORD_MIN_LENGTH, max_length=auth.PASSWORD_MAX_LENGTH) + + @field_validator("display_name", "password") + @classmethod + def validate_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("value cannot be blank") + return value + + +class User(BaseModel): + id: UUID + username: str + display_name: str + created_at: datetime + + +class Session(BaseModel): + token: str + token_type: str + expires_at: datetime + user: User + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + if not value.strip(): + raise ValueError("title cannot be empty") + return value + + +class Chat(BaseModel): + id: UUID + title: str + member_ids: list[UUID] + created_at: datetime + + +class ChatPage(BaseModel): + items: list[Chat] + next_cursor: str | None + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(max_length=4000) + + @field_validator("text") + @classmethod + def validate_text(cls, value: str) -> str: + if not value.strip(): + raise ValueError("text cannot be empty") + return value + + +class Message(BaseModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + +class MessagePage(BaseModel): + items: list[Message] + next_cursor: str | None + + +def error_response( + request: Request, + code: str, + message: str, + status_code: int, + headers: dict | None = None, +): + request_id = request.state.request_id + + return JSONResponse( + status_code=status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + }, + headers={"X-Request-Id": request_id, **(headers or {})}, + ) + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError): + return error_response(request, exc.code, exc.message, exc.status_code, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler( + request: Request, + exc: RequestValidationError, +): + return error_response( + request, + "invalid_request", + "Invalid request data", + 400, + ) + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException): + if exc.status_code == 404: + return error_response(request, "not_found", "Not found", 404) + return error_response(request, "invalid_request", "Request cannot be processed", exc.status_code, exc.headers) + + +@app.exception_handler(Exception) +async def general_exception_handler( + request: Request, + exc: Exception, +): + return error_response( + request, + "internal_error", + "Internal server error", + 500, + ) + +PUBLIC_ENDPOINTS = { + ("POST", "/api/v1/users"), + ("POST", "/api/v1/auth/sessions"), +} + + +@app.middleware("http") +async def request_context(request: Request, call_next): + request_id = str(uuid.uuid4()) + request.state.request_id = request_id + started = time.perf_counter() + + try: + path = request.url.path + if path.startswith("/api/") and (request.method, path) not in PUBLIC_ENDPOINTS: + request.state.session = await run_in_threadpool( + auth.check_bearer, request.headers.get("Authorization") + ) + response = await call_next(request) + except ApiError as exc: + response = error_response(request, exc.code, exc.message, exc.status_code, exc.headers) + except Exception: + log.exception("Unhandled error, request_id=%s", request_id) + response = error_response(request, "internal_error", "Internal server error", 500) + + response.headers["X-Request-Id"] = request_id + log.info( + "%s %s -> %s (%.1f ms) request_id=%s", + request.method, request.url.path, response.status_code, + (time.perf_counter() - started) * 1000, request_id, + ) + return response + + +def current_user_id(request: Request) -> UUID: + session = getattr(request.state, "session", None) + if session is None: + raise unauthorized("Bearer token is required") + return session.user_id + + +def encode_cursor( + created_at: datetime, + object_id: UUID, + *, + chat_id: UUID | None = None, + user_id: UUID | None = None, +) -> str: + data = { + "created_at": created_at.isoformat(), + "id": str(object_id), + } + + if chat_id is not None: + data["chat_id"] = str(chat_id) + + if user_id is not None: + data["user_id"] = str(user_id) + + raw = json.dumps(data).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def decode_cursor(cursor: str): + try: + raw = base64.urlsafe_b64decode(cursor.encode("ascii")) + data = json.loads(raw.decode("utf-8")) + + created_at = datetime.fromisoformat(data["created_at"]) + + if created_at.tzinfo is None: + raise ValueError("Invalid cursor") + + if not isinstance(data["id"], str): + raise ValueError("Invalid cursor") + + object_id = UUID(data["id"]) + + chat_id = UUID(data["chat_id"]) if "chat_id" in data else None + user_id = UUID(data["user_id"]) if "user_id" in data else None + + return created_at, object_id, chat_id, user_id + + except ( + ValueError, + KeyError, + TypeError, + AttributeError, + json.JSONDecodeError, + binascii.Error, + ): + raise ValueError("Invalid cursor") + + +def page_after(cursor: str | None, *, chat_id: UUID | None = None, user_id: UUID | None = None): + """Курсор -> ключ (created_at, id), с которого продолжать. Чужой или битый курсор — 400.""" + if not cursor: + return None + try: + created_at, object_id, cursor_chat_id, cursor_user_id = decode_cursor(cursor) + except ValueError: + raise bad_request("Invalid cursor") from None + if cursor_chat_id != chat_id or cursor_user_id != user_id: + raise bad_request("Invalid cursor") + return created_at, object_id + + + +@app.get("/health/live") +def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def health_ready(): + db.ping() + auth.ping_redis() + return {"status": "ok"} + + + +@app.post("/api/v1/users", response_model=User, status_code=201) +def create_user(user_data: CreateUser): + password_hash = auth.hash_password(user_data.password) # сам пароль нигде не сохраняется + return db.create_user(user_data.username, user_data.display_name, password_hash) + + +@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201) +def create_session( + response: Response, + authorization: str | None = Header(default=None), +): + credentials = auth.parse_basic(authorization) + if credentials is None: + raise auth.login_failed() + username, password = credentials + + found = None + if len(password) <= auth.PASSWORD_MAX_LENGTH: + found = db.get_user_with_password(username) + if not auth.password_matches(found["password_hash"] if found else None, password): + raise auth.login_failed() + + token, expires_at = auth.create_session(found["id"]) + response.headers["Cache-Control"] = "no-store" + user = {key: found[key] for key in ("id", "username", "display_name", "created_at")} + return {"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def delete_session(request: Request): + current_user_id(request) + auth.delete_session(request.state.session) + return Response(status_code=204) + + +@app.get("/api/v1/users/me", response_model=User) +def get_current_user(request: Request): + user = db.get_user(current_user_id(request)) + if user is None: + raise unauthorized("Session is invalid or expired") + return user + + + +@app.post("/api/v1/chats", response_model=Chat, status_code=201) +def create_chat(request: Request, chat_data: CreateChat): + user_id = current_user_id(request) + + if user_id not in chat_data.member_ids: + raise bad_request("Creator must be a chat member") + + if len(chat_data.member_ids) != len(set(chat_data.member_ids)): + raise bad_request("Duplicate member IDs") + return db.create_chat(chat_data.title, chat_data.member_ids) + + +@app.get("/api/v1/chats", response_model=ChatPage) +def list_chats( + request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None), +): + user_id = current_user_id(request) + after = page_after(cursor, user_id=user_id) + + rows = db.list_chats(user_id, after, limit) + items = rows[:limit] + + next_cursor = None + if len(rows) > limit: + last = items[-1] + next_cursor = encode_cursor(last["created_at"], last["id"], user_id=user_id) + + return ChatPage(items=items, next_cursor=next_cursor) + + +@app.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat(request: Request, chat_id: UUID): + return db.get_chat(chat_id, current_user_id(request)) + + +@app.post( + "/api/v1/chats/{chat_id}/messages", + response_model=Message, + status_code=201, +) +def create_message(request: Request, message_data: CreateMessage, chat_id: UUID): + return db.add_message(chat_id, current_user_id(request), message_data.text) + + +@app.get( + "/api/v1/chats/{chat_id}/messages", + response_model=MessagePage, +) +def list_messages( + request: Request, + chat_id: UUID, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None), +): + user_id = current_user_id(request) + after = page_after(cursor, chat_id=chat_id) + + rows = db.list_messages(chat_id, user_id, after, limit) + items = rows[:limit] + + next_cursor = None + if len(rows) > limit: + last = items[-1] + next_cursor = encode_cursor(last["created_at"], last["id"], chat_id=chat_id) + + return MessagePage(items=items, next_cursor=next_cursor) + + +if __name__ == "__main__": + uvicorn.run( + app, + host=settings.APP_HOST, + port=settings.APP_PORT, + timeout_graceful_shutdown=settings.SHUTDOWN_TIMEOUT_SECONDS, + access_log=False, + ) diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..8b981d0 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,33 @@ + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_by_user ON chat_members (user_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT now(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id) +); + +CREATE INDEX messages_history ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..cd4d141 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,21 @@ +fastapi==0.141.1 +uvicorn==0.54.0 +pydantic==2.13.5 +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +argon2-cffi==25.1.0 +redis==6.4.0 +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +h11==0.16.0 +idna==3.20 +pycparser==3.1 +pydantic_core==2.46.5 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 0000000..3a42263 --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,30 @@ +import secrets +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +SECRETS = ROOT / "secrets" + + +def write(name: str, value: str) -> None: + with open(SECRETS / name, "w", encoding="utf-8", newline="") as file: + file.write(value) + (SECRETS / name).chmod(0o644) + + +def main() -> None: + if (SECRETS / "postgres_password").exists(): + print("secrets/ already exists, nothing changed.") + return + SECRETS.mkdir(exist_ok=True) + db_password = secrets.token_hex(24) + redis_password = secrets.token_hex(24) + + write("postgres_password", db_password) + write("database_url", f"postgresql://messenger:{db_password}@postgres:5432/messenger") + write("cache_url", f"redis://:{redis_password}@redis:6379/0") + write("redis_auth", f"requirepass {redis_password}\n") + print("Created secrets/: postgres_password, database_url, cache_url, redis_auth (values are not printed).") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..ae0fb16 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,7 @@ +@echo off +rem Restart hook for tests/resilience.py on Windows (same as scripts/restart.sh). +rem Python on Windows cannot start .sh files directly (WinError 193), a .cmd file works. +rem Restarts all containers of the stand: api, postgres, redis. Volumes are kept (no down -v). +cd /d "%~dp0.." +docker compose restart || exit /b 1 +exit /b 0 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..7c2a64c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose restart diff --git a/settings.py b/settings.py new file mode 100644 index 0000000..949862a --- /dev/null +++ b/settings.py @@ -0,0 +1,53 @@ +import os +from pathlib import Path + + +def env_str(name: str, default: str) -> str: + return os.environ.get(name, default).strip() + + +def env_int(name: str, default: int) -> int: + value = int(env_str(name, str(default))) + if value < 1: + raise ValueError(f"{name} must be >= 1") + return value + + +def read_secret(file_variable: str, plain_variable: str) -> str: + path = env_str(file_variable, "") + if path: + return Path(path).read_text(encoding="utf-8").strip() + return env_str(plain_variable, "") + + +APP_HOST = env_str("APP_HOST", "0.0.0.0") +APP_PORT = env_int("APP_PORT", 8080) +APP_ENV = env_str("APP_ENV", "lab") + +SESSION_TTL_SECONDS = env_int("SESSION_TTL_SECONDS", 3600) +SESSION_STORE = env_str("SESSION_STORE", "redis") + +DATABASE_URL = read_secret("DATABASE_URL_FILE", "DATABASE_URL") +DB_POOL_MIN = env_int("DB_POOL_MIN", 1) +DB_POOL_MAX = env_int("DB_POOL_MAX", 10) +DB_POOL_WAIT_SECONDS = env_int("DB_POOL_WAIT_SECONDS", 3) +DB_CONNECT_TIMEOUT_SECONDS = env_int("DB_CONNECT_TIMEOUT_SECONDS", 3) +DB_STATEMENT_TIMEOUT_MS = env_int("DB_STATEMENT_TIMEOUT_MS", 5000) + +REDIS_URL = read_secret("CACHE_URL_FILE", "CACHE_URL") +REDIS_POOL_MAX = env_int("REDIS_POOL_MAX", 20) +REDIS_TIMEOUT_MS = env_int("REDIS_TIMEOUT_MS", 500) + +MIGRATIONS_DIR = Path(env_str("MIGRATIONS_DIR", str(Path(__file__).resolve().parent / "migrations"))) + +SHUTDOWN_TIMEOUT_SECONDS = 5 + + +def check() -> None: + """Проверка при старте: лучше сразу упасть с понятной ошибкой, чем на первом запросе.""" + if not DATABASE_URL: + raise RuntimeError("PostgreSQL address is not set: DATABASE_URL_FILE") + if not REDIS_URL: + raise RuntimeError("Redis address is not set: CACHE_URL_FILE") + if SESSION_STORE != "redis": + raise RuntimeError("SESSION_STORE: only 'redis' is supported in this solution") diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 0000000..32bc700 --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,182 @@ +"""Общий код для собственных тестов: маленький HTTP-клиент и работа со стендом. + +Только стандартная библиотека Python, ничего ставить не нужно. +Тесты ходят на BASE_URL (по умолчанию http://127.0.0.1:8080) и управляют +контейнерами через `docker compose`, запуская его прямо из Python. +Поэтому всё работает одинаково в PowerShell, cmd и Git Bash на Windows. +Вывод тестов — только латиница, чтобы консоль Windows не ломала кодировку. +""" +import base64 +import hashlib +import json +import os +import subprocess +import time +import urllib.error +import urllib.parse +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") +PASSWORD = "Test-password-123" + + +class Response: + def __init__(self, status, headers, data): + self.status = status + self.headers = {name.lower(): value for name, value in headers.items()} + self.data = data + try: + self.json = json.loads(data.decode("utf-8")) if data else None + except ValueError: + self.json = None + + +def check(condition, message): + if not condition: + raise AssertionError(message) + + +def call(method, path, expected=200, *, body=None, raw=None, token=None, headers=None): + """HTTP-запрос к API. expected — код или кортеж кодов, иначе AssertionError. + + Заодно проверяет то, что контракт требует от любого ответа: + X-Request-Id, единый формат ошибки, WWW-Authenticate у 401. + """ + all_headers = dict(headers or {}) + data = raw + if body is not None: + data = json.dumps(body).encode("utf-8") + if data is not None: + all_headers.setdefault("Content-Type", "application/json") + if token is not None: + all_headers["Authorization"] = "Bearer " + token + + request = urllib.request.Request(BASE_URL + path, data=data, method=method, headers=all_headers) + try: + with urllib.request.urlopen(request, timeout=30) as reply: + response = Response(reply.status, reply.headers, reply.read()) + except urllib.error.HTTPError as error: + response = Response(error.code, error.headers, error.read()) + + expected = expected if isinstance(expected, tuple) else (expected,) + check(response.status in expected, + f"{method} {path}: expected {expected}, got {response.status} {response.data[:200]!r}") + request_id = response.headers.get("x-request-id") + check(request_id, f"{method} {path}: no X-Request-Id header") + if response.status >= 400: + error = (response.json or {}).get("error") or {} + check(error.get("code") and error.get("message"), f"{method} {path}: wrong error format") + check(error.get("request_id") == request_id, f"{method} {path}: request_id differs from header") + if response.status == 401: + check(response.headers.get("www-authenticate"), f"{method} {path}: 401 without WWW-Authenticate") + return response + + +def basic(username, password): + """Значение заголовка Authorization: Basic base64(username:password), пароль в UTF-8.""" + return "Basic " + base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii") + + +def login(username, password, expected=201): + return call("POST", "/api/v1/auth/sessions", expected, headers={"Authorization": basic(username, password)}) + + +def new_user(prefix="user", password=PASSWORD): + """Регистрирует пользователя и входит. Возвращает dict: id, username, password, token.""" + username = f"{prefix}_{uuid.uuid4().hex[:10]}" + user = call("POST", "/api/v1/users", 201, + body={"username": username, "display_name": prefix.title(), "password": password}).json + session = login(username, password).json + return {**user, "password": password, "token": session["token"]} + + +def new_chat(owner, *others, title="Test chat"): + member_ids = [owner["id"]] + [user["id"] for user in others] + return call("POST", "/api/v1/chats", 201, token=owner["token"], + body={"title": title, "member_ids": member_ids}).json + + +def send(user, chat_id, text, expected=201): + return call("POST", f"/api/v1/chats/{chat_id}/messages", expected, token=user["token"], body={"text": text}) + + +def read_history(user, chat_id, limit=100): + """Вся история чата по страницам. Возвращает (сообщения, число_страниц).""" + items, pages, cursor = [], 0, None + while True: + query = f"?limit={limit}" + (f"&cursor={urllib.parse.quote(cursor, safe='')}" if cursor else "") + page = call("GET", f"/api/v1/chats/{chat_id}/messages{query}", 200, token=user["token"]).json + items += page["items"] + pages += 1 + cursor = page["next_cursor"] + if cursor is None: + return items, pages + + +def wait_ready(seconds=90): + deadline = time.monotonic() + seconds + while True: + try: + with urllib.request.urlopen(BASE_URL + "/health/ready", timeout=3) as reply: + if reply.status == 200: + return + except (urllib.error.URLError, OSError): + pass + check(time.monotonic() < deadline, f"API is not ready after {seconds} s") + time.sleep(0.5) + + +def compose(*args, env=None): + """docker compose в корне репозитория. Вывод скрыт: в нём могут быть пути к секретам.""" + subprocess.run(["docker", "compose", *args], cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def compose_output(*args): + """docker compose и его вывод (для logs, ps).""" + result = subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, check=True) + return result.stdout.decode("utf-8", "replace") + result.stderr.decode("utf-8", "replace") + + +def redis_cli(*args): + """redis-cli внутри контейнера redis. Пароль читается там же из секрета и не попадает в вывод.""" + command = "REDISCLI_AUTH=\"$(sed -n 's/^requirepass //p' /run/secrets/redis_auth)\" redis-cli " + " ".join(args) + result = subprocess.run(["docker", "compose", "exec", "-T", "redis", "sh", "-c", command], + cwd=ROOT, capture_output=True, check=True) + return result.stdout.decode("utf-8", "replace").strip() + + +def session_key(token): + """Ключ сессии в Redis, как его считает auth.py: session:.""" + return "session:" + hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def psql(sql): + """Выполняет SQL в контейнере postgres. Возвращает (код выхода, вывод, текст ошибки). + + Значения в SQL тестов — только сгенерированные самим тестом (uuid), не ввод пользователя. + """ + result = subprocess.run( + ["docker", "compose", "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", "-X", "-A", "-t", "-v", "ON_ERROR_STOP=1", "-c", sql], + cwd=ROOT, capture_output=True, check=False, + ) + output = result.stdout.decode("utf-8", "replace").strip() + error = result.stderr.decode("utf-8", "replace").strip() + return result.returncode, output, error + + +def run_tests(tests): + """Запускает функции-тесты по очереди. Код выхода 1, если хоть один упал.""" + failed = 0 + for test in tests: + try: + test() + except Exception as exc: # noqa: BLE001 — нужно напечатать любую ошибку теста + failed += 1 + print(f"FAIL: {test.__name__}: {exc}") + print(f"{len(tests) - failed} passed, {failed} failed") + raise SystemExit(1 if failed else 0) diff --git a/student-tests/explain.py b/student-tests/explain.py new file mode 100644 index 0000000..b5151e8 --- /dev/null +++ b/student-tests/explain.py @@ -0,0 +1,34 @@ +"""EXPLAIN (ANALYZE, BUFFERS) для истории сообщений на 20 000 сообщений. + + python student-tests/explain.py + +Отправляет student-tests/explain.sql в psql внутри контейнера postgres +и сохраняет вывод в evidence/explain-history.txt (тестовые данные потом откатываются). +""" +import subprocess + +from common import ROOT + +OUTPUT = ROOT / "evidence" / "explain-history.txt" + + +def main(): + sql = (ROOT / "student-tests" / "explain.sql").read_bytes() + result = subprocess.run( + ["docker", "compose", "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-v", "ON_ERROR_STOP=1"], + cwd=ROOT, input=sql, capture_output=True, check=False, + ) + OUTPUT.parent.mkdir(exist_ok=True) + OUTPUT.write_bytes(result.stdout + result.stderr) + if result.returncode != 0: + print(result.stderr.decode("utf-8", "replace")) + raise SystemExit("FAIL: psql returned an error, see output above") + for line in result.stdout.decode("utf-8", "replace").splitlines(): + if line.startswith("===") or "Buffers" in line or "Execution Time" in line or " Scan " in line: + print(line) + print(f"PASS: full plans saved to {OUTPUT.relative_to(ROOT)}") + + +if __name__ == "__main__": + main() diff --git a/student-tests/explain.sql b/student-tests/explain.sql new file mode 100644 index 0000000..a5841c2 --- /dev/null +++ b/student-tests/explain.sql @@ -0,0 +1,73 @@ +-- Обоснование индекса истории messages_history (migrations/001_init.sql). +-- Запуск: python student-tests/explain.py (результат -> evidence/explain-history.txt) +-- +-- Всё в одной транзакции, в конце ROLLBACK: тестовые данные не остаются в базе, +-- скрипт можно запускать сколько угодно раз. + +\pset footer off +BEGIN; + +-- Тестовые данные: один большой чат на 15 000 сообщений и 50 маленьких по 100, +-- всего 20 000 сообщений. Чужие сообщения в таблице есть, как в настоящей базе. +CREATE TEMP TABLE seed_chats AS + SELECT gen_random_uuid() AS id, n, CASE WHEN n = 0 THEN 15000 ELSE 100 END AS size + FROM generate_series(0, 50) AS n; +CREATE TEMP TABLE seed_user AS SELECT gen_random_uuid() AS id; + +INSERT INTO users (id, username, display_name, password_hash) + SELECT id, 'explain_' || substr(md5(random()::text), 1, 10), 'Explain', 'not-a-real-hash' FROM seed_user; +INSERT INTO chats (id, title) SELECT id, 'explain ' || n FROM seed_chats; +INSERT INTO chat_members (chat_id, user_id) SELECT c.id, u.id FROM seed_chats c, seed_user u; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), c.id, u.id, 'message ' || g, + timestamptz '2026-09-01 00:00:00+00' + g * interval '1 second' + FROM seed_chats c, seed_user u, generate_series(1, c.size) AS g; +ANALYZE messages; + +SELECT id AS big_chat FROM seed_chats WHERE n = 0 \gset +-- Курсор глубоко в истории: ключ (created_at, id) 10 000-го сообщения большого чата. +SELECT created_at AS cursor_time, id AS cursor_id FROM messages + WHERE chat_id = :'big_chat' ORDER BY created_at, id OFFSET 9999 LIMIT 1 \gset + +\echo '=== Data volume' +SELECT count(*) AS messages_total, + count(*) FILTER (WHERE chat_id = :'big_chat') AS messages_in_big_chat +FROM messages; + +\echo '' +\echo '=== History index' +SELECT indexdef FROM pg_indexes WHERE indexname = 'messages_history'; + +\echo '' +\echo '=== 1. First page: limit=50, the app asks for 51 rows to know if there is a next page' +EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' +ORDER BY created_at, id LIMIT 51; + +\echo '' +\echo '=== 2. Page after the 10000th message by keyset cursor (this is what the app does)' +EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cursor_time'::timestamptz, :'cursor_id'::uuid) +ORDER BY created_at, id LIMIT 51; + +\echo '' +\echo '=== 3. The same page with OFFSET 10000 (the app does NOT do this)' +EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' +ORDER BY created_at, id OFFSET 10000 LIMIT 51; + +\echo '' +\echo '=== 4. Query 2 without the index (index is dropped only inside this transaction)' +DROP INDEX messages_history; +EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cursor_time'::timestamptz, :'cursor_id'::uuid) +ORDER BY created_at, id LIMIT 51; + +ROLLBACK; +\echo '' +\echo '=== ROLLBACK: test data removed, index is back' +SELECT count(*) AS explain_users_left FROM users WHERE username LIKE 'explain\_%'; diff --git a/student-tests/redis_info.py b/student-tests/redis_info.py new file mode 100644 index 0000000..be3cdfb --- /dev/null +++ b/student-tests/redis_info.py @@ -0,0 +1,38 @@ +"""Что лежит в Redis и как он настроен (доказательство для отчёта). + + python student-tests/redis_info.py + +Входит новым пользователем и показывает: ключ его сессии и остаток TTL, +сколько всего сессий, настройки сохранения на диск и политику памяти, +и что без пароля Redis ничего не отдаёт. Токены и пароли не печатаются: +ключ — это SHA-256 токена. +""" +import subprocess + +from common import ROOT, login, new_user, redis_cli, session_key + + +def without_password(): + result = subprocess.run(["docker", "compose", "exec", "-T", "redis", "redis-cli", "get", "anything"], + cwd=ROOT, capture_output=True, check=False) + return (result.stdout + result.stderr).decode("utf-8", "replace").strip() + + +def main(): + user = new_user("info") + token = login(user["username"], user["password"]).json["token"] + key = session_key(token) + print(f"session key: {key[:24]}...; value is the user id: {redis_cli('get', key) == user['id']}") + print(f"TTL of the key, seconds: {redis_cli('ttl', key)}") + keys = redis_cli("--scan", "--pattern", "'session:*'").splitlines() + print(f"sessions in Redis: {len(keys)}") + for name in ("appendonly", "appendfsync", "maxmemory-policy"): + print("config", " = ".join(redis_cli("config", "get", name).split())) + for line in redis_cli("info", "persistence").splitlines(): + if line.startswith(("aof_enabled", "aof_last_write_status")): + print(line) + print(f"without password: {without_password()}") + + +if __name__ == "__main__": + main() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 0000000..382aeeb --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,238 @@ +"""Собственные тесты API (lab1 + lab2). Запуск одной командой при запущенном стенде: + + python student-tests/test_api.py + +Тесты lab1 переведены с X-User-Id на пароль и Bearer-токен. Добавлены тесты lab2: +вход по Basic, неверный пароль, logout, Bearer на всех защищённых запросах. +""" +import base64 +import datetime as dt +import uuid + +from common import PASSWORD, basic, call, check, login, new_chat, new_user, read_history, run_tests, send + + +def parse_time(value): + return dt.datetime.fromisoformat(value.replace("Z", "+00:00")) + + +# ---------- lab1 (перенесены, теперь с токенами) ---------- + +def test_duplicate_username(): + body = {"username": "dup_" + uuid.uuid4().hex[:10], "display_name": "First user", "password": PASSWORD} + call("POST", "/api/v1/users", 201, body=body) + call("POST", "/api/v1/users", 409, body=dict(body, display_name="Second user")) + print("PASS: duplicate username returns 409") + + +def test_invalid_json(): + alice = new_user("alice") + chat = new_chat(alice) + call("POST", "/api/v1/users", 400, raw=b'{"username":') + call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, token=alice["token"], raw=b"not json") + print("PASS: invalid JSON returns 400") + + +def test_wrong_fields(): + alice, bob = new_user("alice"), new_user("bob") + chat = new_chat(alice, bob) + call("POST", "/api/v1/users", 400, body={"username": "Bad Name!", "display_name": "x", "password": PASSWORD}) + call("POST", "/api/v1/users", 400, + body={"username": "valid_" + uuid.uuid4().hex[:8], "display_name": "x", "password": PASSWORD, "is_admin": True}) + # Отправителя нельзя подставить: он берётся из сессии. + call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, token=alice["token"], + body={"text": "hi", "sender_id": bob["id"]}) + print("PASS: wrong and extra fields return 400") + + +def test_foreign_chat(): + alice, bob, eve = new_user("alice"), new_user("bob"), new_user("eve") + chat = new_chat(alice, bob) + call("GET", f"/api/v1/chats/{chat['id']}", 404, token=eve["token"]) + call("GET", f"/api/v1/chats/{chat['id']}/messages", 404, token=eve["token"]) + send(eve, chat["id"], "not my chat", expected=404) + # Несуществующий чат выглядит так же, как чужой. + call("GET", f"/api/v1/chats/{uuid.uuid4()}", 404, token=eve["token"]) + print("PASS: foreign chat returns 404") + + +def test_empty_message(): + alice = new_user("alice") + chat = new_chat(alice) + for text in ("", " ", "\n\t"): + send(alice, chat["id"], text, expected=400) + send(alice, chat["id"], "я" * 4001, expected=400) + send(alice, chat["id"], "я" * 4000) + print("PASS: empty and too long messages return 400, 4000 chars is ok") + + +def test_pagination(): + alice, bob = new_user("alice"), new_user("bob") + chat = new_chat(alice, bob) + sent = [send(alice, chat["id"], f"Message {i}").json["id"] for i in range(7)] + + history, pages = read_history(bob, chat["id"], limit=2) + check(pages == 4, f"expected 4 pages, got {pages}") + check([m["id"] for m in history] == sent, "pages overlap, lose or reorder messages") + + other = new_chat(alice) + for i in range(3): + send(alice, other["id"], f"Other {i}") + first = call("GET", f"/api/v1/chats/{other['id']}/messages?limit=1", token=alice["token"]).json + # Курсор от другого чата и испорченный курсор — 400. + call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor={first['next_cursor']}", 400, token=alice["token"]) + call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor=broken", 400, token=alice["token"]) + print("PASS: pagination works across multiple pages, foreign cursor returns 400") + + +def test_chat_list_pagination(): + alice, bob = new_user("alice"), new_user("bob") + created = [new_chat(alice, bob, title=f"Chat {i}")["id"] for i in range(3)] + seen, cursor = [], None + while True: + query = "?limit=1" + (f"&cursor={cursor}" if cursor else "") + page = call("GET", "/api/v1/chats" + query, token=bob["token"]).json + seen += [chat["id"] for chat in page["items"]] + cursor = page["next_cursor"] + if cursor is None: + break + check(seen == created, "chat list pages are wrong") + print("PASS: chat list pagination") + + +def test_unicode(): + alice, bob = new_user("alice"), new_user("bob") + chat = new_chat(alice, bob, title="Чат 👋") + text = "Привет 👋 你好" + check(send(alice, chat["id"], text).json["text"] == text, "text changed on write") + history, _ = read_history(bob, chat["id"]) + check(history[-1]["text"] == text, "text changed on read") + print("PASS: unicode text is stored as is") + + +# ---------- lab2: пароль, вход, Bearer, logout ---------- + +def test_user_has_no_password(): + body = {"username": "np_" + uuid.uuid4().hex[:10], "display_name": "No password", "password": PASSWORD} + user = call("POST", "/api/v1/users", 201, body=body).json + check(set(user) == {"id", "username", "display_name", "created_at"}, f"unexpected fields: {set(user)}") + print("PASS: user response has no password or hash") + + +def test_password_rules(): + def register(password, expected): + body = {"username": "pw_" + uuid.uuid4().hex[:10], "display_name": "Password", "password": password} + call("POST", "/api/v1/users", expected, body=body) + + register("x" * 11, 400) + register("x" * 129, 400) + register(" " * 12, 400) + register("x" * 12, 201) + register("я" * 128, 201) + print("PASS: password length 12..128, blank password is rejected") + + +def test_login_gives_token(): + username = "lg_" + uuid.uuid4().hex[:10] + user = call("POST", "/api/v1/users", 201, + body={"username": username, "display_name": "Login", "password": PASSWORD}).json + reply = login(username, PASSWORD) + session = reply.json + check(session["token_type"] == "Bearer", "token_type must be Bearer") + check(session["user"] == user, "session user differs from registered user") + check(len(session["token"]) >= 43, "token is too short") + check(username not in session["token"] and user["id"] not in session["token"], "token is not opaque") + check(reply.headers.get("cache-control") == "no-store", "response with token must not be cached") + left = (parse_time(session["expires_at"]) - dt.datetime.now(dt.timezone.utc)).total_seconds() + check(290 < left <= 3600 + 5, f"unexpected session lifetime: {left:.0f} s") + me = call("GET", "/api/v1/users/me", token=session["token"]).json + check(me == user, "/users/me returned another user") + print("PASS: Basic login returns opaque Bearer token with expiry") + + +def test_wrong_password(): + user = new_user("wp") + wrong = login(user["username"], "Wrong-password-000", expected=401) + unknown = login("nobody_" + uuid.uuid4().hex[:8], PASSWORD, expected=401) + check(wrong.headers["www-authenticate"].lower().startswith("basic"), "login 401 must ask for Basic") + # Одинаковый ответ: по нему нельзя узнать, существует ли такой username. + check(wrong.json["error"]["message"] == unknown.json["error"]["message"], "different answers leak usernames") + print("PASS: wrong password and unknown user both return the same 401") + + +def test_malformed_basic(): + no_colon = base64.b64encode(b"just_username").decode() + for header in (None, "Basic", "Basic !!!", "Basic " + no_colon, "Bearer something"): + headers = {} if header is None else {"Authorization": header} + call("POST", "/api/v1/auth/sessions", 401, headers=headers) + print("PASS: malformed Basic header returns 401") + + +def test_password_with_colon_and_unicode(): + password = "пароль:с:двоеточием 👋" + user = new_user("colon", password=password) + call("GET", "/api/v1/users/me", token=user["token"]) + print("PASS: password with colon and unicode works") + + +def test_bearer_required(): + user = new_user("br") + for headers in ({}, {"Authorization": basic(user["username"], user["password"])}, + {"X-User-Id": user["id"]}, {"Authorization": "Bearer " + "A" * 43}, + {"Authorization": "Bearer"}, {"Authorization": "Token " + user["token"]}): + reply = call("GET", "/api/v1/users/me", 401, headers=headers) + check(reply.headers["www-authenticate"].lower().startswith("bearer"), "401 must ask for Bearer") + call("GET", "/api/v1/users/me", 200, headers={"Authorization": "bearer " + user["token"]}) + print("PASS: business endpoints need Bearer; Basic and X-User-Id give 401") + + +def test_x_user_id_ignored(): + alice, bob = new_user("alice"), new_user("bob") + me = call("GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": bob["id"]}).json + check(me["id"] == alice["id"], "X-User-Id changed the current user") + print("PASS: X-User-Id does not change the current user") + + +def test_auth_before_body(): + alice = new_user("alice") + chat = new_chat(alice) + # Без токена всегда 401, даже если тело неверное или чат чужой: сначала «кто ты». + call("POST", f"/api/v1/chats/{chat['id']}/messages", 401, raw=b"not json") + call("GET", f"/api/v1/chats/{uuid.uuid4()}", 401) + print("PASS: 401 comes before 400 and 404") + + +def test_logout(): + user = new_user("lo") + second = login(user["username"], user["password"]).json["token"] + call("DELETE", "/api/v1/auth/sessions/current", 204, token=user["token"]) + call("GET", "/api/v1/users/me", 401, token=user["token"]) + call("DELETE", "/api/v1/auth/sessions/current", 401, token=user["token"]) + call("GET", "/api/v1/users/me", 200, token=second) # другая сессия того же пользователя жива + again = login(user["username"], user["password"]).json["token"] + check(again != user["token"], "new login must give a new token") + call("GET", "/api/v1/users/me", 200, token=again) + print("PASS: logout revokes only the current session") + + +if __name__ == "__main__": + run_tests([ + test_duplicate_username, + test_invalid_json, + test_wrong_fields, + test_foreign_chat, + test_empty_message, + test_pagination, + test_chat_list_pagination, + test_unicode, + test_user_has_no_password, + test_password_rules, + test_login_gives_token, + test_wrong_password, + test_malformed_basic, + test_password_with_colon_and_unicode, + test_bearer_required, + test_x_user_id_ignored, + test_auth_before_body, + test_logout, + ]) diff --git a/student-tests/test_db.py b/student-tests/test_db.py new file mode 100644 index 0000000..29c4034 --- /dev/null +++ b/student-tests/test_db.py @@ -0,0 +1,92 @@ +"""Проверки на уровне базы данных. Запуск при запущенном стенде: + + python student-tests/test_db.py + +SQL выполняется в контейнере postgres через `docker compose exec postgres psql`. +1. Откат составной операции: чат с несуществующим участником -> 400, и в базе + не остаётся ни чата, ни участников, хотя строка чата успела вставиться. +2. База сама не даёт записать сообщение от не-участника (внешний ключ). +3. Пароль хранится как хеш Argon2id, а не как текст или быстрый хеш. +4. Миграции: после перезапуска API ничего не применяется повторно. +""" +import time +import uuid + +from common import call, check, compose, compose_output, new_user, psql, run_tests, wait_ready + + +def sql_value(sql): + code, output, error = psql(sql) + check(code == 0, f"psql failed: {error}") + return output + + +def test_create_chat_rolls_back(): + alice = new_user("rollback") + title = "rollback-" + uuid.uuid4().hex[:8] + inserted_before = int(sql_value("SELECT n_tup_ins FROM pg_stat_user_tables WHERE relname = 'chats'")) + + # Второй участник не существует: INSERT чата пройдёт, INSERT участника упадёт на внешнем ключе. + call("POST", "/api/v1/chats", 400, token=alice["token"], + body={"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}) + + left = sql_value(f"SELECT count(*) FROM chats WHERE title = '{title}'") + orphans = sql_value("SELECT count(*) FROM chats c WHERE NOT EXISTS " + "(SELECT 1 FROM chat_members m WHERE m.chat_id = c.id)") + # Статистика PostgreSQL считает и отменённые вставки; она обновляется с задержкой до ~1 с. + inserted_after = inserted_before + deadline = time.monotonic() + 15 + while inserted_after == inserted_before and time.monotonic() < deadline: + time.sleep(0.5) + inserted_after = int(sql_value("SELECT n_tup_ins FROM pg_stat_user_tables WHERE relname = 'chats'")) + print(f"chat with unknown member -> 400; rows with this title: {left}; chats without members: {orphans}; " + f"chats insert counter: {inserted_before} -> {inserted_after}") + check(left == "0" and orphans == "0", "chat row survived the failed transaction") + check(inserted_after > inserted_before, "the chat row was never inserted, rollback is not shown") + print("PASS: chat row was inserted and then rolled back together with members") + + +def test_message_needs_membership_in_db(): + code, _, error = psql("INSERT INTO messages (id, chat_id, sender_id, text) " + f"VALUES ('{uuid.uuid4()}', '{uuid.uuid4()}', '{uuid.uuid4()}', 'direct insert')") + print(f"direct INSERT of a message from a non-member -> exit code {code}: {error.splitlines()[0] if error else ''}") + check(code != 0 and "foreign key" in error, "database accepted a message from a non-member") + print("PASS: the database itself rejects a message from a non-member") + + +def test_password_is_argon2id(): + user = new_user("hash") + stored = sql_value(f"SELECT password_hash FROM users WHERE username = '{user['username']}'") + print(f"stored password: {stored[:31]}... (length {len(stored)})") + check(stored.startswith("$argon2id$") and user["password"] not in stored, "password is not an Argon2id hash") + print("PASS: password is stored as Argon2id hash") + + +def test_unique_username_constraint(): + constraint = sql_value("SELECT pg_get_constraintdef(oid) FROM pg_constraint " + "WHERE conrelid = 'users'::regclass AND contype = 'u'") + print(f"unique constraint on users: {constraint}") + check(constraint == "UNIQUE (username)", "no unique constraint on username") + print("PASS: username is unique in the database") + + +def test_migrations_are_not_repeated(): + versions = sql_value("SELECT string_agg(version, ',' ORDER BY version) FROM schema_migrations") + print(f"applied migrations: {versions}; restarting api") + compose("restart", "api") + wait_ready() + again = sql_value("SELECT string_agg(version, ',' ORDER BY version) FROM schema_migrations") + last_log = [line for line in compose_output("logs", "api").splitlines() if "Migrations applied" in line][-1] + print(f"after restart: {again}; log: {last_log.split('messenger.db: ')[-1]}") + check(again == versions and "none" in last_log, "migrations were applied again") + print("PASS: migrations are applied once, restart does nothing") + + +if __name__ == "__main__": + run_tests([ + test_create_chat_rolls_back, + test_message_needs_membership_in_db, + test_password_is_argon2id, + test_unique_username_constraint, + test_migrations_are_not_repeated, + ]) diff --git a/student-tests/test_expiry.py b/student-tests/test_expiry.py new file mode 100644 index 0000000..425bd5d --- /dev/null +++ b/student-tests/test_expiry.py @@ -0,0 +1,66 @@ +"""Истечение сессии при коротком SESSION_TTL_SECONDS. Запуск при запущенном стенде: + + python student-tests/test_expiry.py + +Тест сам пересоздаёт контейнер api с SESSION_TTL_SECONDS=2 +(docker compose up -d --no-deps --wait api, переменная берётся из окружения вместо .env), +проверяет, что токен работает до срока и даёт 401 после, а в конце возвращает +обычный TTL из .env. PostgreSQL и Redis при этом не трогаются. +""" +import datetime as dt +import os +import time + +from common import call, check, compose, login, new_user, redis_cli, run_tests, session_key, wait_ready + +SHORT_TTL = 2 + + +def restart_api(ttl=None): + env = dict(os.environ) + if ttl is None: + env.pop("SESSION_TTL_SECONDS", None) # значение снова из .env + else: + env["SESSION_TTL_SECONDS"] = str(ttl) + compose("up", "-d", "--no-deps", "--wait", "api", env=env) + wait_ready() + + +def seconds_left(expires_at): + moment = dt.datetime.fromisoformat(expires_at.replace("Z", "+00:00")) + return (moment - dt.datetime.now(dt.timezone.utc)).total_seconds() + + +def test_session_expires(): + print(f"recreating api with SESSION_TTL_SECONDS={SHORT_TTL}") + restart_api(SHORT_TTL) + try: + user = new_user("ttl") + session = login(user["username"], user["password"]).json + token = session["token"] + left = seconds_left(session["expires_at"]) + print(f"session issued, expires in {left:.2f} s; Redis TTL of the key: " + f"{redis_cli('pttl', session_key(token))} ms") + check(0 < left <= SHORT_TTL + 0.5, "short TTL instance must issue ~2 second sessions") + + call("GET", "/api/v1/users/me", 200, token=token) + print("before expiry: GET /users/me -> 200") + + time.sleep(max(0.0, seconds_left(session["expires_at"])) + 1.0) + call("GET", "/api/v1/users/me", 401, token=token) + exists = redis_cli("exists", session_key(token)) + print(f"after expiry: GET /users/me -> 401; key exists in Redis: {exists}") + check(exists == "0", "Redis must delete the expired session key") + finally: + print("recreating api with SESSION_TTL_SECONDS from .env") + restart_api() + + user = new_user("ttl_back") + left = seconds_left(login(user["username"], user["password"]).json["expires_at"]) + print(f"normal API again: new session expires in {left:.0f} s") + check(left > 300, "normal TTL was not restored") + print("PASS: session expires after SESSION_TTL_SECONDS and is rejected with 401") + + +if __name__ == "__main__": + run_tests([test_session_expires]) diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py new file mode 100644 index 0000000..bce8fe4 --- /dev/null +++ b/student-tests/test_failures.py @@ -0,0 +1,127 @@ +"""Отказ зависимости. Запуск при запущенном стенде: + + python student-tests/test_failures.py redis + python student-tests/test_failures.py postgres + python student-tests/test_failures.py (оба по очереди) + +Тест сам останавливает контейнер (docker compose stop), проверяет ответы API +и запускает контейнер обратно (docker compose start). Volumes не трогаются. + +redis — хранилище сессий недоступно: токен проверить нельзя, поэтому защищённые + запросы получают 503 (а не 200 и не «пропуск»), вход — 503; регистрация работает. + Второй сценарий: Redis убивается без корректной остановки (docker compose kill), + после запуска сессия на месте, потому что AOF пишется на диск до ответа «OK». +postgres — данные недоступны: бизнес-запросы 503, вход 503; без токена и с чужим + токеном — 401, то есть анонимов не пускаем. +После запуска контейнера прежний токен и подтверждённые сообщения на месте. +""" +import sys +import time +import uuid + +from common import PASSWORD, basic, call, check, compose, new_chat, new_user, read_history, run_tests, send, wait_ready + +FAKE_TOKEN = "A" * 43 + + +def timed(method, path, expected, **kwargs): + started = time.monotonic() + reply = call(method, path, expected, **kwargs) + return reply, (time.monotonic() - started) * 1000 + + +def prepare(): + alice, bob = new_user("alice"), new_user("bob") + chat = new_chat(alice, bob) + before = send(alice, chat["id"], "confirmed before outage").json + return alice, bob, chat, before + + +def recovered(alice, chat, before): + wait_ready() + history, _ = read_history(alice, chat["id"]) + check(before in history, "message confirmed before the outage is lost or changed") + call("GET", "/api/v1/users/me", 200, token=alice["token"]) + print("after start: the old token works, confirmed messages are in place") + + +def test_redis_down(): + alice, bob, chat, before = prepare() + print("stopping redis") + compose("stop", "redis") + try: + call("GET", "/health/live", 200) + _, ms = timed("GET", "/health/ready", 503) + print(f"/health/live -> 200, /health/ready -> 503 ({ms:.0f} ms)") + reply, ms = timed("GET", "/api/v1/users/me", 503, token=alice["token"]) + check(reply.json["error"]["code"] == "unavailable", "expected code unavailable") + print(f"valid token: GET /users/me -> 503 unavailable ({ms:.0f} ms), session cannot be checked") + call("GET", "/api/v1/chats", 503, token=FAKE_TOKEN) + print("unknown token -> 503, not 200: nobody is trusted without a check") + call("GET", "/api/v1/chats", 401) + print("no token -> 401") + call("POST", "/api/v1/auth/sessions", 503, headers={"Authorization": basic(alice["username"], PASSWORD)}) + print("login -> 503: there is nowhere to store the session") + call("POST", "/api/v1/users", 201, + body={"username": "rd_" + uuid.uuid4().hex[:10], "display_name": "x", "password": PASSWORD}) + print("registration -> 201: it needs only PostgreSQL") + finally: + print("starting redis") + compose("start", "redis") + recovered(alice, chat, before) + print("PASS: Redis outage gives 503 and does not let anyone in without a session check") + + +def test_redis_crash(): + alice = new_user("crash") + print("killing redis with SIGKILL (docker compose kill redis): no graceful shutdown") + compose("kill", "redis") + try: + # Обычно 503; 200 возможен, если Docker уже успел поднять Redis по restart policy. + status = call("GET", "/api/v1/users/me", (503, 200), token=alice["token"]).status + print(f"right after the crash: GET /users/me -> {status}") + finally: + print("starting redis") + compose("start", "redis") + wait_ready() + call("GET", "/api/v1/users/me", 200, token=alice["token"]) + print("after start: the session issued before the crash still works (AOF, appendfsync always)") + print("PASS: sessions survive a Redis crash, not only a clean restart") + + +def test_postgres_down(): + alice, bob, chat, before = prepare() + print("stopping postgres") + compose("stop", "postgres") + try: + call("GET", "/health/live", 200) + _, ms = timed("GET", "/health/ready", 503) + print(f"/health/live -> 200, /health/ready -> 503 ({ms:.0f} ms)") + for method, path, body in (("GET", "/api/v1/users/me", None), + ("GET", "/api/v1/chats", None), + ("GET", f"/api/v1/chats/{chat['id']}/messages", None), + ("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "will not be saved"})): + reply = call(method, path, 503, token=alice["token"], body=body) + check(reply.json["error"]["code"] == "unavailable", "expected code unavailable") + check("postgres" not in reply.data.decode().lower(), "error must not show database details") + print("valid token: users/me, chats, history, new message -> 503 unavailable, no details") + call("GET", "/api/v1/chats", 401) + call("GET", "/api/v1/chats", 401, token=FAKE_TOKEN) + print("no token -> 401, unknown token -> 401: anonymous users are not let in") + call("POST", "/api/v1/auth/sessions", 503, headers={"Authorization": basic(alice["username"], PASSWORD)}) + call("POST", "/api/v1/users", 503, + body={"username": "pd_" + uuid.uuid4().hex[:10], "display_name": "x", "password": PASSWORD}) + print("login -> 503, registration -> 503") + finally: + print("starting postgres") + compose("start", "postgres") + recovered(alice, chat, before) + print("PASS: PostgreSQL outage gives limited 503 errors and keeps anonymous users out") + + +if __name__ == "__main__": + target = sys.argv[1] if len(sys.argv) > 1 else "all" + tests = {"redis": [test_redis_down, test_redis_crash], "postgres": [test_postgres_down], + "all": [test_redis_down, test_redis_crash, test_postgres_down]} + check(target in tests, "usage: python student-tests/test_failures.py [redis|postgres]") + run_tests(tests[target]) diff --git a/student-tests/test_race.py b/student-tests/test_race.py new file mode 100644 index 0000000..c1af720 --- /dev/null +++ b/student-tests/test_race.py @@ -0,0 +1,67 @@ +"""Проверка гонок. Запуск при запущенном стенде: + + python student-tests/test_race.py + +1. 10 клиентов одновременно отправляют по 10 сообщений в один чат (тест из lab1): + в истории ровно 100 сообщений, все id уникальны, ни один текст не потерян. +2. 20 клиентов одновременно регистрируют ОДИН И ТОТ ЖЕ username: + ровно один получает 201, остальные 409. Защищает уникальный индекс в PostgreSQL, + а не проверка «есть ли такой» в коде. +""" +import threading +import time +import uuid +from concurrent.futures import ThreadPoolExecutor + +from common import PASSWORD, call, check, new_chat, new_user, read_history, run_tests, send + +CLIENTS = 10 +MESSAGES_PER_CLIENT = 10 +REGISTRATIONS = 20 + + +def test_concurrent_messages(): + users = [new_user(f"race{i}") for i in range(CLIENTS)] + chat = new_chat(*users, title="race") + barrier = threading.Barrier(CLIENTS) # все клиенты стартуют одновременно + + def client(index): + barrier.wait() + for n in range(MESSAGES_PER_CLIENT): + send(users[index], chat["id"], f"client-{index}-message-{n}") + + started = time.monotonic() + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + list(pool.map(client, range(CLIENTS))) # list() пробрасывает ошибки из потоков + elapsed = time.monotonic() - started + + history, pages = read_history(users[0], chat["id"], limit=30) + ids = {message["id"] for message in history} + expected = {f"client-{i}-message-{n}" for i in range(CLIENTS) for n in range(MESSAGES_PER_CLIENT)} + print(f"sent {CLIENTS * MESSAGES_PER_CLIENT} messages from {CLIENTS} clients in {elapsed:.2f} s; " + f"read {len(history)} in {pages} pages, unique ids: {len(ids)}") + check(len(history) == CLIENTS * MESSAGES_PER_CLIENT, "wrong number of messages") + check(len(ids) == len(history), "duplicate message ids") + check({message["text"] for message in history} == expected, "lost or changed message texts") + print("PASS: 100 concurrent messages from 10 clients, no losses and no duplicates") + + +def test_concurrent_registration(): + username = "race_" + uuid.uuid4().hex[:10] + barrier = threading.Barrier(REGISTRATIONS) + + def register(index): + barrier.wait() + body = {"username": username, "display_name": f"Client {index}", "password": PASSWORD} + return call("POST", "/api/v1/users", (201, 409), body=body).status + + with ThreadPoolExecutor(max_workers=REGISTRATIONS) as pool: + statuses = list(pool.map(register, range(REGISTRATIONS))) + created, conflicts = statuses.count(201), statuses.count(409) + print(f"{REGISTRATIONS} parallel registrations of one username: 201 x{created}, 409 x{conflicts}") + check(created == 1 and conflicts == REGISTRATIONS - 1, "exactly one registration must win") + print("PASS: concurrent registration created exactly one user") + + +if __name__ == "__main__": + run_tests([test_concurrent_messages, test_concurrent_registration])