diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..9cb982cd --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.sh text eol=lf +Dockerfile text eol=lf +*.sql text eol=lf +*.py text eol=lf +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a71896..a4d6b444 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,9 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. + +# lab2 +secrets/ +.env +.venv/ +__pycache__/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..9c2d536e --- /dev/null +++ b/Dockerfile @@ -0,0 +1,11 @@ +FROM python:3.12.7-slim-bookworm +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /app +COPY src/requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +COPY src/ . +RUN useradd -r -u 10001 appuser +USER appuser +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --retries=10 CMD python -c "import urllib.request as u;u.urlopen('http://127.0.0.1:8080/health/live',timeout=2)" +CMD ["uvicorn","app.main:app","--host","0.0.0.0","--port","8080"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..900b5272 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,110 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Корнилов Михаил Андреевич, БПИ2304 +- Целевая оценка: 3. +- Commit/PR: TODO после публикации (commit, на котором собраны доказательства, указан в `evidence/01-env.txt`) +- Использованные источники, библиотеки и помощь ИИ: Библиотеки: starlette, uvicorn, psycopg 3 + psycopg_pool, argon2-cffi. Каталог `tests/` и `contracts/` курса не менялись. При подготовке использовалась помощь Claude ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Стенд проверялся на Windows + Docker Desktop (WSL2): Docker 28.0.4, Compose v2.34.0, Python 3.11.5 для тестов, хост 16 CPU / 8 ГБ. Образы: `postgres:16.4-alpine`, `python:3.12.7-slim-bookworm` (версии закреплены). + +Команды выполняются в Git Bash (на Linux/macOS — в любом sh) из корня репозитория: + +```sh +sh scripts/setup-secrets.sh # создаёт secrets/pg_password и secrets/database_url (в .gitignore, значения не печатаются) +docker compose up -d --build # миграции применяются при старте API +curl http://localhost:8080/health/ready # ждём {"status":"ok"} +python tests/smoke.py --base-url http://localhost:8080 # = make test +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080 + # на Linux/macOS: --action-script scripts/restart.sh (= make test-persistence) +sh scripts/collect-evidence.sh # все проверки ниже и сохранение в evidence/ (--fresh сначала удаляет данные) +docker compose stop # безопасная остановка: контейнеры остановлены, данные сохранены +docker compose down -v # ОСОЗНАННОЕ удаление учебных данных (том pgdata) +``` + +Действия оператора: только `setup-secrets.sh` (создать секреты). `.env` не обязателен: у переменных есть значения по умолчанию в `compose.yaml`; при желании `cp .env.example .env`. Порт API опубликован только на `127.0.0.1:8080`, PostgreSQL наружу не опубликован. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → API (Starlette/uvicorn, непривилегированный пользователь в контейнере) → PostgreSQL 16 (именованный том `pgdata`). Источник истины — PostgreSQL, сессии тоже хранятся там, поэтому они переживают рестарт API и БД. + +- Таблицы: `users`, `chats`, `chat_members`, `messages`, `sessions`, `schema_migrations`; PK/FK, `UNIQUE(username)`, CHECK на длины и формат (схема — `evidence/05-db-schema.txt`). +- Миграции: `src/migrations/*.sql`, применяются при старте API по порядку под advisory lock, версии пишутся в `schema_migrations`; повторный запуск ничего не дублирует. +- Транзакционная граница: создание чата (чат + участники) выполняется в одной транзакции. +- Пароли: Argon2id (argon2-cffi, параметры по умолчанию). Токен: `secrets.token_urlsafe(32)` (256 бит); в БД хранится только sha256 токена (32 байта). +- Basic принимается только на `POST /auth/sessions`; остальные endpoint — только Bearer. `X-User-Id` игнорируется. Logout ставит `revoked_at`; срок жизни — `SESSION_TTL_SECONDS` (по умолчанию 3600). +- История сообщений: keyset по `(created_at, id)`, индекс `messages(chat_id, created_at, id)`, cursor привязан к чату. +- Готовность: `/health/live` не зависит от БД; `/health/ready` и бизнес-endpoint при недоступной БД отвечают 503 в общем формате ошибок. Пул соединений (`min 2`, `max DB_POOL_MAX=10`, таймаут получения соединения 2 с) восстанавливается сам. + +**Из lab1 перенесено:** все endpoint (`/users`, `/users/me`, `/chats`, `/chats/{id}`, сообщения), формат ошибок и `X-Request-Id`, валидация полей, keyset-пагинация, коды 400/401/404/413/415. Хранилище in-memory заменено PostgreSQL. +**Изменено по объявленным переходам:** при регистрации передаётся `password`; вместо `X-User-Id` — сессии (`POST /auth/sessions`, `DELETE /auth/sessions/current`, Bearer). Неверный UUID в пути везде даёт 400, как в lab1. + +**Соответствие `.env.example`:** + +| Переменная | Статус | +| --- | --- | +| `SESSION_TTL_SECONDS` | используется (compose передаёт в API) | +| `DATABASE_URL_FILE` | используется (`/run/secrets/database_url`, Docker secret) | +| `APP_ENV` | передаётся в контейнер, приложением не читается | +| `APP_HOST`, `APP_PORT` | не читаются; адрес и порт заданы в `CMD` Dockerfile (`0.0.0.0:8080`), наружу порт публикуется на `127.0.0.1` | +| `SESSION_STORE=postgres` | только маркер: сессии всегда в PostgreSQL | +| `CACHE_URL_FILE` | не используется (Redis/Valkey нужен на 4) | +| `DB_POOL_MAX` | читается приложением (по умолчанию 10), в `.env.example` отсутствует | ## Доказательства критериев +Все файлы лежат в `evidence/`; они собраны одним запуском `sh scripts/collect-evidence.sh`, токены и пароли в них не печатаются. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `python tests/smoke.py` | PASS; `scripts/check_contract.py` — PASS | `02-smoke.txt` | +| PostgreSQL, PK/FK, уникальный username | `\d` по всем таблицам | `users_pkey`, `UNIQUE(username)`, FK `chat_members`/`messages`/`sessions`, индексы истории | `05-db-schema.txt` | +| Версионируемые миграции, повтор без дублей | рестарт API + 2 явных вызова `migrate.run` | одна запись `001_init.sql`, число users/messages не изменилось | `06-migrations.txt` | +| Пароль хранится как KDF-хэш | `select left(password_hash,10)` | 10 из 10 хэшей начинаются с `$argon2id$` | `05-db-schema.txt` | +| Токен не хранится в открытом виде | `select length(token_hash)` | 10 из 10 — 32 байта (sha256) | `05-db-schema.txt` | +| Basic только на входе, Bearer на остальном; `X-User-Id` игнорируется | собственные проверки | Basic на `/users/me` → 401; один `X-User-Id` → 401; при Bearer + чужом `X-User-Id` владелец определяется токеном | `03-student-checks.txt` | +| Вход неотличим при неверном пароле и неизвестном пользователе | собственные проверки | оба случая 401 с одинаковыми code/message/`WWW-Authenticate` | `03-student-checks.txt` | +| Logout и срок жизни сессии | logout; TTL=2 с | logout 204, повтор → 401, токен после logout → 401; при TTL=2 токен рабочий сразу и недействителен через 3,5 с | `03-student-checks.txt`, `07-ttl.txt` | +| Гонка регистрации одного username | 10 параллельных запросов | ровно один 201, остальные 409 | `03-student-checks.txt` | +| Атомарное создание чата | чат с несуществующим участником | 400, число чатов пользователя не изменилось | `03-student-checks.txt` | +| Доступ только участникам | запросы постороннего | 404 на чат, историю и отправку; неверный UUID → 400 | `03-student-checks.txt` | +| Пагинация | `limit=2`, cursor | 6 сообщений без повторов; cursor другого чата, `limit=0/101/abc/+5`, повтор параметра → 400 | `03-student-checks.txt` | +| Сохранность при рестарте API и БД | `tests/resilience.py --mode persistence`, hook `scripts/restart.cmd` | PASS; `StartedAt` обоих контейнеров изменился, `RestartCount=0`; после рестарта в БД users=10, chats=4, messages=9, sessions=10 | `04-persistence.txt` | +| Hook действительно перезапускает процессы | `docker inspect … StartedAt` до/после | postgres 18:07:23 → 18:07:42, api 18:07:27 → 18:07:43 (UTC) | `04-persistence.txt` | +| Compose: именованный том, версии образов, готовность | `docker compose config/images/ps` | том `mtusi2026lab2_pgdata`, образы закреплены, оба сервиса `healthy` | `01-env.txt`, `05-db-schema.txt` | +| Секреты и volumes вне Git | `git check-ignore`, `git ls-files` | `secrets/` и `.env` игнорируются, отслеживаемых секретов нет | `09-git-hygiene.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Примечание к проверке hook: `tests/resilience.py` подтверждает сохранность данных и сессии, а какие процессы перезапущены, показывают значения `StartedAt` выше (перезапущены оба контейнера: сначала `postgres`, после `pg_isready` — `api`). ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Нагрузочные измерения (RPS, p50/p95/p99) на уровне 3 не проводились. Проверены отказы: | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Рестарт `postgres` и `api` (`scripts/restart.cmd`) | данные и сессия сохраняются | PASS; оба контейнера перезапущены | ≈4 с до `/health/ready`; потерь нет | +| Рестарт только `api` | миграции не дублируются | одна запись `001_init.sql`, users и messages без изменений | готов сразу после старта; потерь нет | +| `docker compose stop postgres` при работающем API | `live` 200, `ready` и бизнес-endpoint 503 без падения API | `live` 200; `ready` и `/users/me` — 503 в общем формате (с `request_id`) | после `start postgres` `ready` вернулся ≈ через 1 с без рестарта API; потерь нет | +| `SESSION_TTL_SECONDS=2` | токен действует сразу и истекает | 200, затем 401 через 3,5 с | возврат к TTL 3600 пересозданием `api` | + +Версии, лимиты и загрузка на момент прогона — `evidence/01-env.txt`; значения времени восстановления — из прогона, лежащего в `evidence/`, на другой машине они могут отличаться на секунды. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Уровень 4 не реализован: нет Redis/Valkey, плана `EXPLAIN` на большом объёме и тестов отказа кэша. Нагрузочный эксперимент уровня 5 не выполнялся. +- Одна БД без репликации и бэкапов, один Docker-host: при потере тома `pgdata` данные потеряны (`down -v` делает это намеренно). +- Просроченные и отозванные сессии не удаляются из `sessions` (есть индекс по `expires_at`, но очистки нет): таблица растёт без фонового удаления. +- Время сообщения берётся из `clock_timestamp()` в момент вставки; при конкурентных вставках в один чат порядок коммитов может не совпасть с порядком времени, и keyset-cursor теоретически способен пропустить запись, зафиксированную позже. Практически не воспроизводилось; строгий порядок потребовал бы счётчика/последовательности на чат. +- API при старте завершается, если БД недоступна; восстановление обеспечивает `restart: unless-stopped` и `depends_on: service_healthy`. После старта пул соединений восстанавливается сам. +- Приложение не ограничивает частоту входа (нет rate limit), защита от перебора паролей — только стоимость Argon2id. +- Реализация учебная: работоспособна и проверена, но не претендует на промышленную готовность. + +## Windows (без make) + +```sh +python tests/smoke.py --base-url http://localhost:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080 +``` + +Секреты: `sh scripts/setup-secrets.sh` из Git Bash (входит в Git for Windows). Docker Desktop с бэкендом WSL2. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..ea93a10b --- /dev/null +++ b/compose.yaml @@ -0,0 +1,34 @@ +services: + postgres: + image: postgres:16.4-alpine + restart: unless-stopped + environment: + POSTGRES_USER: msg + POSTGRES_DB: msg + POSTGRES_PASSWORD_FILE: /run/secrets/pg_password + secrets: [pg_password] + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U msg -d msg"] + interval: 3s + timeout: 3s + retries: 20 + api: + build: . + restart: unless-stopped + depends_on: + postgres: {condition: service_healthy} + environment: + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + APP_ENV: ${APP_ENV:-lab} + secrets: [database_url] + ports: ["127.0.0.1:8080:8080"] +secrets: + pg_password: + file: ./secrets/pg_password + database_url: + file: ./secrets/database_url +volumes: + pgdata: diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh new file mode 100644 index 00000000..bb0f5d42 --- /dev/null +++ b/scripts/collect-evidence.sh @@ -0,0 +1,157 @@ +#!/bin/sh +# Собирает доказательства lab2 в evidence/*.txt. Запускать из Git Bash (Windows) или любого sh, +# когда стенд уже поднят: docker compose up -d --build. +# sh scripts/collect-evidence.sh # проверки на текущих данных +# sh scripts/collect-evidence.sh --fresh # сначала `docker compose down -v` (УДАЛЯЕТ учебные данные) и чистый старт +# Секреты и токены не печатаются. Скрипт сам перезапускает контейнеры, останавливает/запускает postgres и меняет TTL API +# на время проверки (потом возвращает 3600). Тома не удаляются, кроме режима --fresh. +set -u +export MSYS_NO_PATHCONV=1 # Git Bash: не превращать /run/... в Windows-пути +export PYTHONUTF8=1 # читаемый UTF-8 в evidence/*.txt (иначе кракозябры в Windows) +echo "Сбор доказательств: 9 шагов, 1-3 минуты. Прогресс печатается после каждого шага." +cd "$(dirname "$0")/.." || exit 1 +mkdir -p evidence +BASE="${BASE_URL:-http://localhost:8080}" +PY="" +for c in python python3 py; do + if "$c" --version >/dev/null 2>&1; then PY="$c"; break; fi +done +[ -n "$PY" ] || { echo "Не найден python (python/python3/py)"; exit 2; } +case "$(uname -s)" in + MINGW*|MSYS*|CYGWIN*) ACTION="scripts/restart.cmd" ;; + *) ACTION="scripts/restart.sh" ;; +esac + +now() { date -u +%Y-%m-%dT%H:%M:%SZ; } +sec() { date +%s; } +wait_ready() { + i=0 + until curl -fsS -m 3 "$BASE/health/ready" >/dev/null 2>&1; do + i=$((i + 1)); [ "$i" -gt 90 ] && return 1; sleep 1 + done + return 0 +} +started() { docker inspect -f '{{.Name}} StartedAt={{.State.StartedAt}} RestartCount={{.RestartCount}}' $(docker compose ps -q postgres api); } +psql_c() { docker compose exec -T postgres psql -U msg -d msg -c "$1"; } +RESULTS="" +note() { RESULTS="$RESULTS +$1"; echo "готово: $1"; } + +if [ "${1:-}" = "--fresh" ]; then + { + echo "# 00 чистый старт ($(now))" + echo "\$ docker compose down -v"; docker compose down -v + echo "\$ sh scripts/setup-secrets.sh"; sh scripts/setup-secrets.sh && echo "secrets: ok (значения не печатаются)" + t0=$(sec) + echo "\$ docker compose up -d --build"; docker compose up -d --build + if wait_ready; then echo "ready через $(( $(sec) - t0 )) с после запуска up"; else echo "НЕ ГОТОВ за 90 с"; fi + } > evidence/00-clean-start.txt 2>&1 + note "00 clean start -> evidence/00-clean-start.txt" +fi + +wait_ready || { echo "API не отвечает на $BASE/health/ready. Сначала: docker compose up -d --build"; exit 1; } + +{ + echo "# 01 окружение ($(now))" + echo "commit: $(git rev-parse HEAD 2>/dev/null || echo 'нет git')" + echo "git status:"; git status --short 2>/dev/null | head -20 + echo "\$ docker version"; docker version --format 'client={{.Client.Version}} server={{.Server.Version}} os={{.Server.Os}}/{{.Server.Arch}}' + echo "\$ docker compose version"; docker compose version + echo "python: $($PY --version 2>&1)" + echo "\$ docker compose config --quiet"; docker compose config --quiet && echo "compose config: OK" + echo "\$ docker compose images"; docker compose images + echo "\$ docker compose ps"; docker compose ps + echo "\$ docker volume ls (pgdata)"; docker volume ls | grep -i pgdata + echo "\$ docker stats --no-stream"; docker stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' $(docker compose ps -q) + echo "\$ docker info (лимиты хоста)"; docker info --format 'CPUs={{.NCPU}} Mem={{.MemTotal}}' +} > evidence/01-env.txt 2>&1 +note "01 окружение -> evidence/01-env.txt" + +{ + echo "# 02 публичные проверки ($(now))" + echo "\$ python scripts/check_contract.py"; $PY scripts/check_contract.py; echo "exit code: $?" + echo "\$ python tests/smoke.py --base-url $BASE"; $PY tests/smoke.py --base-url "$BASE"; echo "exit code: $?" +} > evidence/02-smoke.txt 2>&1 +note "02 smoke -> evidence/02-smoke.txt: $(grep -c '^PASS: lab2' evidence/02-smoke.txt) PASS-строк smoke" + +{ + echo "# 03 собственные проверки ($(now))" + echo "\$ python student-tests/lab2_checks.py --base-url $BASE" + $PY student-tests/lab2_checks.py --base-url "$BASE"; echo "exit code: $?" +} > evidence/03-student-checks.txt 2>&1 +note "03 собственные -> evidence/03-student-checks.txt: $(tail -2 evidence/03-student-checks.txt | head -1)" + +{ + echo "# 04 сохранность при рестарте API и PostgreSQL ($(now))" + echo "--- до"; started; docker compose ps + echo "\$ python tests/resilience.py --mode persistence --action-script $ACTION" + $PY tests/resilience.py --mode persistence --action-script "$ACTION" --base-url "$BASE"; echo "exit code: $?" + echo "--- после (StartedAt должен измениться у обоих контейнеров)"; started; docker compose ps + echo "--- время восстановления одного рестарта (hook + ожидание /health/ready)" + t0=$(sec); sh scripts/restart.sh; if wait_ready; then echo "готов через $(( $(sec) - t0 )) с"; else echo "НЕ ГОТОВ за 90 с"; fi + echo "--- проверка сохранности данных в БД после рестарта" + psql_c "select (select count(*) from users) users, (select count(*) from chats) chats, (select count(*) from messages) messages, (select count(*) from sessions) sessions" +} > evidence/04-persistence.txt 2>&1 +note "04 persistence -> evidence/04-persistence.txt: $(grep -m1 -E '^(PASS|FAIL): persistence' evidence/04-persistence.txt || echo 'см. файл')" + +{ + echo "# 05 схема БД ($(now))" + psql_c "select * from schema_migrations" + psql_c "\\dt" + for t in users chats chat_members messages sessions; do psql_c "\\d $t"; done + echo "--- пароли хранятся как Argon2id" + psql_c "select left(password_hash, 10) as hash_prefix, count(*) from users group by 1" + echo "--- в sessions только sha256 токена (32 байта), не сам токен" + psql_c "select length(token_hash) as token_hash_bytes, count(*) from sessions group by 1" + echo "--- volume с данными PostgreSQL" + docker inspect -f '{{range .Mounts}}{{.Type}} {{.Name}} -> {{.Destination}}{{println}}{{end}}' "$(docker compose ps -q postgres)" +} > evidence/05-db-schema.txt 2>&1 +note "05 схема БД -> evidence/05-db-schema.txt" + +{ + echo "# 06 повторный запуск миграций ($(now))" + echo "--- до"; psql_c "select version from schema_migrations"; psql_c "select (select count(*) from users) users, (select count(*) from messages) messages" + echo "--- рестарт API (миграции выполняются при старте)"; docker compose restart api >/dev/null; wait_ready && echo "ready" + echo "--- ещё два явных запуска migrate.run внутри контейнера api" + for n in 1 2; do docker compose exec -T api python -c "import app.migrate as m; m.run(open('/run/secrets/database_url').read().strip()); print('migrate.run ok')"; done + echo "--- после"; psql_c "select version from schema_migrations"; psql_c "select (select count(*) from users) users, (select count(*) from messages) messages" +} > evidence/06-migrations.txt 2>&1 +note "06 миграции повторно -> evidence/06-migrations.txt" + +{ + echo "# 07 истечение сессии при SESSION_TTL_SECONDS=2 ($(now))" + echo "\$ SESSION_TTL_SECONDS=2 docker compose up -d api" + SESSION_TTL_SECONDS=2 docker compose up -d api; wait_ready && echo "ready (TTL=2)" + $PY student-tests/lab2_checks.py --base-url "$BASE" --mode ttl; echo "exit code: $?" + echo "--- возврат к TTL по умолчанию" + docker compose up -d api; wait_ready && echo "ready (TTL по умолчанию)" +} > evidence/07-ttl.txt 2>&1 +note "07 TTL -> evidence/07-ttl.txt: $(grep -m1 -E '^(PASS|FAIL): (все|[0-9])' evidence/07-ttl.txt || echo 'см. файл')" + +{ + echo "# 08 недоступность PostgreSQL ($(now))" + echo "\$ docker compose stop postgres"; docker compose stop postgres >/dev/null; sleep 2 + echo "GET /health/live -> $(curl -s -m 5 -o /dev/null -w '%{http_code}' "$BASE/health/live")" + echo "GET /health/ready -> $(curl -s -m 15 -w ' %{http_code}' "$BASE/health/ready")" + echo "GET /api/v1/users/me (анонимный токен) -> $(curl -s -m 15 -w ' %{http_code}' -H 'Authorization: Bearer anonymous' "$BASE/api/v1/users/me")" + echo "\$ docker compose start postgres"; t0=$(sec); docker compose start postgres >/dev/null + if wait_ready; then echo "ready снова через $(( $(sec) - t0 )) с (без рестарта API)"; else echo "НЕ ВОССТАНОВИЛСЯ за 90 с"; fi + docker compose ps +} > evidence/08-db-down.txt 2>&1 +note "08 БД недоступна -> evidence/08-db-down.txt" + +{ + echo "# 09 секреты и volumes вне Git ($(now))" + if git rev-parse --git-dir >/dev/null 2>&1; then + echo "\$ git check-ignore -v secrets/pg_password secrets/database_url .env"; git check-ignore -v secrets/pg_password secrets/database_url .env + echo "\$ отслеживаемые файлы, похожие на секреты:"; git ls-files | grep -E '(^|/)(secrets/|\.env$|.*\.(pem|key)$)' || echo "нет" + else + echo "каталог не является git-репозиторием: запустите проверку в клоне" + fi +} > evidence/09-git-hygiene.txt 2>&1 +note "09 git hygiene -> evidence/09-git-hygiene.txt" + +{ echo "# Сводка сбора доказательств ($(now))"; echo "$RESULTS"; echo; for f in evidence/0*.txt; do echo; echo "=================== $f"; cat "$f"; done; } > evidence/summary.txt 2>&1 +echo "$RESULTS" +echo +echo "Готово. Отправьте мне содержимое evidence/summary.txt (секретов в нём нет, но просмотрите глазами)." diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..26ea97ff --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +cd /d "%~dp0.." +docker compose restart postgres >nul || exit /b 1 +docker compose exec -T postgres sh -c "i=0; until pg_isready -U msg -d msg -q; do i=$((i+1)); [ $i -gt 60 ] && exit 1; sleep 1; done" || exit /b 1 +docker compose restart api >nul +exit /b %errorlevel% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..8eb245b1 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Перезапуск PostgreSQL и API с сохранением volumes (без down -v): сначала БД, после её готовности — API. +set -eu +cd "$(dirname "$0")/.." || exit 1 +docker compose restart postgres >/dev/null +docker compose exec -T postgres sh -c 'i=0; until pg_isready -U msg -d msg -q; do i=$((i+1)); [ "$i" -gt 60 ] && exit 1; sleep 1; done' +docker compose restart api >/dev/null diff --git a/scripts/setup-secrets.sh b/scripts/setup-secrets.sh new file mode 100644 index 00000000..b69a99c6 --- /dev/null +++ b/scripts/setup-secrets.sh @@ -0,0 +1,11 @@ +#!/bin/sh +# Создаёт локальные секреты (не коммитятся). Безопасно повторять: существующие не перезаписываются. +set -eu +mkdir -p secrets +if [ ! -f secrets/pg_password ]; then + head -c 24 /dev/urandom | base64 | tr -d '/+=\n' > secrets/pg_password +fi +if [ ! -f secrets/database_url ]; then + printf 'postgresql://msg:%s@postgres:5432/msg' "$(cat secrets/pg_password)" > secrets/database_url +fi +chmod 600 secrets/* diff --git a/src/app/__init__.py b/src/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/main.py b/src/app/main.py new file mode 100644 index 00000000..32fea189 --- /dev/null +++ b/src/app/main.py @@ -0,0 +1,378 @@ +import base64 +import binascii +import hashlib +import json +import os +import re +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +import psycopg +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, InvalidHashError +from psycopg.errors import UniqueViolation +from psycopg_pool import ConnectionPool, PoolTimeout +from starlette.applications import Starlette +from starlette.requests import Request +from starlette.concurrency import run_in_threadpool +from starlette.responses import JSONResponse, Response +from starlette.routing import Route + +from . import migrate + +INSTANCE_ID = uuid.uuid4().hex[:8] +SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") +ph = PasswordHasher() +# заранее посчитанный хеш — выравнивает время ответа для неизвестного username +DUMMY_HASH = ph.hash("dummy-password-for-timing") + + +def read_secret(name: str) -> str: + path = os.environ.get(name + "_FILE") + if path: + return open(path, encoding="utf-8").read().strip() + return os.environ[name] + + +DSN = read_secret("DATABASE_URL") +pool = ConnectionPool(DSN, min_size=2, max_size=int(os.environ.get("DB_POOL_MAX", "10")), + timeout=5, open=False, kwargs={"connect_timeout": 5}) + + +class ApiError(Exception): + def __init__(self, status, code, message, headers=None): + self.status, self.code, self.message, self.headers = status, code, message, headers or {} + + +def bad(msg="Неверный запрос"): + return ApiError(400, "invalid_request", msg) + + +def iso(dt: datetime) -> str: + return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def parse_uuid(s): + try: + u = uuid.UUID(s) + if str(u) != s.lower(): + raise ValueError + return u + except (ValueError, AttributeError, TypeError): + raise bad("Неверный UUID") + + +def user_json(r): + return {"id": str(r[0]), "username": r[1], "display_name": r[2], "created_at": iso(r[3])} + + +def msg_json(r): + return {"id": str(r[0]), "chat_id": str(r[1]), "sender_id": str(r[2]), "text": r[3], "created_at": iso(r[4])} + + +def non_blank(s): + return isinstance(s, str) and s.strip() != "" + + +def body_json(request: Request, allowed: set, required: set): + ct = request.headers.get("content-type", "").split(";")[0].strip().lower() + if ct != "application/json": + raise ApiError(415, "unsupported_media_type", "Нужен application/json") + raw = request._body # прочитано заранее в обёртке + if len(raw) > MAX_BODY: + raise ApiError(413, "payload_too_large", "Слишком большое тело") + try: + data = json.loads(raw.decode("utf-8")) + except (ValueError, UnicodeError): + raise bad("Некорректный JSON") + if not isinstance(data, dict) or set(data) - allowed or required - set(data): + raise bad() + return data + + +def current_user(request: Request, conn): + auth = request.headers.get("authorization", "") + parts = auth.split(" ", 1) + hdr = {"WWW-Authenticate": 'Bearer realm="messenger"'} + if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip(): + raise ApiError(401, "unauthorized", "Требуется аутентификация", hdr) + th = hashlib.sha256(parts[1].strip().encode()).digest() + row = conn.execute( + "SELECT u.id,u.username,u.display_name,u.created_at FROM sessions s JOIN users u ON u.id=s.user_id " + "WHERE s.token_hash=%s AND s.revoked_at IS NULL AND s.expires_at>now()", (th,)).fetchone() + if not row: + raise ApiError(401, "unauthorized", "Требуется аутентификация", hdr) + return row, th + + +MAX_BODY = 1024 * 1024 + + +async def read_body_limited(request: Request): + """Читает тело с лимитом: 413 до того, как всё тело окажется в памяти.""" + cl = request.headers.get("content-length") + if cl is not None and (not cl.isdigit() or int(cl) > MAX_BODY): + raise ApiError(413, "payload_too_large", "Слишком большое тело") + buf = bytearray() + async for chunk in request.stream(): + buf += chunk + if len(buf) > MAX_BODY: + raise ApiError(413, "payload_too_large", "Слишком большое тело") + request._body = bytes(buf) + + +def db(fn): + """Обёртка эндпоинта: соединение из пула, единая обработка ошибок.""" + async def wrapper(request: Request): + rid = request.headers.get("x-request-id") or uuid.uuid4().hex + try: + await read_body_limited(request) + resp = await run_in_threadpool(fn, request) + except ApiError as e: + resp = JSONResponse({"error": {"code": e.code, "message": e.message, "request_id": rid}}, + status_code=e.status, headers=e.headers) + except (PoolTimeout, psycopg.OperationalError): + resp = JSONResponse({"error": {"code": "unavailable", "message": "Сервис временно недоступен", + "request_id": rid}}, status_code=503) + except Exception: + resp = JSONResponse({"error": {"code": "internal_error", "message": "Внутренняя ошибка", + "request_id": rid}}, status_code=500) + resp.headers["X-Request-Id"] = rid + resp.headers["X-Instance-Id"] = INSTANCE_ID + return resp + return wrapper + + +def page_args(request: Request): + q = request.query_params + if len(q.getlist("limit")) > 1 or len(q.getlist("cursor")) > 1: + raise bad("limit/cursor можно указать один раз") + limit = 50 + if q.getlist("limit"): + t = q.get("limit") + if not (t.isascii() and t.isdigit()) or not 1 <= int(t) <= 100: + raise bad("limit") + limit = int(t) + return limit, q.get("cursor") or None + + +def enc_cursor(kind, scope, ts, id_): + return base64.urlsafe_b64encode(json.dumps([kind, scope, ts, str(id_)]).encode()).decode().rstrip("=") + + +def dec_cursor(c, kind, scope): + try: + v = json.loads(base64.urlsafe_b64decode(c + "=" * (-len(c) % 4))) + if v[0] != kind or v[1] != scope: + raise ValueError + return datetime.fromisoformat(v[2].replace("Z", "+00:00")), uuid.UUID(v[3]) + except Exception: + raise bad("cursor") + + +async def live(request): + return JSONResponse({"status": "ok"}, headers={"X-Request-Id": request.headers.get("x-request-id") or uuid.uuid4().hex, "X-Instance-Id": INSTANCE_ID}) + + +@db +def ready(request): + with pool.connection(timeout=2) as conn: + conn.execute("SELECT 1") + return JSONResponse({"status": "ok"}) + + +@db +def create_user(request): + d = body_json(request, {"username", "display_name", "password"}, {"username", "display_name", "password"}) + u, dn, pw = d["username"], d["display_name"], d["password"] + if not (isinstance(u, str) and USERNAME_RE.fullmatch(u)): + raise bad("username") + if not (non_blank(dn) and len(dn) <= 100): + raise bad("display_name") + if not (isinstance(pw, str) and 12 <= len(pw) <= 128): + raise bad("password") + h = ph.hash(pw) + with pool.connection() as conn: + try: + r = conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) " + "RETURNING id,username,display_name,created_at", (uuid.uuid4(), u, dn, h)).fetchone() + except UniqueViolation: + raise ApiError(409, "conflict", "Имя пользователя занято") + return JSONResponse(user_json(r), status_code=201) + + +@db +def login(request): + ch = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + fail = ApiError(401, "unauthorized", "Неверные учётные данные", ch) + auth = request.headers.get("authorization", "") + parts = auth.split(" ", 1) + if len(parts) != 2 or parts[0].lower() != "basic": + raise fail + try: + creds = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeError): + raise fail + if ":" not in creds: + raise fail + username, password = creds.split(":", 1) + with pool.connection() as conn: + row = conn.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s", + (username,)).fetchone() + try: + ph.verify(row[4] if row else DUMMY_HASH, password) + ok = row is not None + except (VerifyMismatchError, InvalidHashError): + ok = False + if not ok: + raise fail + token = secrets.token_urlsafe(32) # 256 бит + exp = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL) + conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)", + (hashlib.sha256(token.encode()).digest(), row[0], exp)) + return JSONResponse({"token": token, "token_type": "Bearer", "expires_at": iso(exp), "user": user_json(row)}, + status_code=201) + + +@db +def logout(request): + with pool.connection() as conn: + _, th = current_user(request, conn) + conn.execute("UPDATE sessions SET revoked_at=now() WHERE token_hash=%s", (th,)) + return Response(status_code=204) + + +@db +def me(request): + with pool.connection() as conn: + row, _ = current_user(request, conn) + return JSONResponse(user_json(row)) + + +def chat_json(conn, r): + members = [str(x[0]) for x in conn.execute( + "SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (r[0],))] + return {"id": str(r[0]), "title": r[1], "member_ids": members, "created_at": iso(r[2])} + + +@db +def create_chat(request): + with pool.connection() as conn: + user, _ = current_user(request, conn) + d = body_json(request, {"title", "member_ids"}, {"title", "member_ids"}) + t, m = d["title"], d["member_ids"] + if not (non_blank(t) and len(t) <= 100): + raise bad("title") + if not (isinstance(m, list) and 1 <= len(m) <= 100 and all(isinstance(x, str) for x in m)): + raise bad("member_ids") + ids = [parse_uuid(x) for x in m] + if len(set(ids)) != len(ids) or user[0] not in ids: + raise bad("member_ids") + found = conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (ids,)).fetchone()[0] + if found != len(ids): + raise bad("member_ids") + cid = uuid.uuid4() + with conn.transaction(): # чат и участники — атомарно + r = conn.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING id,title,created_at", (cid, t)).fetchone() + with conn.cursor() as cur: + cur.executemany("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)", [(cid, i) for i in ids]) + return JSONResponse(chat_json(conn, r), status_code=201) + + +@db +def list_chats(request): + with pool.connection() as conn: + user, _ = current_user(request, conn) + limit, cursor = page_args(request) + args = [user[0]] + cond = "" + if cursor: + ts, i = dec_cursor(cursor, "chats", str(user[0])) + cond = "AND (c.created_at,c.id) > (%s,%s)" + args += [ts, i] + rows = conn.execute( + "SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id AND m.user_id=%s " + f"WHERE true {cond} ORDER BY c.created_at,c.id LIMIT %s", args + [limit + 1]).fetchall() + more = len(rows) > limit + rows = rows[:limit] + nxt = enc_cursor("chats", str(user[0]), iso(rows[-1][2]), rows[-1][0]) if more else None + return JSONResponse({"items": [chat_json(conn, r) for r in rows], "next_cursor": nxt}) + + +def get_chat_or_404(conn, user, chat_id): + cid = parse_uuid(chat_id) + r = conn.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m " + "ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s", (cid, user[0])).fetchone() + if not r: + raise ApiError(404, "not_found", "Объект не найден") + return r + + +@db +def get_chat(request): + with pool.connection() as conn: + user, _ = current_user(request, conn) + r = get_chat_or_404(conn, user, request.path_params["chat_id"]) + return JSONResponse(chat_json(conn, r)) + + +@db +def send_message(request): + with pool.connection() as conn: + user, _ = current_user(request, conn) + cid = request.path_params["chat_id"] + chat = get_chat_or_404(conn, user, cid) + d = body_json(request, {"text"}, {"text"}) + t = d["text"] + if not (non_blank(t) and len(t) <= 4000): + raise bad("text") + r = conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) " + "RETURNING id,chat_id,sender_id,text,created_at", (uuid.uuid4(), chat[0], user[0], t)).fetchone() + return JSONResponse(msg_json(r), status_code=201) + + +@db +def list_messages(request): + with pool.connection() as conn: + user, _ = current_user(request, conn) + cid = request.path_params["chat_id"] + chat = get_chat_or_404(conn, user, cid) + limit, cursor = page_args(request) + args = [chat[0]] + cond = "" + if cursor: + ts, i = dec_cursor(cursor, "messages", str(chat[0])) + cond = "AND (created_at,id) > (%s,%s)" + args += [ts, i] + rows = conn.execute("SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s " + f"{cond} ORDER BY created_at,id LIMIT %s", args + [limit + 1]).fetchall() + more = len(rows) > limit + rows = rows[:limit] + nxt = enc_cursor("messages", str(chat[0]), iso(rows[-1][4]), rows[-1][0]) if more else None + return JSONResponse({"items": [msg_json(r) for r in rows], "next_cursor": nxt}) + + +async def lifespan(app): + migrate.run(DSN) + pool.open(wait=True, timeout=30) + yield + pool.close() + + +P = "/api/v1" +app = Starlette(lifespan=lifespan, routes=[ + Route("/health/live", live), + Route("/health/ready", ready), + Route(P + "/users", create_user, methods=["POST"]), + Route(P + "/users/me", me), + Route(P + "/auth/sessions", login, methods=["POST"]), + Route(P + "/auth/sessions/current", logout, methods=["DELETE"]), + Route(P + "/chats", create_chat, methods=["POST"]), + Route(P + "/chats", list_chats, methods=["GET"]), + Route(P + "/chats/{chat_id}", get_chat), + Route(P + "/chats/{chat_id}/messages", send_message, methods=["POST"]), + Route(P + "/chats/{chat_id}/messages", list_messages, methods=["GET"]), +]) diff --git a/src/app/migrate.py b/src/app/migrate.py new file mode 100644 index 00000000..0f512105 --- /dev/null +++ b/src/app/migrate.py @@ -0,0 +1,25 @@ +"""Версионируемые миграции: применяются по порядку, повторный запуск безопасен.""" +import pathlib +import psycopg + +DIR = pathlib.Path(__file__).resolve().parent.parent / "migrations" + + +def run(dsn: str) -> None: + with psycopg.connect(dsn, autocommit=True) as conn: + # advisory lock: несколько реплик/перезапусков не мигрируют одновременно + conn.execute("SELECT pg_advisory_lock(727001)") + try: + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + "version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())" + ) + done = {r[0] for r in conn.execute("SELECT version FROM schema_migrations")} + for f in sorted(DIR.glob("*.sql")): + if f.name in done: + continue + with conn.transaction(): + conn.execute(f.read_text(encoding="utf-8")) + conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (f.name,)) + finally: + conn.execute("SELECT pg_advisory_unlock(727001)") diff --git a/src/migrations/001_init.sql b/src/migrations/001_init.sql new file mode 100644 index 00000000..28531688 --- /dev/null +++ b/src/migrations/001_init.sql @@ -0,0 +1,39 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE INDEX chats_created_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users(id), + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +-- keyset-пагинация истории: WHERE chat_id=$1 AND (created_at,id) > ($2,$3) ORDER BY created_at,id +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, -- sha256(token); сам токен не хранится + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL, + revoked_at timestamptz +); +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/src/requirements.txt b/src/requirements.txt new file mode 100644 index 00000000..89a404c2 --- /dev/null +++ b/src/requirements.txt @@ -0,0 +1,4 @@ +starlette==0.41.3 +uvicorn==0.32.1 +psycopg[binary,pool]==3.2.3 +argon2-cffi==23.1.0 diff --git a/student-tests/lab2_checks.py b/student-tests/lab2_checks.py new file mode 100644 index 00000000..87d14ef6 --- /dev/null +++ b/student-tests/lab2_checks.py @@ -0,0 +1,231 @@ +#!/usr/bin/env python3 +"""Собственные проверки lab2 (дополняют публичный smoke, ничего не ослабляют). + + python student-tests/lab2_checks.py --base-url http://localhost:8080 # основные + python student-tests/lab2_checks.py --base-url http://localhost:8080 --mode ttl # при SESSION_TTL_SECONDS=2 + +Только стандартная библиотека. Токены и пароли не печатаются. +""" +import argparse, base64, http.client, json, sys, threading, time, urllib.error, urllib.parse, urllib.request, uuid + +PW = "correct-horse-battery" +fails = [] + + +def call(base, method, path, body=None, headers=None, raw=None): + h = dict(headers or {}) + data = raw + if body is not None: + data = json.dumps(body).encode() + h.setdefault("Content-Type", "application/json") + req = urllib.request.Request(base + path, data=data, headers=h, method=method) + try: + with urllib.request.urlopen(req, timeout=15) as r: + return r.status, {k.lower(): v for k, v in r.headers.items()}, r.read() + except urllib.error.HTTPError as e: + return e.code, {k.lower(): v for k, v in e.headers.items()}, e.read() + + +def post_big(base, path, size): + """POST тела size байт; сервер может ответить 413 и закрыть соединение раньше, чем тело отправлено.""" + u = urllib.parse.urlsplit(base) + conn = http.client.HTTPConnection(u.hostname, u.port, timeout=15) + conn.putrequest("POST", u.path + path) + conn.putheader("Content-Type", "application/json") + conn.putheader("Content-Length", str(size)) + conn.endheaders() + try: + conn.send(b"{" + b" " * (size - 2) + b"}") + except OSError: + pass # сервер уже ответил и закрыл соединение + try: + return conn.getresponse().status + except (OSError, http.client.HTTPException) as e: + return "нет ответа: %s" % type(e).__name__ + finally: + conn.close() + + +def js(b): + try: + return json.loads(b) + except ValueError: + return None + + +def check(name, ok, detail=""): + print(("PASS" if ok else "FAIL") + ": " + name + ("" if ok else " -> " + detail)) + if not ok: + fails.append(name) + + +def basic(u, p): + return {"Authorization": "Basic " + base64.b64encode(f"{u}:{p}".encode()).decode()} + + +def bearer(t): + return {"Authorization": "Bearer " + t} + + +class Api: + def __init__(self, base): + self.base = base + "/api/v1" + + def __call__(self, *a, **k): + return call(self.base, *a, **k) + + def user(self, prefix="u"): + name = f"{prefix}_{uuid.uuid4().hex[:10]}" + s, _, b = self("POST", "/users", {"username": name, "display_name": name, "password": PW}) + assert s == 201, f"create user: {s}" + u = js(b) + s, _, b = self("POST", "/auth/sessions", headers=basic(name, PW)) + assert s == 201, f"login: {s}" + return name, u["id"], js(b)["token"] + + +def main_checks(api): + a_name, a_id, a_tok = api.user("alice") + b_name, b_id, b_tok = api.user("bob") + c_name, c_id, c_tok = api.user("carol") + + # --- регистрация + s, _, _ = api("POST", "/users", {"username": a_name, "display_name": "x", "password": PW}) + check("повторный username -> 409", s == 409, str(s)) + s, _, b = api("POST", "/users", {"username": "x_" + uuid.uuid4().hex[:8], "display_name": "x", "password": "short"}) + check("пароль короче 12 -> 400", s == 400, str(s)) + s, _, b = api("POST", "/users", {"username": "x_" + uuid.uuid4().hex[:8], "display_name": "x", "password": PW, "extra": 1}) + check("лишнее поле -> 400", s == 400, str(s)) + s, _, b = api("GET", "/users/me", headers=bearer(a_tok)) + me = js(b) or {} + check("User не содержит пароль/hash/токен", s == 200 and not ({"password", "password_hash", "token"} & set(me)), str(sorted(me))) + + res = [] + rname = "race_" + uuid.uuid4().hex[:10] + def reg(): + res.append(api("POST", "/users", {"username": rname, "display_name": "r", "password": PW})[0]) + ts = [threading.Thread(target=reg) for _ in range(10)] + [t.start() for t in ts]; [t.join() for t in ts] + check("гонка одинакового username: ровно один 201, остальные 409", sorted(res) == [201] + [409] * 9, str(sorted(res))) + + # --- вход + s1, h1, b1 = api("POST", "/auth/sessions", headers=basic(a_name, "wrong-password-123")) + s2, h2, b2 = api("POST", "/auth/sessions", headers=basic("nosuchuser_zz", PW)) + e1, e2 = (js(b1) or {}).get("error", {}), (js(b2) or {}).get("error", {}) + check("неверный пароль и неизвестный пользователь неразличимы (401, тот же code/message/заголовок)", + s1 == s2 == 401 and e1.get("code") == e2.get("code") and e1.get("message") == e2.get("message") + and h1.get("www-authenticate") == h2.get("www-authenticate") == 'Basic realm="messenger", charset="UTF-8"', + f"{s1}/{s2} {h1.get('www-authenticate')}") + s, _, _ = api("POST", "/auth/sessions", {"username": a_name, "password": PW}) + check("вход JSON-телом без Basic -> 401", s == 401, str(s)) + s, _, _ = api("POST", "/auth/sessions", headers=bearer(a_tok)) + check("Bearer на POST /auth/sessions -> 401", s == 401, str(s)) + s, h, b = api("POST", "/auth/sessions", headers=basic(a_name, PW)) + d = js(b) or {} + check("токен >=256 бит, token_type Bearer", s == 201 and len(d.get("token", "")) >= 43 and d.get("token_type") == "Bearer", str(s)) + + # --- бизнес-endpoint принимают только Bearer + s, h, _ = api("GET", "/users/me", headers=basic(a_name, PW)) + check("Basic на бизнес-endpoint -> 401 + WWW-Authenticate: Bearer", s == 401 and h.get("www-authenticate", "").startswith("Bearer"), str(s)) + s, _, _ = api("GET", "/users/me", headers={"X-User-Id": a_id}) + check("один X-User-Id доступа не даёт", s == 401, str(s)) + s, _, b = api("GET", "/users/me", headers={**bearer(a_tok), "X-User-Id": b_id}) + check("X-User-Id игнорируется: владелец определяется токеном", s == 200 and (js(b) or {}).get("id") == a_id, str(s)) + s, _, _ = api("GET", "/users/me", headers=bearer("x" * 43)) + check("неизвестный токен -> 401", s == 401, str(s)) + + # --- запрос-идентификатор в ошибках + s, h, b = api("GET", "/chats") + check("X-Request-Id совпадает с request_id в теле ошибки", s == 401 and h.get("x-request-id") == (js(b) or {}).get("error", {}).get("request_id"), str(s)) + + # --- чаты и доступ + s, _, b = api("GET", "/chats", headers=bearer(a_tok)) + before = len((js(b) or {}).get("items", [])) + s, _, b = api("POST", "/chats", {"title": "t", "member_ids": [a_id, str(uuid.uuid4())]}, bearer(a_tok)) + check("чат с неизвестным участником -> 400", s == 400, str(s)) + s, _, b = api("GET", "/chats", headers=bearer(a_tok)) + check("после отказа новый чат не появился (нет частичной записи)", len((js(b) or {}).get("items", [])) == before) + s, _, b = api("POST", "/chats", {"title": "ab", "member_ids": [a_id, b_id]}, bearer(a_tok)) + chat = js(b) or {} + check("чат создан с обоими участниками", s == 201 and sorted(chat.get("member_ids", [])) == sorted([a_id, b_id]), str(s)) + cid = chat.get("id", "") + s, _, _ = api("POST", "/chats", {"title": "ab", "member_ids": [b_id]}, bearer(a_tok)) + check("создатель обязан быть среди member_ids -> 400", s == 400, str(s)) + for path in (f"/chats/{cid}", f"/chats/{cid}/messages"): + s, _, _ = api("GET", path, headers=bearer(c_tok)) + check(f"посторонний: GET {path.split(cid)[1] or '/chat'} -> 404", s == 404, str(s)) + s, _, _ = api("POST", f"/chats/{cid}/messages", {"text": "hi"}, bearer(c_tok)) + check("посторонний не может писать -> 404", s == 404, str(s)) + for path in ("/chats/not-a-uuid", "/chats/not-a-uuid/messages"): + s, _, _ = api("GET", path, headers=bearer(a_tok)) + check(f"неверный UUID {path} -> 400", s == 400, str(s)) + s, _, _ = api("POST", f"/chats/{cid}/messages", {"text": "hi", "sender_id": b_id}, bearer(a_tok)) + check("sender_id в запросе не принимается -> 400", s == 400, str(s)) + s, _, _ = api("POST", f"/chats/{cid}/messages", {"text": " "}, bearer(a_tok)) + check("пробельный текст -> 400", s == 400, str(s)) + s, _, b = api("POST", f"/chats/{cid}/messages", {"text": "привет 👋"}, bearer(b_tok)) + check("отправитель берётся из токена", s == 201 and (js(b) or {}).get("sender_id") == b_id, str(s)) + + # --- пагинация + for i in range(5): + api("POST", f"/chats/{cid}/messages", {"text": f"m{i}"}, bearer(a_tok)) + seen, cur, pages = [], None, 0 + while True: + s, _, b = api("GET", f"/chats/{cid}/messages?limit=2" + (f"&cursor={cur}" if cur else ""), headers=bearer(a_tok)) + d = js(b) or {} + seen += [m["id"] for m in d.get("items", [])] + pages += 1 + cur = d.get("next_cursor") + if not cur or pages > 10: + break + check("пагинация limit=2: без повторов, все 6 сообщений", len(seen) == len(set(seen)) == 6, f"{len(seen)}/{len(set(seen))}") + s, _, b = api("GET", f"/chats/{cid}/messages?limit=2", headers=bearer(a_tok)) + cur = (js(b) or {}).get("next_cursor") + s, _, b = api("POST", "/chats", {"title": "other", "member_ids": [a_id]}, bearer(a_tok)) + other = (js(b) or {}).get("id") + s, _, _ = api("GET", f"/chats/{other}/messages?cursor={cur}", headers=bearer(a_tok)) + check("cursor от другого чата -> 400", s == 400, str(s)) + for q in ("limit=0", "limit=101", "limit=abc", "limit=%2B5", "limit=2&limit=3"): + s, _, _ = api("GET", f"/chats/{cid}/messages?{q}", headers=bearer(a_tok)) + check(f"?{q} -> 400", s == 400, str(s)) + + # --- тело запроса + s = post_big(api.base, "/users", 1100 * 1024) + check("тело >1 MiB -> 413", s == 413, str(s)) + s, _, _ = api("POST", "/users", raw=b"{}", headers={"Content-Type": "text/plain"}) + check("не JSON Content-Type -> 415", s == 415, str(s)) + s, _, _ = api("POST", "/users", raw=b"{", headers={"Content-Type": "application/json"}) + check("битый JSON -> 400", s == 400, str(s)) + + # --- logout (в конце: отзывает токен) + s, _, _ = api("DELETE", "/auth/sessions/current", headers=bearer(a_tok)) + check("logout -> 204", s == 204, str(s)) + s, h, _ = api("DELETE", "/auth/sessions/current", headers=bearer(a_tok)) + check("повторный logout с отозванным токеном -> 401", s == 401, str(s)) + s, h, _ = api("GET", "/users/me", headers=bearer(a_tok)) + check("отозванный токен -> 401 + WWW-Authenticate: Bearer", s == 401 and h.get("www-authenticate", "").startswith("Bearer"), str(s)) + s, _, _ = api("GET", "/users/me", headers=bearer(b_tok)) + check("logout одного пользователя не затрагивает чужие сессии", s == 200, str(s)) + + +def ttl_checks(api): + name = api.user("ttl")[0] + s, _, b = api("POST", "/auth/sessions", headers=basic(name, PW)) + d = js(b) or {} + tok = d.get("token", "") + s0, _, _ = api("GET", "/users/me", headers=bearer(tok)) + check("TTL: сразу после входа токен действует (200)", s0 == 200, str(s0)) + time.sleep(3.5) + s1, h, _ = api("GET", "/users/me", headers=bearer(tok)) + check("TTL: через 3.5 с при SESSION_TTL_SECONDS=2 токен истёк (401)", s1 == 401 and h.get("www-authenticate", "").startswith("Bearer"), str(s1)) + + +if __name__ == "__main__": + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--mode", choices=["main", "ttl"], default="main") + a = ap.parse_args() + api = Api(a.base_url.rstrip("/")) + (ttl_checks if a.mode == "ttl" else main_checks)(api) + print(("FAIL: %d проверок не прошли: %s" % (len(fails), "; ".join(fails))) if fails else "PASS: все проверки режима '%s'" % a.mode) + sys.exit(1 if fails else 0)