diff --git a/.dockerignore b/.dockerignore index bc16e556..22269a65 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,19 @@ __pycache__ node_modules evidence .DS_Store +# в образ идут только requirements.txt, src/ и migrations/ +tests +student-tests +contracts +examples +scripts +infra +*.md +Makefile +Dockerfile* +compose*.yaml +lab.json +requirements-dev.txt +.gitignore +.idea +.vscode diff --git a/.env.example b/.env.example index 714c8076..44cc7c5b 100644 --- a/.env.example +++ b/.env.example @@ -7,5 +7,18 @@ 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 +SESSION_STORE=redis CACHE_URL_FILE=/run/secrets/cache_url +# info / debug / warning +LOG_LEVEL=info +# Сколько секунд после SIGTERM ждать незавершённые запросы (не больше 10). +SHUTDOWN_TIMEOUT=8 +# Пул соединений с PostgreSQL и таймауты в секундах. +DB_POOL_MIN_SIZE=2 +DB_POOL_MAX_SIZE=10 +DB_POOL_TIMEOUT=3 +DB_CONNECT_TIMEOUT=3 +DB_STATEMENT_TIMEOUT=5 +# Пул соединений с Redis и таймаут операций в секундах. +CACHE_POOL_MAX_SIZE=20 +CACHE_TIMEOUT=2 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..84e4ca1a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,34 @@ +FROM python:3.13.16-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /app + +# сначала зависимости: слой переиспользуется, пока не меняется requirements.txt +COPY requirements.txt . +RUN pip install -r requirements.txt + +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app + +COPY src/ . +COPY migrations/ migrations/ + +USER 10001:10001 + +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=5s --start-period=10s --retries=3 \ + CMD ["python", "healthcheck.py"] + +STOPSIGNAL SIGTERM + +# exec-форма: python запускается как PID 1 и сам получает SIGTERM +CMD ["python", "main.py"] diff --git a/Makefile b/Makefile index 9ecb223e..4ec646ca 100644 --- a/Makefile +++ b/Makefile @@ -2,9 +2,10 @@ PYTHON ?= python3 BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= +COMPOSE = docker compose --env-file .env TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence env up down clean student-test test-failures explain help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +25,27 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +env: + ./scripts/init-env.sh + +up: env + $(COMPOSE) up -d --build + BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh + +down: + $(COMPOSE) --profile test down + +# удаляет контейнеры вместе с данными PostgreSQL и Redis +clean: + $(COMPOSE) --profile test down -v + +student-test: + BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v + +# останавливает и запускает redis/postgres, поднимает второй API на порту 8081 +test-failures: + BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests/failures -v + +explain: + ./scripts/explain_history.sh diff --git a/REPORT.md b/REPORT.md index e42f2b05..13448a7b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,239 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Мусаев Абдул-Хамид Рамзанович, БВТ-2303 +- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не заявлен +- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/27 +- Использованные источники, библиотеки и помощь ИИ: + - библиотеки: FastAPI 0.143.0, Uvicorn 0.54.0, psycopg 3.3.6 и psycopg-pool 3.3.3, redis-py 8.1.0, argon2-cffi 25.1.0 (полный список с версиями в `requirements.txt`); + - источники: документация PostgreSQL (транзакции, EXPLAIN), Redis persistence, psycopg, Docker Compose, RFC 7617, `contracts/README.md`; + - помощь ИИ: ИИ-ассистент использовался во вспомогательных целях. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker с Compose v2 (проверено на Docker 29.3.0, Compose 5.1.0), `make`, `openssl`, `curl` и Python 3.9+ на хосте для тестов. Сервер, PostgreSQL и Redis работают только в контейнерах. + +```sh +make up # создаёт .env с паролями, собирает образ, поднимает стенд и ждёт /health/ready + +make check # структура skeleton +make test # публичный smoke +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make student-test # собственные тесты API +make test-failures # истечение сессии, остановка Redis и PostgreSQL, откат транзакции +make explain # 60 000 синтетических сообщений и планы запросов +python3 scripts/sigterm_check.py + +make down # остановить и удалить контейнеры, данные остаются в volumes +make clean # то же и удалить volumes: намеренное удаление учебных данных +``` + +То же без `make`: + +```sh +./scripts/init-env.sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +./scripts/wait-ready.sh +``` + +`scripts/init-env.sh` копирует `.env.example` в `.env` и дописывает в него случайные пароли PostgreSQL и Redis (`openssl rand`). Файл `.env` исключён из Git. Повторный запуск скрипта пароли не меняет: пароль PostgreSQL задаётся один раз при создании volume, поэтому после `make clean` нужно либо оставить старый `.env`, либо удалить его и создать заново. + +Миграции отдельной команды не требуют: при `up` одноразовый контейнер `migrate` применяет их до старта API. Повторить вручную можно командой `docker compose --env-file .env run --rm migrate`. + +`make test-failures` сам останавливает и запускает `redis` и `postgres` и поднимает второй экземпляр API на порту 8081, поэтому запускать его нужно только на учебном стенде. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──HTTP──> api (uvicorn + FastAPI) ──┬──> postgres: пользователи, чаты, участники, сообщения + └──> redis: сессии с TTL +``` + +### Роли и сервисы + +| Роль | Сервис compose | Образ | Готовность | Volume | Сеть и порт | Как получает секреты | +| --- | --- | --- | --- | --- | --- | --- | +| api | `api` | собирается из `Dockerfile` на `python:3.13.16-slim-bookworm` | HEALTHCHECK → `/health/ready` | нет, состояния не хранит | опубликован `127.0.0.1:8080` | файлы `/run/secrets/database_url`, `/run/secrets/cache_url` | +| миграции | `migrate` | тот же образ, команда `python migrate.py` | одноразовый, код выхода 0 | нет | только внутренняя сеть | файл `/run/secrets/database_url` | +| postgres | `postgres` | `postgres:17.11-alpine` | `pg_isready` | `pgdata` | только внутренняя сеть, 5432 | `POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password` | +| redis | `redis` | `redis:7.4.11-alpine` | `redis-cli ping` | `redisdata` | только внутренняя сеть, 6379 | `--requirepass` из `/run/secrets/redis_password` | + +Секреты описаны в `compose.yaml` как `secrets` с источником из переменных `.env`. Compose кладёт их в контейнеры файлами, в окружении контейнеров паролей нет (проверка в `evidence/07-containers.txt`). Наружу опубликован только порт API. + +### Файлы + +| Файл | Что в нём | +| --- | --- | +| `migrations/0001_init.sql` | таблицы, ключи, ограничения, индексы | +| `src/migrate.py` | применяет миграции по порядку, ведёт таблицу `schema_migrations` | +| `src/store.py` | все SQL-запросы и пул соединений | +| `src/sessions.py` | сессии в Redis | +| `src/security.py` | hash пароля (Argon2id), разбор заголовков Basic и Bearer | +| `src/main.py` | endpoint, middleware, обработка ошибок | +| `src/schemas.py`, `src/errors.py`, `src/config.py` | валидация JSON, формат ошибки, настройки | + +### Схема данных + +- `users`: `id` (PK), `username` (UNIQUE и CHECK по шаблону), `display_name`, `password_hash`, `created_at`. +- `chats`: `id` (PK), `title`, `created_at`. +- `chat_members`: PK `(chat_id, user_id)`, внешние ключи на `chats` и `users`, `position` — порядок участника в запросе. Индекс `(user_id, chat_id)` для списка чатов пользователя. +- `messages`: `id` (PK), внешние ключи `chat_id` и `sender_id`, `text` (CHECK 1–4000 символов), `created_at`. Индекс `(chat_id, created_at, id)` для истории. + +`id` и `created_at` назначает PostgreSQL (`gen_random_uuid()`, `now()`). Ограничения длины продублированы в CHECK, чтобы неверные данные не попали в БД даже в обход приложения. + +### Транзакционные границы + +Каждый метод `Store` берёт одно соединение из пула и выполняется в одной транзакции: `with pool.connection()` делает COMMIT при выходе и ROLLBACK при исключении. + +- **Регистрация** — один `INSERT`. Уникальность username проверяет сама БД; нарушение ограничения превращается в 409. Поэтому два одновременных запроса не создадут двух пользователей. +- **Создание чата** — составная операция: `INSERT` в `chats`, затем `INSERT` всех участников в `chat_members`. Если участника нет, срабатывает внешний ключ, транзакция откатывается вместе с уже вставленным чатом, клиент получает 400. +- **Отправка сообщения** — проверка членства и `INSERT` в одной транзакции. +- Ответ 201 отправляется только после COMMIT. PostgreSQL работает с настройками по умолчанию (`fsync=on`, `synchronous_commit=on`), то есть подтверждённая запись уже на диске. + +Все значения попадают в запросы только параметрами `%s`, строки SQL из пользовательских данных не собираются. + +### Аутентификация + +- Пароль хешируется Argon2id (`argon2-cffi`, 19 МиБ памяти, 2 прохода, 1 поток — минимальные параметры из рекомендаций OWASP). В БД хранится только hash. +- `POST /api/v1/auth/sessions` принимает только `Authorization: Basic`. Неизвестный username и неверный пароль дают одинаковый 401 с `WWW-Authenticate: Basic`. Если пользователя нет, пароль всё равно сверяется с заранее посчитанным hash, чтобы время ответа не выдавало существование username. +- Токен — `secrets.token_urlsafe(32)`, 256 бит случайности. Остальные endpoint принимают только `Authorization: Bearer`; `X-User-Id` не читается, Basic на бизнес-запросах даёт 401. +- Проверка токена выполняется до валидации параметров и тела и до обращения к чату: сначала аутентификация, потом доступ к конкретному ресурсу. + +### Роль Redis + +Redis — **единственное хранилище сессий**. PostgreSQL о сессиях ничего не знает; источник истины для пользователей, чатов и сообщений — PostgreSQL, для сессий — Redis. + +- Ключ `session:`, значение — id пользователя. Сам токен в Redis не хранится, поэтому по дампу нельзя получить рабочий токен. +- **Expiry**: ключ записывается командой `SET ... EX SESSION_TTL_SECONDS`, срок отсчитывается от входа и запросами не продлевается. Истёкший ключ Redis удаляет сам. +- **Инвалидация**: logout — это `DEL` ключа текущей сессии. Другие сессии того же пользователя остаются. +- **Persistence**: включён AOF с `appendfsync always`, данные лежат в volume `redisdata`. Сессия переживает перезапуск Redis, а оставшийся TTL при этом не увеличивается (`evidence/04-redis-sessions.txt`: 3591 с до перезапуска, 3583 с после). +- Политика вытеснения — `noeviction`: при нехватке памяти Redis откажет в записи новой сессии, но не удалит действующие. +- После `FLUSHALL` или удаления volume `redisdata` все сессии пропадают: каждый токен получит 401, пользователям нужно войти заново. Данные в PostgreSQL при этом не страдают. + +### Пул соединений и таймауты + +| Что | Значение | Где задаётся | +| --- | --- | --- | +| соединений с PostgreSQL | от 2 до 10 | `DB_POOL_MIN_SIZE`, `DB_POOL_MAX_SIZE` | +| ожидание свободного соединения | 3 с | `DB_POOL_TIMEOUT` | +| установка соединения с PostgreSQL | 3 с | `DB_CONNECT_TIMEOUT` | +| выполнение одного запроса | 5 с (`statement_timeout`) | `DB_STATEMENT_TIMEOUT` | +| соединений с Redis | до 20 | `CACHE_POOL_MAX_SIZE` | +| операция с Redis и ожидание соединения | 2 с | `CACHE_TIMEOUT` | + +Перед выдачей из пула соединение с PostgreSQL проверяется, поэтому после перезапуска БД запросы не получают мёртвые соединения. + +### Поведение при отказе зависимостей + +- **Redis недоступен**: проверить токен нечем, поэтому любой запрос с токеном получает 503 `unavailable`. Запрос не выполняется ни от имени владельца токена, ни как анонимный. Запрос без токена по-прежнему получает 401. +- **PostgreSQL недоступен**: запросы, которым нужны данные, получают 503 не позже чем через 3 секунды (ожидание соединения из пула). +- `/health/ready` проверяет обе зависимости (`SELECT 1` и `PING`) и отвечает 503 в общем формате ошибки, если хотя бы одна недоступна. `/health/live` от них не зависит. +- API стартует, даже если БД ещё не поднялась, и отвечает 503 до её появления. + +### Пагинация и порядок + +Запрос истории: + +```sql +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +ORDER BY created_at, id LIMIT $4 +``` + +Cursor — base64 от JSON `[область, created_at, id]` последней выданной записи; область привязывает его к конкретному чату или к списку чатов конкретного пользователя. Разбор строгий: посторонние символы в base64 не пропускаются, внутри должен быть список ровно из трёх строк, время — в формате сервера, id — UUID в каноническом виде; затем cursor кодируется заново и сравнивается с присланным. Любое отклонение даёт 400 `invalid_request`. Запрашивается `limit + 1` строк: лишняя строка показывает, есть ли следующая страница. + +**Семантика при конкурентных вставках.** `created_at` — это `now()` PostgreSQL, то есть время начала транзакции. Две параллельные транзакции могут зафиксироваться не в порядке своих `created_at`. Поэтому сообщение с чуть более ранним временем может появиться в истории уже после того, как клиент прошёл это место по cursor, и при обходе вперёд он его не увидит (окно — миллисекунды, длительность транзакции вставки). Повторов при обходе нет. Чтение после записи выполняется: ответ 201 приходит после COMMIT, следующий `GET` это сообщение видит. + +### Соответствие переменных окружения + +| Переменная в `.env` | По умолчанию | Что делает | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT` | `0.0.0.0`, `8080` | адрес сервера; в compose заданы жёстко, из `.env` не читаются | +| `APP_ENV` | `lab` | выводится в лог при старте | +| `SESSION_TTL_SECONDS` | `3600` | срок жизни сессии | +| `SESSION_STORE` | `redis` | поддерживается только `redis`, с другим значением сервер не стартует | +| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | `/run/secrets/...` | пути к файлам со строками подключения; в compose заданы жёстко | +| `LOG_LEVEL`, `SHUTDOWN_TIMEOUT` | `info`, `8` | как в lab1 | +| `DB_POOL_*`, `DB_*_TIMEOUT`, `CACHE_*` | см. таблицу выше | пул и таймауты | +| `POSTGRES_PASSWORD`, `REDIS_PASSWORD`, `DATABASE_URL`, `CACHE_URL` | создаёт `init-env.sh` | источник compose-секретов; в контейнер `api` попадают только файлами | + +### Что перенесено из lab1 и что изменено + +Перенесены: структура `src/`, формат ошибок и `X-Request-Id`, валидация JSON, cursor-пагинация, логирование без содержимого, Dockerfile (непривилегированный пользователь, healthcheck, корректная остановка по SIGTERM), собственные тесты. + +Исправлено по замечаниям: + +- (к lab1) Некорректный cursor мог вернуть 200 (посторонние символы в base64, неканоничные время и UUID); теперь он всегда даёт 400, проверка — тест `test_cursor_format_is_checked`. +- (к lab2) `POST /api/v1/auth/sessions` с заголовком `Authorization: Basic é` возвращал 500: при не-ASCII символах `b64decode` бросает обычный `ValueError`, а перехватывались только `binascii.Error` и `UnicodeDecodeError`. Теперь в `parse_basic` (`src/security.py`) перехватывается `ValueError`, который покрывает все три случая, и ответ — 401 с `WWW-Authenticate: Basic`. Негативные тесты: `test_garbage_after_basic_is_401_not_500` (11 вариантов значения после `Basic`) и `test_garbage_token_is_401_not_500` (то же для Bearer). + +Изменено: хранилище в памяти заменено на PostgreSQL; `X-User-Id` заменён на пароль, Basic и Bearer; добавлены миграции, Redis, compose, проверка зависимостей в `/health/ready` и ответ 503. Строки теперь проверяются ещё и на символ NUL, который PostgreSQL не хранит. Контракт и публичные тесты не менялись. ## Доказательства критериев +Стенд: Apple M3 Pro, 11 CPU, 18 ГБ RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0, без ограничений CPU/RAM для контейнеров. Все файлы получены из чистого clone на пустых volumes, commit `6473fd0`. Файл `evidence/02-student-tests.txt` получен заново после исправлений по замечаниям (проверка cursor, разбор заголовка Basic). + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/01-up-and-smoke.txt` | +| 3: данные и сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`; у контейнеров `postgres`, `redis`, `api` новое время старта, volumes те же | `evidence/03-persistence.txt` | +| 3: таблицы, ключи, уникальность username, миграции с нуля | `make up` на пустом volume | `применена: 0001_init.sql`, smoke проходит | `evidence/01-up-and-smoke.txt`, `migrations/0001_init.sql` | +| 3: создание чата атомарно | `make test-failures` (`test_transactions.py`) | после неудачного создания в `chats` 0 строк, после удачного — чат и 2 участника | `evidence/05-failures.txt` | +| 3: Basic только на входе, Bearer на остальном, срок жизни, отзыв, `X-User-Id` не даёт доступ | `make student-test` (`test_auth.py`) | 17 тестов `ok` | `evidence/02-student-tests.txt` | +| 3: пароли хешируются KDF | `test_password_is_stored_as_argon2id_hash` | hash в БД начинается с `$argon2id$` | `evidence/05-failures.txt` | +| 3: миграции повторяются без дублирования | `docker compose run --rm migrate` | `уже применена: 0001_init.sql`, в `schema_migrations` одна строка, число строк в таблицах не изменилось | `evidence/03-persistence.txt`, `evidence/05-failures.txt` | +| 3: secrets и volumes не в Git | `git ls-files \| grep -E "^\.env$\|secrets"` | пусто | `evidence/07-containers.txt` | +| 4: Redis реально используется для сессий с TTL и persistence | `redis-cli CONFIG GET`, `TTL`, `docker compose restart redis` | `appendonly yes`, `appendfsync always`; ключ пережил перезапуск, TTL 3591 → 3583 | `evidence/04-redis-sessions.txt` | +| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/sessions.py`; остановка зависимостей | 503 через 0,01 с без Redis и через 3,0 с без PostgreSQL | `evidence/05-failures.txt` | +| 4: гонка регистрации одного username | `test_username_race_creates_one_row`, `test_same_username_registered_once` | один ответ 201 и девять 409, в `users` одна строка | `evidence/05-failures.txt`, `evidence/02-student-tests.txt` | +| 4: rollback составной операции | `test_chat_with_unknown_member_is_rolled_back` | 400, в `chats` 0 строк с этим названием, участников без чата нет | `evidence/05-failures.txt` | +| 4: индекс истории обоснован EXPLAIN на ≥10 000 сообщений | `make explain` | Index Scan, 8 буферов на страницу в любом месте истории | `evidence/06-explain.txt` | +| 4: автоматическая проверка expiry при коротком TTL | `test_expiry.py`, API с `SESSION_TTL_SECONDS=2` | через 3 с токен получает 401, запросы срок не продлевают | `evidence/05-failures.txt` | +| 4: автоматическая проверка logout и неверного пароля | `test_auth.py` | после logout 401, вторая сессия работает; неверный пароль — 401 | `evidence/02-student-tests.txt` | +| 4: недоступность Redis и БД | `test_dependencies.py` | 503 `unavailable` за ограниченное время, аноним получает 401, после восстановления прежний токен и данные на месте | `evidence/05-failures.txt` | +| Возможности lab1: непривилегированный пользователь, закреплённые версии, SIGTERM | `docker compose exec api id`, `scripts/sigterm_check.py` | `uid=10001(app)`; начатый запрос получил 201, выход за 1,45 с с кодом 0 | `evidence/07-containers.txt`, `evidence/08-sigterm.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Нагрузочное исследование (трек 5) не проводилось. + +### Индекс истории + +Гипотеза: индекс `(chat_id, created_at, id)` позволяет читать любую страницу истории за число обращений к диску, не зависящее от длины истории и от положения страницы. + +Методика: `scripts/seed_history.sql` создаёт 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате, остальные 50 000 поровну в 20 других; затем `ANALYZE`. `scripts/explain_history.sql` выполняет `EXPLAIN (ANALYZE, BUFFERS)` для четырёх запросов с `LIMIT 51` (страница 50 плюс одна строка). Данные небольшие и целиком в кэше, поэтому сравнивать нужно число буферов, а не миллисекунды. + +| Запрос | План | Буферов | Время выполнения | +| --- | --- | --- | --- | +| первая страница | Index Scan по `messages_chat_history_idx` | 8 | 0,025 мс | +| страница после 5000-го сообщения, keyset | Index Scan, условие на `(created_at, id)` внутри Index Cond | 8 | 0,034 мс | +| та же страница через `OFFSET 5000` | Index Scan, прочитано 5051 строка | 491 | 0,469 мс | +| keyset без индекса | Seq Scan всей таблицы (отброшено 55 140 строк) и сортировка | 862 | 2,266 мс | + +Вывод: с индексом и keyset страница из середины стоит столько же, сколько первая, сортировка не нужна. OFFSET читает все пропущенные строки, и стоимость растёт с номером страницы. Без индекса каждая страница читает всю таблицу, включая чужие чаты. + +Ограничение измерения: одна таблица на 60 000 строк, один запуск, всё в памяти. Для вывода о реальной нагрузке этого мало. Четвёртый запрос выполняет `DROP INDEX` внутри транзакции с `ROLLBACK`: на это время таблица `messages` заблокирована, поэтому скрипт годится только для учебного стенда. + +### Отказы | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose restart postgres redis api` | данные и сессия на месте | прежний токен читает прежние сообщения | готов через несколько секунд, потерь нет | +| `docker compose stop redis` | запросы с токеном не выполняются | 503 за 0,01 с; без токена 401; `/health/ready` 503, `/health/live` 200 | после `start redis` прежний токен работает, сообщение, отправленное во время отказа, не записано | +| `docker compose stop postgres` | запросы к данным не выполняются | 503 за 3,0 с; без токена 401 | после `start postgres` данные на месте, запись снова работает | +| сессия с TTL 2 с | через 2 с токен недействителен | через 3 с 401, logout с ним тоже 401, новый вход работает | — | +| чат с несуществующим участником | ничего не создаётся | 400, в `chats` и `chat_members` следов нет | — | +| 10 одновременных регистраций одного username | один пользователь | один 201, девять 409, одна строка | — | +| SIGTERM процессу API | начатый запрос завершится | 201, новые соединения не принимаются, выход за 1,45 с | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один экземпляр API, один PostgreSQL, один Redis на одном хосте. Отказ хоста, диска или любого из хранилищ не переживается, резервных копий нет. +- При недоступном Redis не работает ни один запрос с токеном: запасного пути проверки сессии нет. Это осознанный выбор в пользу простоты и того, что отозванная сессия не может «ожить» из другого хранилища. +- `appendfsync always` делает каждую запись сессии синхронной записью на диск. Для учебного стенда это незаметно, под нагрузкой вход станет узким местом. +- Нет ограничения числа попыток входа и числа сессий на пользователя, код 429 не используется. +- Порядок истории при параллельных вставках описан выше: возможен пропуск сообщения при обходе вперёд в окне длительности транзакции. +- Если JSON синтаксически сломан, FastAPI отвечает 400 раньше, чем проверяется токен. На доступ к данным это не влияет. +- При недоступной БД ответ 503 приходит через 3 секунды, а не сразу: столько запрос ждёт соединение из пула. +- Пароли в `.env` лежат открытым текстом на диске разработчика (права 600). Для локального стенда с синтетическими данными это допустимо. +- `make explain` оставляет в БД синтетические чаты и 60 000 сообщений; убрать их можно только `make clean`. +- Проверено на одном стенде (macOS, Docker Desktop). На Linux не запускалось. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..4dbaa7ab --- /dev/null +++ b/compose.yaml @@ -0,0 +1,125 @@ +name: mtusi-messenger-lab2 + +# Настройки и секреты берутся из .env (создаёт scripts/init-env.sh, в Git не попадает). +# Секреты доходят до контейнеров только файлами в /run/secrets, в переменных окружения контейнеров их нет. + +x-app: &app + build: . + image: mtusi-messenger:lab2 + +x-app-env: &app-env + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + LOG_LEVEL: ${LOG_LEVEL:-info} + SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-redis} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-2} + DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10} + DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3} + DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-3} + DB_STATEMENT_TIMEOUT: ${DB_STATEMENT_TIMEOUT:-5} + CACHE_POOL_MAX_SIZE: ${CACHE_POOL_MAX_SIZE:-20} + CACHE_TIMEOUT: ${CACHE_TIMEOUT:-2} + +services: + postgres: + image: postgres:17.11-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + redis: + image: redis:7.4.11-alpine + # сессии хранятся только здесь, поэтому включён AOF с fsync на каждую запись; + # запуск через docker-entrypoint.sh, чтобы процесс работал от пользователя redis, а не от root + command: + - sh + - -c + - exec docker-entrypoint.sh redis-server --appendonly yes --appendfsync always --requirepass "$$(cat /run/secrets/redis_password)" + secrets: + - redis_password + volumes: + - redisdata:/data + healthcheck: + test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$(cat /run/secrets/redis_password)\" ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + migrate: + <<: *app + command: ["python", "migrate.py"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + restart: "no" + + api: + <<: *app + environment: *app-env + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8080:8080" + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + restart: unless-stopped + + # тот же сервер с TTL сессии 2 секунды, нужен только тесту истечения: + # docker compose --profile test up -d api-short-ttl + api-short-ttl: + <<: *app + profiles: ["test"] + environment: + <<: *app-env + SESSION_TTL_SECONDS: "2" + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8081:8080" + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + +volumes: + pgdata: + redisdata: + +secrets: + postgres_password: + environment: POSTGRES_PASSWORD + redis_password: + environment: REDIS_PASSWORD + database_url: + environment: DATABASE_URL + cache_url: + environment: CACHE_URL diff --git a/evidence/01-up-and-smoke.txt b/evidence/01-up-and-smoke.txt new file mode 100644 index 00000000..1a9770e5 --- /dev/null +++ b/evidence/01-up-and-smoke.txt @@ -0,0 +1,72 @@ +# Запуск из чистого clone на пустых volumes, публичный smoke +# дата: 2026-10-08T15:55Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ ./scripts/init-env.sh +пароли записаны в .env + +$ docker compose --env-file .env config --quiet + +$ docker compose --env-file .env up -d --build + Image mtusi-messenger:lab2 Built + Image mtusi-messenger:lab2 Built + Network mtusi-messenger-lab2_default Creating + Network mtusi-messenger-lab2_default Created + Volume mtusi-messenger-lab2_redisdata Creating + Volume mtusi-messenger-lab2_redisdata Created + Volume mtusi-messenger-lab2_pgdata Creating + Volume mtusi-messenger-lab2_pgdata Created + Container mtusi-messenger-lab2-postgres-1 Creating + Container mtusi-messenger-lab2-redis-1 Creating + Container mtusi-messenger-lab2-postgres-1 Created + Container mtusi-messenger-lab2-redis-1 Created + Container mtusi-messenger-lab2-migrate-1 Creating + Container mtusi-messenger-lab2-migrate-1 Created + Container mtusi-messenger-lab2-api-1 Creating + Container mtusi-messenger-lab2-api-1 Created + Container mtusi-messenger-lab2-postgres-1 Starting + Container mtusi-messenger-lab2-redis-1 Starting + Container mtusi-messenger-lab2-postgres-1 Started + Container mtusi-messenger-lab2-postgres-1 Waiting + Container mtusi-messenger-lab2-redis-1 Started + Container mtusi-messenger-lab2-postgres-1 Healthy + Container mtusi-messenger-lab2-migrate-1 Starting + Container mtusi-messenger-lab2-migrate-1 Started + Container mtusi-messenger-lab2-migrate-1 Waiting + Container mtusi-messenger-lab2-redis-1 Waiting + Container mtusi-messenger-lab2-migrate-1 Exited + Container mtusi-messenger-lab2-redis-1 Healthy + Container mtusi-messenger-lab2-api-1 Starting + Container mtusi-messenger-lab2-api-1 Started + +$ ./scripts/wait-ready.sh +готов: http://localhost:8080 + +$ docker compose --env-file .env ps -a +SERVICE IMAGE STATE STATUS +api mtusi-messenger:lab2 running Up 1 second (health: starting) +migrate mtusi-messenger:lab2 exited Exited (0) 1 second ago +postgres postgres:17.11-alpine running Up 7 seconds (healthy) +redis redis:7.4.11-alpine running Up 7 seconds (healthy) + +$ docker compose --env-file .env logs migrate +migrate-1 | применена: 0001_init.sql + +$ curl -s -i http://localhost:8080/health/ready +HTTP/1.1 200 OK +date: Thu, 08 Oct 2026 15:55:10 GMT +server: uvicorn +content-length: 15 +content-type: application/json +x-request-id: c5fc87a41bdc4cfaa665cddb6d79a6c0 + +{"status":"ok"} + +$ make check +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. + +$ make test +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. + diff --git a/evidence/02-student-tests.txt b/evidence/02-student-tests.txt new file mode 100644 index 00000000..43ae9909 --- /dev/null +++ b/evidence/02-student-tests.txt @@ -0,0 +1,76 @@ +# Собственные тесты API +# дата: 2026-10-09T21:41Z, после исправлений по замечаниям (проверка cursor, разбор заголовка Basic) +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ make student-test +BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests -v +test_blank_title (test_access.CreateChatTest.test_blank_title) ... ok +test_creator_must_be_member (test_access.CreateChatTest.test_creator_must_be_member) ... ok +test_duplicate_members (test_access.CreateChatTest.test_duplicate_members) ... ok +test_empty_members (test_access.CreateChatTest.test_empty_members) ... ok +test_failed_create_leaves_no_chat (test_access.CreateChatTest.test_failed_create_leaves_no_chat) ... ok +test_unknown_member (test_access.CreateChatTest.test_unknown_member) ... ok +test_bad_chat_id (test_access.ForeignChatTest.test_bad_chat_id) ... ok +test_chat_is_not_listed_for_outsider (test_access.ForeignChatTest.test_chat_is_not_listed_for_outsider) ... ok +test_foreign_chat_looks_like_missing_chat (test_access.ForeignChatTest.test_foreign_chat_looks_like_missing_chat) ... ok +test_members_can_read_and_write (test_access.ForeignChatTest.test_members_can_read_and_write) ... ok +test_outsider_gets_404_everywhere (test_access.ForeignChatTest.test_outsider_gets_404_everywhere) ... ok +test_outsider_message_is_not_saved (test_access.ForeignChatTest.test_outsider_message_is_not_saved) ... ok +test_basic_is_not_accepted_on_business_endpoints (test_auth.BearerTest.test_basic_is_not_accepted_on_business_endpoints) ... ok +test_garbage_token_is_401_not_500 (test_auth.BearerTest.test_garbage_token_is_401_not_500) ... ok +test_no_token (test_auth.BearerTest.test_no_token) ... ok +test_token_is_checked_before_anything_else (test_auth.BearerTest.test_token_is_checked_before_anything_else) ... ok +test_unknown_tokens (test_auth.BearerTest.test_unknown_tokens) ... ok +test_x_user_id_does_not_change_identity (test_auth.BearerTest.test_x_user_id_does_not_change_identity) ... ok +test_x_user_id_gives_no_access (test_auth.BearerTest.test_x_user_id_gives_no_access) ... ok +test_colon_and_unicode_in_password (test_auth.LoginTest.test_colon_and_unicode_in_password) ... ok +test_garbage_after_basic_is_401_not_500 (test_auth.LoginTest.test_garbage_after_basic_is_401_not_500) ... ok +test_login (test_auth.LoginTest.test_login) ... ok +test_malformed_credentials (test_auth.LoginTest.test_malformed_credentials) ... ok +test_token_is_opaque_and_unique (test_auth.LoginTest.test_token_is_opaque_and_unique) ... ok +test_username_that_cannot_exist (test_auth.LoginTest.test_username_that_cannot_exist) ... ok +test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same) ... ok +test_login_again_after_logout (test_auth.LogoutTest.test_login_again_after_logout) ... ok +test_logout_requires_token (test_auth.LogoutTest.test_logout_requires_token) ... ok +test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session) ... ok +test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) ... ok +test_same_username_registered_once (test_concurrency.ConcurrencyTest.test_same_username_registered_once) ... ok +test_chat_cursor_belongs_to_user (test_pagination.ChatPaginationTest.test_chat_cursor_belongs_to_user) ... ok +test_walk_chat_list (test_pagination.ChatPaginationTest.test_walk_chat_list) ... ok +test_bad_cursor (test_pagination.MessagePaginationTest.test_bad_cursor) ... ok +test_bad_limit (test_pagination.MessagePaginationTest.test_bad_limit) ... ok +test_cursor_format_is_checked (test_pagination.MessagePaginationTest.test_cursor_format_is_checked) ... ok +test_cursor_from_another_chat (test_pagination.MessagePaginationTest.test_cursor_from_another_chat) ... ok +test_default_limit (test_pagination.MessagePaginationTest.test_default_limit) ... ok +test_exact_page_has_no_cursor (test_pagination.MessagePaginationTest.test_exact_page_has_no_cursor) ... ok +test_limit_can_change_between_pages (test_pagination.MessagePaginationTest.test_limit_can_change_between_pages) ... ok +test_new_message_appears_after_last_page (test_pagination.MessagePaginationTest.test_new_message_appears_after_last_page) ... ok +test_no_duplicates_and_order (test_pagination.MessagePaginationTest.test_no_duplicates_and_order) ... ok +test_walk_several_pages (test_pagination.MessagePaginationTest.test_walk_several_pages) ... ok +test_extra_field (test_validation.InvalidJsonTest.test_extra_field) ... ok +test_malformed_json (test_validation.InvalidJsonTest.test_malformed_json) ... ok +test_malformed_json_in_message (test_validation.InvalidJsonTest.test_malformed_json_in_message) ... ok +test_missing_field (test_validation.InvalidJsonTest.test_missing_field) ... ok +test_not_an_object (test_validation.InvalidJsonTest.test_not_an_object) ... ok +test_wrong_type (test_validation.InvalidJsonTest.test_wrong_type) ... ok +test_empty_message (test_validation.MessageValidationTest.test_empty_message) ... ok +test_nul_character (test_validation.MessageValidationTest.test_nul_character) ... ok +test_sender_id_is_not_accepted (test_validation.MessageValidationTest.test_sender_id_is_not_accepted) ... ok +test_text_limit (test_validation.MessageValidationTest.test_text_limit) ... ok +test_unicode_is_kept (test_validation.MessageValidationTest.test_unicode_is_kept) ... ok +test_whitespace_message (test_validation.MessageValidationTest.test_whitespace_message) ... ok +test_bad_display_names (test_validation.UserValidationTest.test_bad_display_names) ... ok +test_bad_passwords (test_validation.UserValidationTest.test_bad_passwords) ... ok +test_bad_usernames (test_validation.UserValidationTest.test_bad_usernames) ... ok +test_display_name_length_is_counted_in_code_points (test_validation.UserValidationTest.test_display_name_length_is_counted_in_code_points) ... ok +test_duplicate_username (test_validation.UserValidationTest.test_duplicate_username) ... ok +test_password_is_never_returned (test_validation.UserValidationTest.test_password_is_never_returned) ... ok +test_password_length_limits (test_validation.UserValidationTest.test_password_length_limits) ... ok + +---------------------------------------------------------------------- +Ran 62 tests in 1.797s + +OK + +отправлено 100, подтверждено 100, в истории 100, уникальных id 100 + diff --git a/evidence/03-persistence.txt b/evidence/03-persistence.txt new file mode 100644 index 00000000..3ab62be6 --- /dev/null +++ b/evidence/03-persistence.txt @@ -0,0 +1,46 @@ +# Сохранность: перезапуск API, PostgreSQL и Redis с сохранением volumes +# дата: 2026-10-08T15:55Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +# до перезапуска +postgres StartedAt=2026-10-08T15:55:04.230004924Z +redis StartedAt=2026-10-08T15:55:04.230356549Z +api StartedAt=2026-10-08T15:55:10.436053969Z + +$ cat scripts/restart.sh +#!/bin/sh +# Перезапускает API и оба хранилища. Volumes не трогает: данные и сессии должны остаться. +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart postgres redis api + +$ make test-persistence ACTION_SCRIPT=scripts/restart.sh +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + +# после перезапуска: у всех трёх контейнеров новое время старта +postgres StartedAt=2026-10-08T15:55:15.070657346Z +redis StartedAt=2026-10-08T15:55:15.160837596Z +api StartedAt=2026-10-08T15:55:15.392988013Z + +$ docker volume ls --filter name=mtusi-messenger-lab2 +DRIVER VOLUME NAME +local mtusi-messenger-lab2_pgdata +local mtusi-messenger-lab2_redisdata + +# повторный запуск миграций +$ docker compose --env-file .env run --rm migrate + Container mtusi-messenger-lab2-postgres-1 Running + Container mtusi-messenger-lab2-postgres-1 Waiting + Container mtusi-messenger-lab2-postgres-1 Healthy + Container mtusi-messenger-lab2-migrate-run-c47ffc8919e4 Creating + Container mtusi-messenger-lab2-migrate-run-c47ffc8919e4 Created +уже применена: 0001_init.sql + +$ psql: SELECT * FROM schema_migrations + version | applied_at +---------------+------------------------------- + 0001_init.sql | 2026-10-08 15:55:10.184216+00 +(1 row) + diff --git a/evidence/04-redis-sessions.txt b/evidence/04-redis-sessions.txt new file mode 100644 index 00000000..37f779f4 --- /dev/null +++ b/evidence/04-redis-sessions.txt @@ -0,0 +1,36 @@ +# Сессии в Redis: настройки persistence, вид ключа, TTL не продлевается перезапуском +# дата: 2026-10-08T15:55Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ redis-cli CONFIG GET appendonly / appendfsync / maxmemory-policy +appendonly +yes +appendfsync +always +maxmemory-policy +noeviction + +$ redis-cli --scan --pattern 'session:*' | wc -l + 41 + +# один из ключей: sha256 от токена, значение — id пользователя +$ redis-cli GET session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367 +97dbb54c-2e55-441f-ae31-ef469b935758 +$ redis-cli TTL session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367 +3591 + +$ docker compose --env-file .env restart redis + Container mtusi-messenger-lab2-redis-1 Restarting + Container mtusi-messenger-lab2-redis-1 Started + +$ redis-cli TTL session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367 # после перезапуска ключ на месте, TTL уменьшился +3583 + +$ docker compose --env-file .env exec -T redis ls -la /data/appendonlydir +total 24 +drwx------ 2 redis redis 4096 Oct 8 15:55 . +drwxr-xr-x 3 redis redis 4096 Oct 8 15:55 .. +-rw------- 1 redis redis 89 Oct 8 15:55 appendonly.aof.1.base.rdb +-rw------- 1 redis redis 7582 Oct 8 15:55 appendonly.aof.1.incr.aof +-rw------- 1 redis redis 88 Oct 8 15:55 appendonly.aof.manifest + diff --git a/evidence/05-failures.txt b/evidence/05-failures.txt new file mode 100644 index 00000000..c6a19d91 --- /dev/null +++ b/evidence/05-failures.txt @@ -0,0 +1,36 @@ +# Тесты отказов: истечение сессии, остановка Redis и PostgreSQL, откат транзакции, гонка регистрации +# дата: 2026-10-08T15:55Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ make test-failures +BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests/failures -v +test_postgres_down (test_dependencies.DependencyDownTest.test_postgres_down) ... ok +test_redis_down (test_dependencies.DependencyDownTest.test_redis_down) ... ok +test_expires_at_matches_ttl (test_expiry.SessionExpiryTest.test_expires_at_matches_ttl) ... ok +test_login_after_expiry (test_expiry.SessionExpiryTest.test_login_after_expiry) ... ok +test_requests_do_not_extend_session (test_expiry.SessionExpiryTest.test_requests_do_not_extend_session) ... ok +test_session_expires (test_expiry.SessionExpiryTest.test_session_expires) ... ok +test_chat_with_unknown_member_is_rolled_back (test_transactions.TransactionTest.test_chat_with_unknown_member_is_rolled_back) ... ok +test_migrations_can_be_repeated (test_transactions.TransactionTest.test_migrations_can_be_repeated) ... ok +test_password_is_stored_as_argon2id_hash (test_transactions.TransactionTest.test_password_is_stored_as_argon2id_hash) ... ok +test_username_race_creates_one_row (test_transactions.TransactionTest.test_username_race_creates_one_row) ... ok +test_valid_chat_is_committed_whole (test_transactions.TransactionTest.test_valid_chat_is_committed_whole) ... ok + +---------------------------------------------------------------------- +Ran 11 tests in 47.384s + +OK + +# время ответа при отказе (после тестов сервисы снова остановлены вручную) +$ docker compose stop redis; curl /api/v1/users/me с Bearer-токеном +{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"ec599bbf80da42ba9410d2bb5fe44408"}} +HTTP 503 за 0.010007 с +$ docker compose stop postgres; curl /health/ready +{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"ff86a9409ca74d1a9207d7efe82e4313"}} +HTTP 503 за 3.015225 с + +$ docker compose logs api | grep unavailable | tail -4 +api-1 | 2026-10-08 15:55:59,645 WARNING messenger: redis unavailable: ConnectionError request_id=7303c9edcbe8408496ff607945e71893 +api-1 | 2026-10-08 15:55:59,653 WARNING messenger: redis unavailable: ConnectionError request_id=0a217c1035f548f0b3a68b9bb0640d3f +api-1 | 2026-10-08 15:56:17,960 WARNING messenger: redis unavailable: ConnectionError request_id=ec599bbf80da42ba9410d2bb5fe44408 +api-1 | 2026-10-08 15:56:21,270 WARNING messenger: postgres unavailable: PoolTimeout request_id=ff86a9409ca74d1a9207d7efe82e4313 diff --git a/evidence/06-explain.txt b/evidence/06-explain.txt new file mode 100644 index 00000000..37977829 --- /dev/null +++ b/evidence/06-explain.txt @@ -0,0 +1,74 @@ +# Индекс истории: EXPLAIN (ANALYZE, BUFFERS) на 60 000 сообщений, 10 000 в одном чате +# дата: 2026-10-08T15:56Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ make explain +./scripts/explain_history.sh +== Объём данных + messages_total | messages_in_chat | table_size | index_size +----------------+------------------+------------+------------ + 60140 | 10000 | 6848 kB | 6160 kB +(1 row) + + +== 1. Первая страница (limit 50, запрос берёт 51 строку) + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..21.21 rows=51 width=80) (actual time=0.007..0.015 rows=51 loops=1) + Buffers: shared hit=8 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..4114.85 rows=10089 width=80) (actual time=0.006..0.012 rows=51 loops=1) + Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid) + Buffers: shared hit=8 + Planning: + Buffers: shared hit=33 + Planning Time: 0.079 ms + Execution Time: 0.025 ms +(9 rows) + + +== 2. Страница из середины истории: keyset после 5000-го сообщения + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..38.79 rows=51 width=80) (actual time=0.006..0.015 rows=51 loops=1) + Buffers: shared hit=8 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..3778.58 rows=5021 width=80) (actual time=0.006..0.012 rows=51 loops=1) + Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-08 07:36:22.289031+00'::timestamp with time zone, '31ba47ee-c105-47bd-9bb1-79986700dbd4'::uuid))) + Buffers: shared hit=8 + Planning Time: 0.031 ms + Execution Time: 0.034 ms +(7 rows) + + +== 3. Та же страница через OFFSET (так делать не стали) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=2039.48..2060.28 rows=51 width=80) (actual time=0.459..0.464 rows=51 loops=1) + Buffers: shared hit=491 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..4114.85 rows=10089 width=80) (actual time=0.005..0.359 rows=5051 loops=1) + Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid) + Buffers: shared hit=491 + Planning Time: 0.016 ms + Execution Time: 0.469 ms +(7 rows) + + +== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK) + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=2075.96..2076.09 rows=51 width=80) (actual time=2.252..2.256 rows=51 loops=1) + Buffers: shared hit=862 + -> Sort (cost=2075.96..2088.51 rows=5021 width=80) (actual time=2.252..2.254 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 31kB + Buffers: shared hit=862 + -> Seq Scan on messages (cost=0.00..1908.45 rows=5021 width=80) (actual time=0.939..2.012 rows=5000 loops=1) + Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-08 07:36:22.289031+00'::timestamp with time zone, '31ba47ee-c105-47bd-9bb1-79986700dbd4'::uuid))) + Rows Removed by Filter: 55140 + Buffers: shared hit=856 + Planning: + Buffers: shared hit=4 + Planning Time: 0.032 ms + Execution Time: 2.266 ms +(14 rows) + + diff --git a/evidence/07-containers.txt b/evidence/07-containers.txt new file mode 100644 index 00000000..2f70cc31 --- /dev/null +++ b/evidence/07-containers.txt @@ -0,0 +1,58 @@ +# Контейнеры: пользователи, секреты, версии +# дата: 2026-10-08T15:56Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ docker compose --env-file .env exec -T api id +uid=10001(app) gid=10001(app) groups=10001(app) + +$ docker compose exec api ls -l /run/secrets +total 8 +-r--r--r-- 1 root root 70 Oct 8 15:55 cache_url +-r--r--r-- 1 root root 95 Oct 8 15:55 database_url + +$ docker compose exec api env | grep -ci "password\|postgresql://\|redis://" # секретов в окружении нет +0 + +$ docker compose exec redis ps -o user,args +USER COMMAND +redis redis-server *:6379 +root ps -o user,args + +$ docker compose exec postgres ps -o user,args | head -3 +USER COMMAND +postgres postgres +postgres postgres: checkpointer + +$ docker compose --env-file .env images +CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED +mtusi-messenger-lab2-api-1 mtusi-messenger lab2 linux/arm64 46505be4fa02 203MB 47 minutes ago +mtusi-messenger-lab2-migrate-1 mtusi-messenger lab2 linux/arm64 46505be4fa02 203MB 47 minutes ago +mtusi-messenger-lab2-postgres-1 postgres 17.11-alpine linux/arm64/v8 25a89970a832 291MB 2 weeks ago +mtusi-messenger-lab2-redis-1 redis 7.4.11-alpine linux/arm64/v8 ec4f171e9ff0 39.5MB 2 weeks ago + +$ docker compose --env-file .env exec -T api pip freeze --disable-pip-version-check +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==25.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.143.0 +h11==0.16.0 +idna==3.20 +opentelemetry-api==1.45.1 +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +pycparser==3.1 +pydantic==2.13.5 +pydantic_core==2.46.5 +redis==8.1.0 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.54.0 + +$ git ls-files | grep -E "^\.env$|secrets" # в Git секретов нет +(пусто) diff --git a/evidence/08-sigterm.txt b/evidence/08-sigterm.txt new file mode 100644 index 00000000..c687132c --- /dev/null +++ b/evidence/08-sigterm.txt @@ -0,0 +1,11 @@ +# SIGTERM (возможность lab1 сохранена) +# дата: 2026-10-08T15:56Z, commit: 6473fd0 +# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0 + +$ python3 scripts/sigterm_check.py +$ docker kill --signal=SIGTERM <контейнер api> +новый запрос после SIGTERM: не принят (RemoteDisconnected) +начатый до SIGTERM запрос: HTTP/1.1 201 Created +процесс завершился за 1.45 с, код выхода 0 +PASS: остановка корректная и укладывается в 10 секунд + diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..e5d90b81 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,39 @@ +-- Пользователи, чаты, участники и сообщения. + +CREATE TABLE users ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + 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 DEFAULT gen_random_uuid(), + 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) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + -- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы + position integer NOT NULL, + PRIMARY KEY (chat_id, user_id) +); + +-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT now() +); + +-- история чата читается запросом +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4 +-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории +CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..bfe01add --- /dev/null +++ b/requirements.txt @@ -0,0 +1,24 @@ +# Прямые зависимости +fastapi==0.143.0 +uvicorn==0.54.0 +psycopg[binary,pool]==3.3.6 +redis==8.1.0 +argon2-cffi==25.1.0 +# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm +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 +opentelemetry-api==1.45.1 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +pycparser==3.1 +pydantic==2.13.5 +pydantic_core==2.46.5 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 diff --git a/scripts/explain_history.sh b/scripts/explain_history.sh new file mode 100755 index 00000000..371e03ee --- /dev/null +++ b/scripts/explain_history.sh @@ -0,0 +1,11 @@ +#!/bin/sh +# Наполняет БД синтетической историей и печатает планы запросов пагинации. +set -eu +cd "$(dirname "$0")/.." + +run_sql() { + docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -q +} + +run_sql < scripts/seed_history.sql +run_sql < scripts/explain_history.sql diff --git a/scripts/explain_history.sql b/scripts/explain_history.sql new file mode 100644 index 00000000..88d64441 --- /dev/null +++ b/scripts/explain_history.sql @@ -0,0 +1,44 @@ +\set chat '00000000-0000-4000-8000-000000000100' +\pset pager off + +\echo '== Объём данных' +SELECT count(*) AS messages_total, + count(*) FILTER (WHERE chat_id = :'chat') AS messages_in_chat, + pg_size_pretty(pg_relation_size('messages')) AS table_size, + pg_size_pretty(pg_relation_size('messages_chat_history_idx')) AS index_size +FROM messages; + +\echo +\echo '== 1. Первая страница (limit 50, запрос берёт 51 строку)' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'chat' +ORDER BY created_at, id LIMIT 51; + +-- cursor на 5000-е сообщение чата, как его получил бы клиент после 100 страниц +SELECT created_at AS after_time, id AS after_id FROM messages +WHERE chat_id = :'chat' ORDER BY created_at, id OFFSET 4999 LIMIT 1 \gset + +\echo +\echo '== 2. Страница из середины истории: keyset после 5000-го сообщения' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id') +ORDER BY created_at, id LIMIT 51; + +\echo +\echo '== 3. Та же страница через OFFSET (так делать не стали)' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'chat' +ORDER BY created_at, id OFFSET 5000 LIMIT 51; + +\echo +\echo '== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)' +BEGIN; +DROP INDEX messages_chat_history_idx; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id') +ORDER BY created_at, id LIMIT 51; +ROLLBACK; diff --git a/scripts/init-env.sh b/scripts/init-env.sh new file mode 100755 index 00000000..a9cd4402 --- /dev/null +++ b/scripts/init-env.sh @@ -0,0 +1,25 @@ +#!/bin/sh +# Создаёт .env из .env.example и дописывает в него случайные пароли. Файл .env исключён из Git. +set -eu +cd "$(dirname "$0")/.." + +[ -f .env ] || cp .env.example .env + +if grep -q '^POSTGRES_PASSWORD=' .env; then + # пароль PostgreSQL задаётся один раз при создании volume, новый пароль к старым данным не подойдёт + echo ".env уже содержит пароли, ничего не меняю" + exit 0 +fi + +postgres_password=$(openssl rand -hex 24) +redis_password=$(openssl rand -hex 24) +cat >> .env < 60000 - n) +FROM generate_series(1, 60000) AS n +WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100'); + +ANALYZE messages; diff --git a/scripts/sigterm_check.py b/scripts/sigterm_check.py new file mode 100644 index 00000000..64e312b2 --- /dev/null +++ b/scripts/sigterm_check.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""Проверка SIGTERM (перенесена из lab1): начатый запрос завершается, новые не принимаются, выход быстрее 10 секунд.""" +import json +import socket +import subprocess +import sys +import time +import urllib.parse +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "student-tests")) +from api import BASE_URL, call, new_chat, new_user + +LIMIT_SECONDS = 10 + + +def main(): + container = subprocess.run( + ["docker", "compose", "--env-file", ".env", "ps", "-q", "api"], + cwd=ROOT, check=True, capture_output=True, text=True, + ).stdout.strip() + address = urllib.parse.urlsplit(BASE_URL) + user = new_user("sigterm") + chat = new_chat(user) + + # отправляем заголовки и только половину тела: запрос уже начат, но ещё не закончен + body = json.dumps({"text": "сообщение, отправленное во время остановки"}).encode() + head = ( + "POST /api/v1/chats/%s/messages HTTP/1.1\r\n" + "Host: %s\r\nContent-Type: application/json\r\nContent-Length: %d\r\nAuthorization: Bearer %s\r\n\r\n" + % (chat["id"], address.netloc, len(body), user["token"]) + ).encode() + connection = socket.create_connection((address.hostname, address.port), timeout=LIMIT_SECONDS) + connection.sendall(head + body[:10]) + time.sleep(0.3) + + print("$ docker kill --signal=SIGTERM <контейнер api>") + started = time.monotonic() + subprocess.run(["docker", "kill", "--signal=SIGTERM", container], check=True, stdout=subprocess.DEVNULL) + time.sleep(1) + + try: + status = call("GET", "/health/live")[0] + print("новый запрос после SIGTERM: принят, статус", status) + accepted = True + except OSError as error: + print("новый запрос после SIGTERM: не принят (%s)" % type(error).__name__) + accepted = False + + connection.sendall(body[10:]) + status_line = connection.recv(65536).split(b"\r\n")[0].decode() + connection.close() + print("начатый до SIGTERM запрос:", status_line) + + exit_code = subprocess.run(["docker", "wait", container], check=True, capture_output=True, text=True).stdout.strip() + elapsed = time.monotonic() - started + print("процесс завершился за %.2f с, код выхода %s" % (elapsed, exit_code)) + + # контейнер, остановленный через docker kill, сам не перезапускается: поднимаем его обратно + subprocess.run(["docker", "start", container], check=True, stdout=subprocess.DEVNULL) + + if accepted or " 201 " not in status_line or elapsed > LIMIT_SECONDS or exit_code != "0": + raise SystemExit("FAIL") + print("PASS: остановка корректная и укладывается в %d секунд" % LIMIT_SECONDS) + + +if __name__ == "__main__": + main() diff --git a/scripts/wait-ready.sh b/scripts/wait-ready.sh new file mode 100755 index 00000000..a036a4fd --- /dev/null +++ b/scripts/wait-ready.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Ждёт, пока /health/ready ответит 200, не дольше 60 секунд. +BASE_URL=${BASE_URL:-http://localhost:8080} +for attempt in $(seq 1 60); do + if curl -fs -o /dev/null "$BASE_URL/health/ready"; then + echo "готов: $BASE_URL" + exit 0 + fi + sleep 1 +done +echo "стенд не стал готов за 60 секунд: $BASE_URL" >&2 +exit 1 diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..acf48cbc --- /dev/null +++ b/src/config.py @@ -0,0 +1,41 @@ +import os +from pathlib import Path + +HOST = os.getenv("APP_HOST", "0.0.0.0") +PORT = int(os.getenv("APP_PORT", "8080")) +ENV = os.getenv("APP_ENV", "lab") +LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower() +# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом +SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8")) + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +SESSION_STORE = os.getenv("SESSION_STORE", "redis") + +# пул соединений с PostgreSQL и таймауты, всё в секундах +DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2")) +DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10")) +DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3")) +DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3")) +DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5")) + +CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20")) +CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2")) + + +def read_secret(name: str) -> str: + """Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME.""" + path = os.getenv(name + "_FILE") + if path and Path(path).is_file(): + return Path(path).read_text().strip() + value = os.getenv(name) + if not value: + raise SystemExit(f"не задан {name}_FILE или {name}") + return value + + +def database_url() -> str: + return read_secret("DATABASE_URL") + + +def cache_url() -> str: + return read_secret("CACHE_URL") diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..62f6c873 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,38 @@ +from fastapi.responses import JSONResponse + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, headers=None): + self.status = status + self.code = code + self.message = message + self.headers = headers + + +def invalid(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def bad_credentials() -> ApiError: + # один и тот же ответ для неизвестного username и неверного пароля + return ApiError( + 401, "unauthorized", "Неверное имя пользователя или пароль", + {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + + +def unauthorized() -> ApiError: + return ApiError( + 401, "unauthorized", "Нужен действующий Bearer-токен", + {"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + +def not_found() -> ApiError: + # одинаковый ответ для несуществующего и чужого объекта + return ApiError(404, "not_found", "Объект не найден") + + +def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse: + body = {"error": {"code": code, "message": message, "request_id": request_id}} + return JSONResponse(body, status_code=status, headers=headers) diff --git a/src/healthcheck.py b/src/healthcheck.py new file mode 100644 index 00000000..a9bcca4d --- /dev/null +++ b/src/healthcheck.py @@ -0,0 +1,11 @@ +"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200.""" +import os +import sys +import urllib.request + +port = os.getenv("APP_PORT", "8080") +try: + with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response: + sys.exit(0 if response.status == 200 else 1) +except Exception: + sys.exit(1) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..53a83a7f --- /dev/null +++ b/src/main.py @@ -0,0 +1,280 @@ +import base64 +import json +import logging +import re +import sys +import time +import uuid +from contextlib import asynccontextmanager +from dataclasses import dataclass +from datetime import datetime, timedelta, timezone +from uuid import UUID + +import psycopg +import redis +import uvicorn +from fastapi import Depends, FastAPI, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException + +import config +import security +from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized +from schemas import CreateChat, CreateMessage, CreateUser +from sessions import Sessions +from store import TIME_FORMAT, Store, UnknownMember, UsernameTaken, timestamp + +logging.basicConfig( + level=config.LOG_LEVEL.upper(), + format="%(asctime)s %(levelname)s %(name)s: %(message)s", + stream=sys.stdout, +) +log = logging.getLogger("messenger") + +if config.SESSION_STORE != "redis": + sys.exit("поддерживается только SESSION_STORE=redis") + +USERNAME = re.compile(r"[a-z0-9_]{3,32}") + +store = Store(config.database_url()) +sessions = Sessions(config.cache_url()) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + store.open() + log.info( + "started env=%s listen=%s:%d session_ttl=%ds db_pool_max=%d", + config.ENV, config.HOST, config.PORT, config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE, + ) + yield + store.close() + sessions.close() + log.info("stopped") + + +app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None) + + +@app.middleware("http") +async def request_context(request: Request, call_next): + request_id = uuid.uuid4().hex + request.state.request_id = request_id + started = time.perf_counter() + try: + response = await call_next(request) + except Exception: + log.exception("unhandled error request_id=%s", request_id) + response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера") + response.headers["X-Request-Id"] = request_id + # в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем + log.info( + "%s %s status=%d duration_ms=%.1f request_id=%s", + request.method, request.url.path, response.status_code, + (time.perf_counter() - started) * 1000, request_id, + ) + return response + + +@app.exception_handler(ApiError) +async def on_api_error(request: Request, exc: ApiError): + return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def on_validation_error(request: Request, exc: RequestValidationError): + first = exc.errors()[0] + where = ".".join(str(part) for part in first["loc"]) + return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}") + + +@app.exception_handler(HTTPException) +async def on_http_error(request: Request, exc: HTTPException): + # сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод + if exc.status_code == 404: + code, message = "not_found", "Объект не найден" + else: + code, message = "invalid_request", "Запрос не поддерживается" + return error_response(request.state.request_id, exc.status_code, code, message, exc.headers) + + +# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout +@app.exception_handler(psycopg.OperationalError) +async def on_database_down(request: Request, exc: Exception): + log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id) + return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен") + + +@app.exception_handler(redis.RedisError) +async def on_cache_down(request: Request, exc: Exception): + log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id) + return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен") + + +@dataclass +class Session: + user_id: str + token: str + + +def current_session(request: Request) -> Session: + # X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается + token = security.parse_bearer(request.headers.get("Authorization")) + if token is None: + raise unauthorized() + # если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт + user_id = sessions.user_id(token) + if user_id is None: + raise unauthorized() + return Session(user_id, token) + + +def encode_cursor(scope: str, created_at: str, item_id: str) -> str: + raw = json.dumps([scope, created_at, item_id]) + return base64.urlsafe_b64encode(raw.encode()).decode() + + +def decode_cursor(scope: str, cursor): + """Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы.""" + if cursor is None: + return None + try: + # validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча + cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True)) + # время и id принимаются только в том виде, в котором их выдаёт сам сервер + moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc) + time_ok = moment.strftime(TIME_FORMAT) == created_at + id_ok = str(UUID(item_id)) == item_id + except (TypeError, ValueError, AttributeError): + raise invalid("Некорректный cursor") + # cursor действует только для того списка, в котором был выдан + if cursor_scope != scope or not time_ok or not id_ok: + raise invalid("Некорректный cursor") + # у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается + if encode_cursor(scope, created_at, item_id) != cursor: + raise invalid("Некорректный cursor") + return [moment, item_id] + + +def page(scope: str, items: list, has_more: bool) -> dict: + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/health/live") +def liveness(): + return {"status": "ok"} + + +@app.get("/health/ready") +def readiness(): + # без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны + store.ping() + sessions.ping() + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register_user(body: CreateUser): + try: + return store.create_user(body.username, body.display_name, security.hash_password(body.password)) + except UsernameTaken: + raise ApiError(409, "conflict", "Такой username уже занят") + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(request: Request): + credentials = security.parse_basic(request.headers.get("Authorization")) + if credentials is None: + raise bad_credentials() + username, password = credentials + user, password_hash = None, None + # username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой + if USERNAME.fullmatch(username): + user, password_hash = store.get_credentials(username) + if not security.verify_password(password_hash, password): + raise bad_credentials() + token = sessions.create(user["id"]) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS) + return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session(session: Session = Depends(current_session)): + sessions.revoke(session.token) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(session: Session = Depends(current_session)): + user = store.get_user(session.user_id) + if user is None: + raise unauthorized() + return user + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, session: Session = Depends(current_session)): + member_ids = [str(member) for member in body.member_ids] + if len(set(member_ids)) != len(member_ids): + raise invalid("member_ids содержит повторы") + if session.user_id not in member_ids: + raise invalid("Создатель чата должен быть в member_ids") + try: + return store.create_chat(body.title, member_ids) + except UnknownMember: + raise invalid("В member_ids есть несуществующий пользователь") + + +@app.get("/api/v1/chats") +def list_chats( + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None, min_length=1), + session: Session = Depends(current_session), +): + scope = "chats:" + session.user_id + items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit) + return page(scope, items, has_more) + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: UUID, session: Session = Depends(current_session)): + chat = store.get_chat(str(chat_id), session.user_id) + if chat is None: + raise not_found() + return chat + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def send_message(chat_id: UUID, body: CreateMessage, session: Session = Depends(current_session)): + # отправитель берётся из сессии, в теле запроса его нет + message = store.add_message(str(chat_id), session.user_id, body.text) + if message is None: + raise not_found() + return message + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: UUID, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None, min_length=1), + session: Session = Depends(current_session), +): + scope = "messages:" + str(chat_id) + result = store.list_messages(str(chat_id), session.user_id, decode_cursor(scope, cursor), limit) + if result is None: + raise not_found() + items, has_more = result + return page(scope, items, has_more) + + +if __name__ == "__main__": + uvicorn.run( + app, + host=config.HOST, + port=config.PORT, + log_level=config.LOG_LEVEL, + access_log=False, + timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT, + ) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..216b5a73 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,48 @@ +"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет.""" +import os +import sys +import time +from pathlib import Path + +import psycopg + +import config + +MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations")) +LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно + + +def connect(attempts=30): + for attempt in range(attempts): + try: + return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT) + except psycopg.OperationalError: + if attempt == attempts - 1: + raise + time.sleep(1) + + +def main(): + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + if not files: + sys.exit(f"в {MIGRATIONS_DIR} нет миграций") + with connect() as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + "version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())" + ) + applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")} + for path in files: + if path.name in applied: + print("уже применена:", path.name) + continue + # миграция и отметка о ней в одной транзакции: либо всё, либо ничего + with conn.transaction(): + conn.execute(path.read_text()) + conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,)) + print("применена:", path.name) + + +if __name__ == "__main__": + main() diff --git a/src/schemas.py b/src/schemas.py new file mode 100644 index 00000000..62cc090c --- /dev/null +++ b/src/schemas.py @@ -0,0 +1,38 @@ +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +def not_blank(value: str) -> str: + if not value.strip(): + raise ValueError("строка не может состоять только из пробелов") + # PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8 + if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value): + raise ValueError("строка содержит недопустимые символы") + return value + + +class StrictModel(BaseModel): + # лишние поля в JSON считаются ошибкой + model_config = ConfigDict(extra="forbid") + + +class CreateUser(StrictModel): + 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=12, max_length=128) + + _not_blank = field_validator("display_name", "password")(not_blank) + + +class CreateChat(StrictModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + _title = field_validator("title")(not_blank) + + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + _text = field_validator("text")(not_blank) diff --git a/src/security.py b/src/security.py new file mode 100644 index 00000000..73d7baa3 --- /dev/null +++ b/src/security.py @@ -0,0 +1,45 @@ +import base64 + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток +hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username +DUMMY_HASH = hasher.hash("no-such-user-password") + + +def hash_password(password: str) -> str: + return hasher.hash(password) + + +def verify_password(password_hash, password: str) -> bool: + try: + return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None + except (VerificationError, InvalidHashError): + return False + + +def parse_basic(header): + """Разбирает Authorization: Basic base64(username:password). Возвращает пару или None.""" + scheme, _, value = (header or "").partition(" ") + if scheme.lower() != "basic": + return None + try: + decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except ValueError: + # три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8 + # (их исключения — подклассы ValueError) + return None + # двоеточие в пароле допустимо, поэтому делим только по первому + username, colon, password = decoded.partition(":") + if not colon: + return None + return username, password + + +def parse_bearer(header): + scheme, _, token = (header or "").partition(" ") + if scheme.lower() != "bearer" or not token.strip(): + return None + return token.strip() diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..150fc8ef --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,47 @@ +import hashlib +import secrets + +import redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +import config + + +class Sessions: + """Сессии лежат только в Redis: ключ session:, значение id пользователя, TTL ставит сам Redis.""" + + def __init__(self, url: str): + pool = redis.BlockingConnectionPool.from_url( + url, + max_connections=config.CACHE_POOL_MAX_SIZE, + timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения + socket_timeout=config.CACHE_TIMEOUT, + socket_connect_timeout=config.CACHE_TIMEOUT, + decode_responses=True, + # одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается + retry=Retry(NoBackoff(), 1), + ) + self.client = redis.Redis(connection_pool=pool) + + @staticmethod + def key(token: str) -> str: + # сам токен в Redis не хранится: по дампу нельзя войти от чужого имени + return "session:" + hashlib.sha256(token.encode()).hexdigest() + + def create(self, user_id: str) -> str: + token = secrets.token_urlsafe(32) # 256 бит случайности + self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS) + return token + + def user_id(self, token: str): + return self.client.get(self.key(token)) + + def revoke(self, token: str) -> None: + self.client.delete(self.key(token)) + + def ping(self) -> None: + self.client.ping() + + def close(self) -> None: + self.client.close() diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..ee7ad79c --- /dev/null +++ b/src/store.py @@ -0,0 +1,189 @@ +from datetime import timezone + +from psycopg import errors +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +import config + + +class UsernameTaken(Exception): + pass + + +class UnknownMember(Exception): + pass + + +# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz +TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ" + + +def timestamp(value) -> str: + return value.astimezone(timezone.utc).strftime(TIME_FORMAT) + + +def user_json(row) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": timestamp(row["created_at"]), + } + + +def chat_json(row) -> dict: + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": [str(member) for member in row["member_ids"]], + "created_at": timestamp(row["created_at"]), + } + + +def message_json(row) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": timestamp(row["created_at"]), + } + + +CHAT_COLUMNS = """ + c.id, c.title, c.created_at, + (SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids +""" + + +class Store: + """Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s.""" + + def __init__(self, url: str): + self.pool = ConnectionPool( + url, + min_size=config.DB_POOL_MIN_SIZE, + max_size=config.DB_POOL_MAX_SIZE, + timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение + kwargs={ + "connect_timeout": config.DB_CONNECT_TIMEOUT, + "options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}", + "row_factory": dict_row, + }, + # перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам + check=ConnectionPool.check_connection, + open=False, + ) + + def open(self) -> None: + # не ждём БД: если она недоступна, сервер стартует и отвечает 503 + self.pool.open(wait=False) + + def close(self) -> None: + self.pool.close() + + def ping(self) -> None: + with self.pool.connection() as conn: + conn.execute("SELECT 1") + + def create_user(self, username: str, display_name: str, password_hash: str) -> dict: + with self.pool.connection() as conn: + try: + row = conn.execute( + "INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) " + "RETURNING id, username, display_name, created_at", + (username, display_name, password_hash), + ).fetchone() + except errors.UniqueViolation: + # уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей + raise UsernameTaken() + return user_json(row) + + def get_user(self, user_id: str): + with self.pool.connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,) + ).fetchone() + return user_json(row) if row else None + + def get_credentials(self, username: str): + """Пользователь и hash его пароля или (None, None).""" + with self.pool.connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,), + ).fetchone() + if row is None: + return None, None + return user_json(row), row["password_hash"] + + def create_chat(self, title: str, member_ids: list) -> dict: + # блок with — одна транзакция: commit при выходе, rollback при любом исключении + with self.pool.connection() as conn: + chat = conn.execute( + "INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,) + ).fetchone() + try: + with conn.cursor() as cursor: + cursor.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat["id"], member, position) for position, member in enumerate(member_ids)], + ) + except errors.ForeignKeyViolation: + # участника нет в users: транзакция откатывается вместе с уже вставленным чатом + raise UnknownMember() + return chat_json({**chat, "member_ids": member_ids}) + + def get_chat(self, chat_id: str, user_id: str): + with self.pool.connection() as conn: + row = 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() + return chat_json(row) if row else None + + def list_chats(self, user_id: str, after, limit: int): + query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s" + params = [user_id] + if after: + query += " AND (c.created_at, c.id) > (%s, %s)" + params += after + query += " ORDER BY c.created_at, c.id LIMIT %s" + with self.pool.connection() as conn: + rows = conn.execute(query, params + [limit + 1]).fetchall() + return [chat_json(row) for row in rows[:limit]], len(rows) > limit + + def add_message(self, chat_id: str, sender_id: str, text: str): + with self.pool.connection() as conn: + if not self._is_member(conn, chat_id, sender_id): + return None + row = conn.execute( + "INSERT INTO messages (chat_id, sender_id, text) VALUES (%s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (chat_id, sender_id, text), + ).fetchone() + return message_json(row) + + def list_messages(self, chat_id: str, user_id: str, after, limit: int): + query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s" + params = [chat_id] + if after: + # keyset: продолжаем с записи после cursor, а не пропускаем N строк + query += " AND (created_at, id) > (%s, %s)" + params += after + query += " ORDER BY created_at, id LIMIT %s" + with self.pool.connection() as conn: + if not self._is_member(conn, chat_id, user_id): + return None + # limit + 1: лишняя строка показывает, есть ли следующая страница + rows = conn.execute(query, params + [limit + 1]).fetchall() + return [message_json(row) for row in rows[:limit]], len(rows) > limit + + @staticmethod + def _is_member(conn, chat_id: str, user_id: str) -> bool: + row = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id) + ).fetchone() + return row is not None diff --git a/student-tests/api.py b/student-tests/api.py new file mode 100644 index 00000000..50884886 --- /dev/null +++ b/student-tests/api.py @@ -0,0 +1,82 @@ +"""Маленький HTTP-клиент для собственных тестов. Только стандартная библиотека.""" +import base64 +import json +import os +import urllib.error +import urllib.parse +import urllib.request +import uuid + +BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") + + +def call(method, path, body=None, user=None, raw=None, headers=None, base_url=None): + """Возвращает (код ответа, разобранный JSON или None, заголовки).""" + request_headers = {"Accept": "application/json"} + if body is not None: + raw = json.dumps(body, ensure_ascii=False).encode("utf-8") + if raw is not None: + request_headers["Content-Type"] = "application/json" + if user is not None: + request_headers["Authorization"] = "Bearer " + user["token"] + request_headers.update(headers or {}) + request = urllib.request.Request((base_url or BASE_URL) + path, data=raw, headers=request_headers, method=method) + try: + response = urllib.request.urlopen(request, timeout=15) + except urllib.error.HTTPError as error: + response = error + with response: + data = response.read() + return response.status, json.loads(data) if data else None, response.headers + + +def basic(username, password): + return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()} + + +def login(username, password, base_url=None): + return call("POST", "/api/v1/auth/sessions", headers=basic(username, password), base_url=base_url) + + +def user_body(**fields): + """Корректное тело регистрации со случайным username; поля можно переопределить.""" + body = {"username": "u_" + uuid.uuid4().hex[:12], "display_name": "Тест", "password": "Pw-" + uuid.uuid4().hex} + body.update(fields) + return body + + +def new_user(prefix="t", base_url=None): + """Регистрирует синтетического пользователя и сразу входит. В словаре id, username, password и token.""" + body = user_body(username=prefix + "_" + uuid.uuid4().hex[:12], display_name="Тест " + prefix) + status, user, _ = call("POST", "/api/v1/users", body, base_url=base_url) + assert status == 201, status + status, session, _ = login(body["username"], body["password"], base_url=base_url) + assert status == 201, status + return {**user, "password": body["password"], "token": session["token"], "user": user} + + +def new_chat(owner, *others, title="Тестовый чат"): + member_ids = [owner["id"]] + [other["id"] for other in others] + status, chat, _ = call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=owner) + assert status == 201, status + return chat + + +def send(user, chat, text): + return call("POST", "/api/v1/chats/" + chat["id"] + "/messages", {"text": text}, user=user) + + +def history(user, chat, limit): + """Обходит всю историю чата страницами по limit, возвращает сообщения и размеры страниц.""" + items, sizes, cursor = [], [], None + while True: + path = "/api/v1/chats/%s/messages?limit=%d" % (chat["id"], limit) + if cursor: + path += "&cursor=" + urllib.parse.quote(cursor, safe="") + status, page, _ = call("GET", path, user=user) + assert status == 200, status + items += page["items"] + sizes.append(len(page["items"])) + cursor = page["next_cursor"] + if cursor is None: + return items, sizes diff --git a/student-tests/failures/stand.py b/student-tests/failures/stand.py new file mode 100644 index 00000000..44092c33 --- /dev/null +++ b/student-tests/failures/stand.py @@ -0,0 +1,39 @@ +"""Управление стендом для тестов отказов: останавливает и запускает сервисы через docker compose.""" +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "student-tests")) + +from api import BASE_URL, call # noqa: E402 + + +def compose(*args): + command = ["docker", "compose", "--env-file", ".env", *args] + return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout + + +def sql(query): + """Выполняет запрос через psql внутри контейнера postgres и возвращает вывод без оформления.""" + return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-At", "-c", query).strip() + + +def wait_ready(base_url=BASE_URL, seconds=60): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + try: + if call("GET", "/health/ready", base_url=base_url)[0] == 200: + return + except OSError: + pass + time.sleep(0.3) + raise AssertionError("стенд не стал готов за %d секунд" % seconds) + + +def timed(*args, **kwargs): + """Как call, но первым элементом возвращает время ответа в секундах.""" + started = time.monotonic() + result = call(*args, **kwargs) + return (time.monotonic() - started, *result) diff --git a/student-tests/failures/test_dependencies.py b/student-tests/failures/test_dependencies.py new file mode 100644 index 00000000..ef222a66 --- /dev/null +++ b/student-tests/failures/test_dependencies.py @@ -0,0 +1,76 @@ +"""Недоступность Redis и PostgreSQL: ограниченная по времени ошибка 503, анониму доступ не открывается.""" +import unittest + +from stand import call, compose, timed, wait_ready +from api import basic, history, new_chat, new_user, send, user_body + +# таймауты в .env.example: 2 с на Redis, 3 с на ожидание соединения с БД; берём запас +MAX_SECONDS = 6 + + +class DependencyDownTest(unittest.TestCase): + def setUp(self): + wait_ready() + self.user = new_user("dep") + self.chat = new_chat(self.user) + send(self.user, self.chat, "сообщение до отказа") + self.messages = "/api/v1/chats/" + self.chat["id"] + "/messages" + + def assert_unavailable(self, result): + elapsed, status, body, headers = result + self.assertEqual(status, 503) + self.assertEqual(body["error"]["code"], "unavailable") + self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"]) + self.assertLess(elapsed, MAX_SECONDS) + + def test_redis_down(self): + compose("stop", "redis") + self.addCleanup(wait_ready) + self.addCleanup(compose, "start", "redis") + + # сессию проверить нечем: запрос с настоящим токеном не выполняется, но и чужим не становится + self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user)) + self.assert_unavailable(timed("GET", self.messages, user=self.user)) + self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user)) + # поддельный токен тоже не принимается за действующий + self.assert_unavailable(timed("GET", "/api/v1/users/me", user={"token": "x" * 43})) + # без токена ответ прежний, Redis для него не нужен + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) + self.assertEqual(call("GET", self.messages)[0], 401) + # новую сессию создать негде + self.assert_unavailable(timed("POST", "/api/v1/auth/sessions", + headers=basic(self.user["username"], self.user["password"]))) + self.assert_unavailable(timed("GET", "/health/ready")) + self.assertEqual(call("GET", "/health/live")[0], 200) + + compose("start", "redis") + wait_ready() + # прежний токен снова работает: сессия пережила остановку Redis, а сообщение во время отказа не записалось + self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"]) + self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"]) + + def test_postgres_down(self): + compose("stop", "postgres") + self.addCleanup(wait_ready) + self.addCleanup(compose, "start", "postgres") + + self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user)) + self.assert_unavailable(timed("GET", self.messages, user=self.user)) + self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user)) + self.assert_unavailable(timed("POST", "/api/v1/users", user_body())) + self.assert_unavailable(timed("POST", "/api/v1/auth/sessions", + headers=basic(self.user["username"], self.user["password"]))) + # проверка токена идёт в Redis, поэтому аноним по-прежнему получает 401 + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) + self.assert_unavailable(timed("GET", "/health/ready")) + self.assertEqual(call("GET", "/health/live")[0], 200) + + compose("start", "postgres") + wait_ready() + self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"]) + self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"]) + self.assertEqual(send(self.user, self.chat, "после восстановления")[0], 201) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/failures/test_expiry.py b/student-tests/failures/test_expiry.py new file mode 100644 index 00000000..c826b69c --- /dev/null +++ b/student-tests/failures/test_expiry.py @@ -0,0 +1,54 @@ +"""Истечение сессии. Проверяется на втором экземпляре API с SESSION_TTL_SECONDS=2 (порт 8081).""" +import datetime +import time +import unittest + +from stand import call, compose, wait_ready +from api import login, new_user + +SHORT_TTL_URL = "http://localhost:8081" + + +class SessionExpiryTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + compose("--profile", "test", "up", "-d", "api-short-ttl") + cls.addClassCleanup(compose, "--profile", "test", "rm", "-sf", "api-short-ttl") + wait_ready(SHORT_TTL_URL) + + def test_session_expires(self): + user = new_user("ttl", base_url=SHORT_TTL_URL) + self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 200) + time.sleep(3) + status, body, headers = call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL) + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer ")) + # logout с истёкшим токеном тоже 401 + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user, base_url=SHORT_TTL_URL)[0], 401) + + def test_expires_at_matches_ttl(self): + user = new_user("ttl", base_url=SHORT_TTL_URL) + _, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL) + expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00") + left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds() + self.assertTrue(0 < left <= 2.5, left) + + def test_requests_do_not_extend_session(self): + user = new_user("ttl", base_url=SHORT_TTL_URL) + deadline = time.monotonic() + 3 + while time.monotonic() < deadline: + call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL) + time.sleep(0.2) + self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 401) + + def test_login_after_expiry(self): + user = new_user("ttl", base_url=SHORT_TTL_URL) + time.sleep(3) + status, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL) + self.assertEqual(status, 201) + self.assertEqual(call("GET", "/api/v1/users/me", user=session, base_url=SHORT_TTL_URL)[0], 200) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/failures/test_transactions.py b/student-tests/failures/test_transactions.py new file mode 100644 index 00000000..466e0152 --- /dev/null +++ b/student-tests/failures/test_transactions.py @@ -0,0 +1,65 @@ +"""Проверки на уровне БД: откат составной операции, гонка регистрации, повторный запуск миграций.""" +import threading +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor + +from stand import call, compose, sql, wait_ready +from api import new_user, user_body + + +class TransactionTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + wait_ready() + cls.alice, cls.bob = new_user("alice"), new_user("bob") + + def create_chat(self, title, member_ids): + return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice) + + def test_chat_with_unknown_member_is_rolled_back(self): + title = "rollback-" + uuid.uuid4().hex + # Алиса и Боб существуют, третьего участника нет: вставка чата и двух участников уже выполнена, + # на третьем срабатывает внешний ключ, и транзакция должна откатить всё + status, body, _ = self.create_chat(title, [self.alice["id"], self.bob["id"], str(uuid.uuid4())]) + self.assertEqual(status, 400) + self.assertEqual(body["error"]["code"], "invalid_request") + self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "0") + self.assertEqual(sql("SELECT count(*) FROM chat_members m LEFT JOIN chats c ON c.id = m.chat_id WHERE c.id IS NULL"), "0") + + def test_valid_chat_is_committed_whole(self): + title = "commit-" + uuid.uuid4().hex + status, chat, _ = self.create_chat(title, [self.alice["id"], self.bob["id"]]) + self.assertEqual(status, 201) + self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "1") + self.assertEqual(sql("SELECT count(*) FROM chat_members WHERE chat_id = '%s'" % chat["id"]), "2") + + def test_username_race_creates_one_row(self): + body = user_body(username="race_" + uuid.uuid4().hex[:8]) + barrier = threading.Barrier(10) + + def register(_): + barrier.wait() + return call("POST", "/api/v1/users", body)[0] + + with ThreadPoolExecutor(max_workers=10) as pool: + statuses = sorted(pool.map(register, range(10))) + self.assertEqual(statuses, [201] + [409] * 9) + self.assertEqual(sql("SELECT count(*) FROM users WHERE username = '%s'" % body["username"]), "1") + + def test_password_is_stored_as_argon2id_hash(self): + stored = sql("SELECT password_hash FROM users WHERE id = '%s'" % self.alice["id"]) + self.assertTrue(stored.startswith("$argon2id$"), stored[:12]) + self.assertNotIn(self.alice["password"], stored) + + def test_migrations_can_be_repeated(self): + before = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)") + output = compose("run", "--rm", "migrate") + self.assertIn("уже применена: 0001_init.sql", output) + self.assertEqual(sql("SELECT count(*) FROM schema_migrations"), "1") + after = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)") + self.assertEqual(before, after) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_access.py b/student-tests/test_access.py new file mode 100644 index 00000000..e29c254c --- /dev/null +++ b/student-tests/test_access.py @@ -0,0 +1,77 @@ +import unittest +import uuid + +from api import call, new_chat, new_user, send + + +class ForeignChatTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve") + cls.chat = new_chat(cls.alice, cls.bob) + cls.path = "/api/v1/chats/" + cls.chat["id"] + send(cls.alice, cls.chat, "секрет") + + def test_outsider_gets_404_everywhere(self): + self.assertEqual(call("GET", self.path, user=self.eve)[0], 404) + self.assertEqual(call("GET", self.path + "/messages", user=self.eve)[0], 404) + status, body, _ = send(self.eve, self.chat, "я тут") + self.assertEqual(status, 404) + self.assertEqual(body["error"]["code"], "not_found") + + def test_foreign_chat_looks_like_missing_chat(self): + _, foreign, _ = call("GET", self.path, user=self.eve) + _, missing, _ = call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=self.eve) + self.assertEqual(foreign["error"]["message"], missing["error"]["message"]) + + def test_outsider_message_is_not_saved(self): + send(self.eve, self.chat, "не должно появиться") + _, page, _ = call("GET", self.path + "/messages", user=self.alice) + self.assertNotIn("не должно появиться", [item["text"] for item in page["items"]]) + + def test_chat_is_not_listed_for_outsider(self): + _, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.eve) + self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]]) + _, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob) + self.assertIn(self.chat["id"], [item["id"] for item in page["items"]]) + + def test_members_can_read_and_write(self): + self.assertEqual(send(self.bob, self.chat, "ответ")[0], 201) + self.assertEqual(call("GET", self.path, user=self.bob)[0], 200) + + def test_bad_chat_id(self): + self.assertEqual(call("GET", "/api/v1/chats/123", user=self.alice)[0], 400) + + +class CreateChatTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.alice, cls.bob = new_user("alice"), new_user("bob") + + def create(self, member_ids, title="Чат"): + return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)[0] + + def test_creator_must_be_member(self): + self.assertEqual(self.create([self.bob["id"]]), 400) + + def test_duplicate_members(self): + self.assertEqual(self.create([self.alice["id"], self.bob["id"], self.bob["id"]]), 400) + + def test_unknown_member(self): + self.assertEqual(self.create([self.alice["id"], str(uuid.uuid4())]), 400) + + def test_empty_members(self): + self.assertEqual(self.create([]), 400) + + def test_blank_title(self): + self.assertEqual(self.create([self.alice["id"]], title=" "), 400) + + def test_failed_create_leaves_no_chat(self): + _, before, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob) + self.create([self.alice["id"], self.bob["id"], str(uuid.uuid4())]) + _, after, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob) + self.assertEqual(before, after) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..b63547b9 --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,144 @@ +import datetime +import unittest +import uuid + +from api import basic, call, login, new_user, user_body + + +class LoginTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.body = user_body() + _, cls.user, _ = call("POST", "/api/v1/users", cls.body) + + def assert_basic_challenge(self, result): + status, body, headers = result + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + self.assertTrue(headers["WWW-Authenticate"].startswith("Basic ")) + return body + + def test_login(self): + status, session, _ = login(self.body["username"], self.body["password"]) + self.assertEqual(status, 201) + self.assertEqual(set(session), {"token", "token_type", "expires_at", "user"}) + self.assertEqual(session["token_type"], "Bearer") + self.assertEqual(session["user"], self.user) + self.assertGreaterEqual(len(session["token"]), 32) + expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00") + left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds() + self.assertTrue(300 <= left <= 3600 + 5, left) + + def test_token_is_opaque_and_unique(self): + first = login(self.body["username"], self.body["password"])[1]["token"] + second = login(self.body["username"], self.body["password"])[1]["token"] + self.assertNotEqual(first, second) + for token in (first, second): + self.assertNotIn(self.user["id"], token) + self.assertNotIn(self.body["username"], token) + self.assertEqual(call("GET", "/api/v1/users/me", user={"token": token})[0], 200) + + def test_wrong_password_and_unknown_user_look_the_same(self): + wrong = self.assert_basic_challenge(login(self.body["username"], "wrong-password-123")) + unknown = self.assert_basic_challenge(login("nobody_" + uuid.uuid4().hex[:8], self.body["password"])) + self.assertEqual(wrong["error"]["message"], unknown["error"]["message"]) + + def test_malformed_credentials(self): + token = login(self.body["username"], self.body["password"])[1]["token"] + for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic bm8tY29sb24=", "Bearer " + token, "Basic 0KU6"): + with self.subTest(header=header): + headers = {"Authorization": header} if header else {} + self.assert_basic_challenge(call("POST", "/api/v1/auth/sessions", headers=headers)) + + def test_garbage_after_basic_is_401_not_500(self): + # значение заголовка приходит на сервер как latin-1, поэтому после Basic может оказаться не ASCII + values = ("\u00e9", "\u00e9\u00e9\u00e9=", "\u00ff\u00fe", "//46cHc=", "=", "====", "a", " ", "A" * 5000, "Og==", + "dXNlcjpwYXNz dXNlcjpwYXNz") + for value in values: + with self.subTest(value=ascii(value[:16])): + result = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + value}) + self.assert_basic_challenge(result) + + def test_username_that_cannot_exist(self): + for username in ("", "Has Space", "ab\u0000cd", "имя_кириллицей"): + with self.subTest(username=username): + self.assert_basic_challenge(login(username, self.body["password"])) + + def test_colon_and_unicode_in_password(self): + body = user_body(password="пароль:с:двоеточиями") + self.assertEqual(call("POST", "/api/v1/users", body)[0], 201) + self.assertEqual(login(body["username"], body["password"])[0], 201) + self.assert_basic_challenge(login(body["username"], "пароль")) + + +class BearerTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.alice, cls.eve = new_user("alice"), new_user("eve") + + def assert_bearer_challenge(self, result): + status, body, headers = result + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer ")) + + def test_no_token(self): + self.assert_bearer_challenge(call("GET", "/api/v1/users/me")) + + def test_unknown_tokens(self): + for token in ("x" * 43, self.alice["id"], self.alice["username"], self.alice["token"][:-1]): + with self.subTest(token=token[:8]): + self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token})) + + def test_garbage_token_is_401_not_500(self): + for token in ("\u00e9", "\u00ff\u00fe", "a b", "x" * 10000): + with self.subTest(token=ascii(token[:16])): + self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token})) + + def test_basic_is_not_accepted_on_business_endpoints(self): + headers = basic(self.alice["username"], self.alice["password"]) + self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers=headers)) + self.assert_bearer_challenge(call("GET", "/api/v1/chats", headers=headers)) + + def test_x_user_id_gives_no_access(self): + self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers={"X-User-Id": self.alice["id"]})) + + def test_x_user_id_does_not_change_identity(self): + status, me, _ = call("GET", "/api/v1/users/me", user=self.alice, headers={"X-User-Id": self.eve["id"]}) + self.assertEqual(status, 200) + self.assertEqual(me, self.alice["user"]) + + def test_token_is_checked_before_anything_else(self): + self.assert_bearer_challenge(call("GET", "/api/v1/chats/not-a-uuid")) + self.assert_bearer_challenge(call("GET", "/api/v1/chats?limit=0")) + self.assert_bearer_challenge(call("POST", "/api/v1/chats", {"title": 5})) + + +class LogoutTest(unittest.TestCase): + def test_logout_revokes_only_current_session(self): + user = new_user() + other_token = login(user["username"], user["password"])[1]["token"] + + status, body, _ = call("DELETE", "/api/v1/auth/sessions/current", user=user) + self.assertEqual(status, 204) + self.assertIsNone(body) + + self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401) + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user)[0], 401) + # вторая сессия того же пользователя продолжает работать + self.assertEqual(call("GET", "/api/v1/users/me", user={"token": other_token})[0], 200) + + def test_login_again_after_logout(self): + user = new_user() + call("DELETE", "/api/v1/auth/sessions/current", user=user) + status, session, _ = login(user["username"], user["password"]) + self.assertEqual(status, 201) + self.assertNotEqual(session["token"], user["token"]) + self.assertEqual(call("GET", "/api/v1/users/me", user=session)[0], 200) + + def test_logout_requires_token(self): + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current")[0], 401) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..6d13bdf1 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,63 @@ +"""Проверка гонок: 10 клиентов параллельно отправляют 100 сообщений в один чат.""" +import threading +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor + +from api import call, history, new_chat, new_user, send, user_body + +CLIENTS = 10 +MESSAGES_PER_CLIENT = 10 + + +class ConcurrencyTest(unittest.TestCase): + def test_100_messages_from_10_clients(self): + users = [new_user("c%d" % number) for number in range(CLIENTS)] + chat = new_chat(users[0], *users[1:]) + barrier = threading.Barrier(CLIENTS) + + def client(number): + barrier.wait() # все потоки стартуют одновременно + results = [] + for index in range(MESSAGES_PER_CLIENT): + results.append(send(users[number], chat, "клиент %d сообщение %d" % (number, index))) + return results + + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + results = [result for chunk in pool.map(client, range(CLIENTS)) for result in chunk] + + total = CLIENTS * MESSAGES_PER_CLIENT + self.assertEqual([status for status, _, _ in results], [201] * total) + confirmed = {message["id"]: message for _, message, _ in results} + self.assertEqual(len(confirmed), total) + + items, _ = history(users[0], chat, limit=7) + self.assertEqual(len(items), total) + self.assertEqual(len({item["id"] for item in items}), total) + self.assertEqual(len({item["text"] for item in items}), total) + # каждое подтверждённое сообщение есть в истории без изменений + self.assertEqual({item["id"]: item for item in items}, confirmed) + keys = [(item["created_at"], item["id"]) for item in items] + self.assertEqual(keys, sorted(keys)) + # сообщения одного клиента идут в том порядке, в котором он их отправлял + for number in range(CLIENTS): + own = [item["text"] for item in items if item["sender_id"] == users[number]["id"]] + self.assertEqual(own, ["клиент %d сообщение %d" % (number, index) for index in range(MESSAGES_PER_CLIENT)]) + print("\nотправлено %d, подтверждено %d, в истории %d, уникальных id %d" + % (total, len(confirmed), len(items), len({item["id"] for item in items}))) + + def test_same_username_registered_once(self): + body = user_body(username="race_" + uuid.uuid4().hex[:8]) + barrier = threading.Barrier(CLIENTS) + + def register(_): + barrier.wait() + return call("POST", "/api/v1/users", body)[0] + + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + statuses = sorted(pool.map(register, range(CLIENTS))) + self.assertEqual(statuses, [201] + [409] * (CLIENTS - 1)) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_pagination.py b/student-tests/test_pagination.py new file mode 100644 index 00000000..5b7d8702 --- /dev/null +++ b/student-tests/test_pagination.py @@ -0,0 +1,145 @@ +import base64 +import json +import unittest +import urllib.parse + +from api import call, history, new_chat, new_user, send + + +class MessagePaginationTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.user = new_user() + cls.chat = new_chat(cls.user) + cls.sent = [send(cls.user, cls.chat, "сообщение %d" % number)[1] for number in range(25)] + cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages" + + def test_walk_several_pages(self): + items, sizes = history(self.user, self.chat, limit=10) + self.assertEqual(sizes, [10, 10, 5]) + self.assertEqual(items, self.sent) + + def test_no_duplicates_and_order(self): + items, _ = history(self.user, self.chat, limit=7) + ids = [item["id"] for item in items] + self.assertEqual(len(ids), len(set(ids))) + keys = [(item["created_at"], item["id"]) for item in items] + self.assertEqual(keys, sorted(keys)) + + def test_exact_page_has_no_cursor(self): + _, page, _ = call("GET", self.path + "?limit=25", user=self.user) + self.assertEqual(len(page["items"]), 25) + self.assertIsNone(page["next_cursor"]) + + def test_default_limit(self): + _, page, _ = call("GET", self.path, user=self.user) + self.assertEqual(len(page["items"]), 25) + + def test_limit_can_change_between_pages(self): + _, first, _ = call("GET", self.path + "?limit=3", user=self.user) + cursor = urllib.parse.quote(first["next_cursor"], safe="") + _, second, _ = call("GET", self.path + "?limit=100&cursor=" + cursor, user=self.user) + self.assertEqual(first["items"] + second["items"], self.sent) + + def test_bad_limit(self): + for limit in ("0", "101", "-1", "abc", "1.5", ""): + with self.subTest(limit=limit): + self.assertEqual(call("GET", self.path + "?limit=" + limit, user=self.user)[0], 400) + + def test_bad_cursor(self): + for cursor in ("garbage", "", "e30=", "%D0%B9"): + with self.subTest(cursor=cursor): + self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400) + + def test_cursor_format_is_checked(self): + _, first, _ = call("GET", self.path + "?limit=3", user=self.user) + good = first["next_cursor"] + scope, created_at, item_id = json.loads(base64.urlsafe_b64decode(good)) + + def encode(value, **options): + return base64.urlsafe_b64encode(json.dumps(value, **options).encode()).decode() + + # тест знает внутренний формат cursor: собранный заново правильный cursor совпадает с выданным + self.assertEqual(encode([scope, created_at, item_id]), good) + bad = { + "посторонний символ внутри base64": good[:5] + "!" + good[5:], + "пробел внутри base64": good[:5] + " " + good[5:], + "перевод строки в конце": good + "\n", + "лишний знак =": good + "=", + "обрезанный": good[:-4], + "время не в формате сервера": encode([scope, "вчера", item_id]), + "время без микросекунд": encode([scope, created_at[:19] + "Z", item_id]), + "время с неполными микросекундами": encode([scope, created_at[:21] + "Z", item_id]), + "время со смещением вместо Z": encode([scope, created_at[:-1] + "+00:00", item_id]), + "несуществующая дата": encode([scope, "2026-13-45T25:61:61.000000Z", item_id]), + "число вместо времени": encode([scope, 1234567890, item_id]), + "id не UUID": encode([scope, created_at, "abc"]), + "UUID в верхнем регистре": encode([scope, created_at, item_id.upper()]), + "UUID без дефисов": encode([scope, created_at, item_id.replace("-", "")]), + "null вместо id": encode([scope, created_at, None]), + "лишний элемент": encode([scope, created_at, item_id, "x"]), + "не хватает элемента": encode([scope, created_at]), + "объект вместо списка": encode({"scope": scope, "created_at": created_at, "id": item_id}), + "тот же JSON без пробелов": encode([scope, created_at, item_id], separators=(",", ":")), + "пустой список": encode([]), + } + for name, cursor in bad.items(): + with self.subTest(name): + path = self.path + "?cursor=" + urllib.parse.quote(cursor, safe="") + status, body, _ = call("GET", path, user=self.user) + self.assertEqual(status, 400) + self.assertEqual(body["error"]["code"], "invalid_request") + # правильный cursor при этом продолжает работать + self.assertEqual(call("GET", self.path + "?cursor=" + urllib.parse.quote(good, safe=""), user=self.user)[0], 200) + + def test_cursor_from_another_chat(self): + other = new_chat(self.user, title="Другой чат") + send(self.user, other, "раз") + send(self.user, other, "два") + _, page, _ = call("GET", "/api/v1/chats/" + other["id"] + "/messages?limit=1", user=self.user) + cursor = urllib.parse.quote(page["next_cursor"], safe="") + self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400) + + def test_new_message_appears_after_last_page(self): + user = new_user() + chat = new_chat(user) + send(user, chat, "раз") + send(user, chat, "два") + path = "/api/v1/chats/" + chat["id"] + "/messages" + _, first, _ = call("GET", path + "?limit=1", user=user) + _, created, _ = send(user, chat, "три") + cursor = urllib.parse.quote(first["next_cursor"], safe="") + _, rest, _ = call("GET", path + "?limit=100&cursor=" + cursor, user=user) + self.assertEqual([item["text"] for item in rest["items"]], ["два", "три"]) + self.assertEqual(rest["items"][-1], created) + + +class ChatPaginationTest(unittest.TestCase): + def test_walk_chat_list(self): + user = new_user() + created = [new_chat(user, title="Чат %d" % number) for number in range(5)] + items, cursor = [], None + while True: + path = "/api/v1/chats?limit=2" + if cursor: + path += "&cursor=" + urllib.parse.quote(cursor, safe="") + status, page, _ = call("GET", path, user=user) + self.assertEqual(status, 200) + self.assertLessEqual(len(page["items"]), 2) + items += page["items"] + cursor = page["next_cursor"] + if cursor is None: + break + self.assertEqual(items, created) + + def test_chat_cursor_belongs_to_user(self): + alice, bob = new_user("alice"), new_user("bob") + for number in range(2): + new_chat(alice, bob, title="Общий %d" % number) + _, page, _ = call("GET", "/api/v1/chats?limit=1", user=alice) + cursor = urllib.parse.quote(page["next_cursor"], safe="") + self.assertEqual(call("GET", "/api/v1/chats?cursor=" + cursor, user=bob)[0], 400) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_validation.py b/student-tests/test_validation.py new file mode 100644 index 00000000..b39b4576 --- /dev/null +++ b/student-tests/test_validation.py @@ -0,0 +1,122 @@ +import unittest + +from api import call, login, new_chat, new_user, send, user_body + + +class ErrorFormatTest(unittest.TestCase): + def assert_error(self, result, status, code): + got_status, body, headers = result + self.assertEqual(got_status, status) + self.assertEqual(set(body), {"error"}) + self.assertEqual(set(body["error"]), {"code", "message", "request_id"}) + self.assertEqual(body["error"]["code"], code) + self.assertTrue(body["error"]["message"]) + self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"]) + + +class InvalidJsonTest(ErrorFormatTest): + def test_malformed_json(self): + self.assert_error(call("POST", "/api/v1/users", raw=b'{"username": "abc", '), 400, "invalid_request") + + def test_not_an_object(self): + self.assert_error(call("POST", "/api/v1/users", raw=b'["abc"]'), 400, "invalid_request") + + def test_extra_field(self): + self.assert_error(call("POST", "/api/v1/users", user_body(is_admin=True)), 400, "invalid_request") + + def test_wrong_type(self): + self.assert_error(call("POST", "/api/v1/users", user_body(username=12345)), 400, "invalid_request") + + def test_missing_field(self): + body = user_body() + del body["password"] + self.assert_error(call("POST", "/api/v1/users", body), 400, "invalid_request") + + def test_malformed_json_in_message(self): + user = new_user() + chat = new_chat(user) + path = "/api/v1/chats/" + chat["id"] + "/messages" + self.assert_error(call("POST", path, raw=b"{text: no quotes}", user=user), 400, "invalid_request") + + +class UserValidationTest(ErrorFormatTest): + def test_bad_usernames(self): + for username in ("ab", "a" * 33, "Alice", "with space", "имя", "abc\n", ""): + with self.subTest(username=username): + self.assert_error(call("POST", "/api/v1/users", user_body(username=username)), 400, "invalid_request") + + def test_bad_display_names(self): + for display_name in ("", " ", "\t\n", "я" * 101, "имя\u0000"): + with self.subTest(display_name=display_name): + result = call("POST", "/api/v1/users", user_body(display_name=display_name)) + self.assert_error(result, 400, "invalid_request") + + def test_display_name_length_is_counted_in_code_points(self): + # 100 эмодзи это 400 байт в UTF-8, но ровно 100 code points + status, user, _ = call("POST", "/api/v1/users", user_body(display_name="🙂" * 100)) + self.assertEqual(status, 201) + self.assertEqual(user["display_name"], "🙂" * 100) + + def test_bad_passwords(self): + for password in ("short-11-ch", "x" * 129, " " * 12, "", 123456789012, None): + with self.subTest(password=password): + self.assert_error(call("POST", "/api/v1/users", user_body(password=password)), 400, "invalid_request") + + def test_password_length_limits(self): + for password in ("exactly-12-c", "x" * 128, "пароль🙂пароль"): + with self.subTest(length=len(password)): + body = user_body(password=password) + self.assertEqual(call("POST", "/api/v1/users", body)[0], 201) + self.assertEqual(login(body["username"], password)[0], 201) + + def test_password_is_never_returned(self): + body = user_body() + status, user, _ = call("POST", "/api/v1/users", body) + self.assertEqual(status, 201) + self.assertEqual(set(user), {"id", "username", "display_name", "created_at"}) + _, session, _ = login(body["username"], body["password"]) + self.assertNotIn(body["password"], str(session)) + + def test_duplicate_username(self): + body = user_body(display_name="Первый") + self.assertEqual(call("POST", "/api/v1/users", body)[0], 201) + body["display_name"] = "Второй" + self.assert_error(call("POST", "/api/v1/users", body), 409, "conflict") + + +class MessageValidationTest(ErrorFormatTest): + @classmethod + def setUpClass(cls): + cls.user = new_user() + cls.chat = new_chat(cls.user) + + def test_empty_message(self): + self.assert_error(send(self.user, self.chat, ""), 400, "invalid_request") + + def test_whitespace_message(self): + for text in (" ", " \n\t ", "  "): + with self.subTest(text=repr(text)): + self.assert_error(send(self.user, self.chat, text), 400, "invalid_request") + + def test_nul_character(self): + self.assert_error(send(self.user, self.chat, "до\u0000после"), 400, "invalid_request") + + def test_text_limit(self): + self.assertEqual(send(self.user, self.chat, "ы" * 4000)[0], 201) + self.assert_error(send(self.user, self.chat, "ы" * 4001), 400, "invalid_request") + + def test_sender_id_is_not_accepted(self): + path = "/api/v1/chats/" + self.chat["id"] + "/messages" + body = {"text": "привет", "sender_id": self.user["id"]} + self.assert_error(call("POST", path, body, user=self.user), 400, "invalid_request") + + def test_unicode_is_kept(self): + text = "Привет 👋 你好 مرحبا\nвторая строка" + status, message, _ = send(self.user, self.chat, text) + self.assertEqual(status, 201) + self.assertEqual(message["text"], text) + self.assertEqual(message["sender_id"], self.user["id"]) + + +if __name__ == "__main__": + unittest.main()