forked from mtusi2026/mtusi2026lab2
lab2: PostgreSQL, sessions, compose, evidence tooling.
This commit is contained in:
@@ -0,0 +1,5 @@
|
||||
*.sh text eol=lf
|
||||
Dockerfile text eol=lf
|
||||
*.sql text eol=lf
|
||||
*.py text eol=lf
|
||||
*.cmd text eol=crlf
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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.
|
||||
|
||||
@@ -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:
|
||||
@@ -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 (секретов в нём нет, но просмотрите глазами)."
|
||||
@@ -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%
|
||||
@@ -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
|
||||
@@ -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/*
|
||||
+378
@@ -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"]),
|
||||
])
|
||||
@@ -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)")
|
||||
@@ -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);
|
||||
@@ -0,0 +1,4 @@
|
||||
starlette==0.41.3
|
||||
uvicorn==0.32.1
|
||||
psycopg[binary,pool]==3.2.3
|
||||
argon2-cffi==23.1.0
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user