lab2: PostgreSQL, sessions, compose, evidence tooling.

This commit is contained in:
Conloty
2026-11-12 21:52:21 +03:00
parent 65003b6119
commit ac54d4cfde
15 changed files with 1001 additions and 14 deletions
+5
View File
@@ -0,0 +1,5 @@
*.sh text eol=lf
Dockerfile text eol=lf
*.sql text eol=lf
*.py text eol=lf
*.cmd text eol=crlf
+6
View File
@@ -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__/
+11
View File
@@ -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"]
+87 -14
View File
@@ -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.
+34
View File
@@ -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:
+157
View File
@@ -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 (секретов в нём нет, но просмотрите глазами)."
+6
View File
@@ -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%
+7
View File
@@ -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
+11
View File
@@ -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/*
View File
+378
View File
@@ -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"]),
])
+25
View File
@@ -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)")
+39
View File
@@ -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);
+4
View File
@@ -0,0 +1,4 @@
starlette==0.41.3
uvicorn==0.32.1
psycopg[binary,pool]==3.2.3
argon2-cffi==23.1.0
+231
View File
@@ -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)