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