ЛР 2 - БВТ2302 - Саргсян Сона - на 4 #145

Closed
sargsona wants to merge 7 commits from sargsona/mtusi2026lab2:solution/bvt2302-sargsyan into master
28 changed files with 2118 additions and 14 deletions
+26
View File
@@ -0,0 +1,26 @@
FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
RUN groupadd --system app && \
useradd --system --gid app --create-home app
COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --timeout 60 -r requirements.txt
COPY --chown=app:app src/ /app/src/
COPY --chown=app:app migrations/ /app/migrations/
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2)" || exit 1
CMD ["sh", "-c", "exec uvicorn src.main:app --host \"${APP_HOST}\" --port \"${APP_PORT}\" --timeout-graceful-shutdown 8"]
+125 -14
View File
@@ -1,37 +1,148 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Саргсян Сона, БВТ2302
- Целевая оценка: 4
- Commit/PR:
- Использованные источники, библиотеки и помощь ИИ: Claude Code. Библиотеки: FastAPI, Pydantic, Uvicorn, asyncpg, argon2-cffi, redis-py (клиент для Valkey).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Git, Docker с запущенным daemon (Compose v2), Make, Python 3.9+ (для публичных проверок, только стандартная библиотека) и `openssl`. Порты 8080 (API), 18080 (только SIGTERM-тест) должны быть свободны. При первой сборке нужен доступ к Docker Hub и PyPI.
Версии: Python 3.12.7 (образ `python:3.12.7-slim`, закреплён digest), FastAPI 0.115.2, Pydantic 2.14.1, Uvicorn 0.32.0, asyncpg 0.30.0, argon2-cffi 23.1.0, redis-py 5.2.1, PostgreSQL 16.6 (`postgres:16.6-alpine`), Valkey 8.0.1 (`valkey/valkey:8.0.1-alpine`). Все runtime-зависимости закреплены в `requirements.txt`.
Действия оператора (один раз). Секреты создаются локально и в Git не попадают (`secrets/` и `.env` в `.gitignore` и `.dockerignore`):
```sh
mkdir -p secrets
PW=$(openssl rand -hex 24)
printf '%s' "$PW" > secrets/postgres_password
printf 'postgresql://messenger:%s@postgres:5432/messenger' "$PW" > secrets/database_url
chmod 644 secrets/*
cp .env.example .env
chmod +x scripts/restart.sh
```
Права 644 нужны, чтобы непривилегированный пользователь `app` в контейнере прочитал секрет; допустимо только для локального стенда с синтетическими данными.
Сборка, миграции и запуск. Миграции применяет само приложение при старте (`src/db.py`), отдельного шага нет:
```sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
curl --fail --retry 20 --retry-connrefused --retry-delay 1 http://localhost:8080/health/ready
```
Проверки:
```sh
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 student_tests/test_lab2.py
python3 student_tests/test_lifecycle.py
python3 student_tests/test_sigterm.py
python3 -m unittest discover -s student_tests -p "test_level4.py" -v
docker compose --env-file .env exec -T postgres psql -U messenger -d messenger < scripts/explain.sql
```
`test_level4.py` останавливает и запускает контейнеры valkey/postgres/api; volumes не удаляются. `test_sigterm.py` запускает отдельный контейнер API в сети compose (имя сети по умолчанию `mtusi-lab2_default`, переопределяется `COMPOSE_NETWORK`).
Остановка с сохранением данных: `docker compose --env-file .env down`. Намеренное удаление учебных данных (БД и Valkey): `docker compose --env-file .env down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент ──HTTP──> API (FastAPI) ──> PostgreSQL 16 (volume pgdata) - источник истины
└────────> Valkey 8 (без persistence) — кэш сессий с TTL
```
**Источник истины.** PostgreSQL хранит пользователей, чаты, участников, сообщения и сессии (`migrations/001_init.sql`). Сессия — строка в `sessions`: SHA-256 токена (сам токен не хранится), `user_id`, `expires_at`, `revoked_at`. Токен - 256 бит случайности (`secrets.token_urlsafe(32)`).
**Роль Valkey.** Кэш проверенных сессий: ключ `sess:<sha256 токена>`, значение - данные пользователя. Valkey запущен без persistence (`--save "" --appendonly no`), с лимитом памяти 64 МБ и политикой `allkeys-lru`. Потеря кэша (рестарт, `FLUSHALL`) ничего не теряет: следующий запрос получает данные из PostgreSQL и наполняет кэш заново.
**Политика expiry и инвалидации кэша.**
- TTL записи = `min(остаток жизни сессии, CACHE_TTL_SECONDS=60)`, то есть кэш никогда не живёт дольше сессии.
- Logout: сначала `UPDATE sessions SET revoked_at` в PostgreSQL, затем `DEL` ключа в Valkey.
- Данные пользователя в кэше неизменяемы (в API нет редактирования), поэтому других причин инвалидации нет.
- Если Valkey недоступен, кэш обходится (любой сбой - промах); после сбоя обращения к кэшу приостанавливаются на 5 секунд, чтобы не ждать таймаут на каждом запросе. Readiness зависит только от PostgreSQL: Valkey - оптимизация, а не критичная зависимость.
**Аутентификация.** `POST /auth/sessions` принимает только `Authorization: Basic`; остальные endpoint - только Bearer (зависимость `current_user`). `X-User-Id` не читается. Пароли хешируются Argon2id (argon2-cffi, параметры по умолчанию библиотеки), вычисление выполняется в thread pool. Для несуществующего пользователя проверка идёт по хешу-заглушке, ответ одинаковый 401. Это отличает password KDF (медленный, с солью, защищает слабые пароли от перебора) от быстрого checksum: токен имеет 256 бит случайности, поэтому для него достаточно SHA-256.
**Транзакционные границы.**
- Создание чата: `INSERT chats` + `INSERT chat_members` в одной транзакции; неизвестный участник нарушает FK и откатывает всё.
- Отправка сообщения: проверка членства и `INSERT` - один оператор (`INSERT ... SELECT ... WHERE EXISTS`).
- Регистрация: гонку одинаковых username решает `UNIQUE`, приложение ловит `UniqueViolationError` и отвечает 409.
- Миграции: каждая в транзакции вместе с записью в `schema_migrations`, под `pg_advisory_lock`.
**Что перенесено из lab1.** Структура приложения (middleware с `X-Request-Id`, формат ошибок, строгая валидация Pydantic, обработка SIGTERM), Dockerfile, собственные тесты (адаптированы под пароль/Bearer). **Что изменено.** In-memory словари заменены PostgreSQL; `X-User-Id` заменён Bearer; добавлены password KDF, сессии, Valkey, миграции, compose. Курсор пагинации теперь keyset `(created_at, id)`, непрозрачный и привязанный к ресурсу (раньше был ID записи).
**Соответствие переменных `.env.example`.**
| Переменная | Реализация |
| --- | --- |
| `APP_HOST`, `APP_PORT` | задаются в Dockerfile (0.0.0.0 / 8080) |
| `APP_ENV` | передаётся в контейнер, поведение не меняет |
| `SESSION_TTL_SECONDS` | срок жизни сессии (по умолчанию 3600) |
| `DATABASE_URL_FILE` | путь к секрету с адресом PostgreSQL |
| `SESSION_STORE` | не используется: сессии всегда в PostgreSQL, Valkey - кэш |
| `CACHE_URL_FILE` | поддерживается; в compose адрес Valkey передаётся через `CACHE_URL` (в нём нет секретов) |
Дополнительно: `DB_POOL_MIN=2`, `DB_POOL_MAX=10`, `DB_CONNECT_TIMEOUT=5`, `DB_COMMAND_TIMEOUT=5`, `CACHE_TTL_SECONDS=60`, `CACHE_TIMEOUT=0.5`, `MIGRATIONS_DIR`.
## Доказательства критериев
Дата проверок: 03.11.2026; стенд: <macOS / Docker Desktop, число CPU и RAM>.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | PASS: lab2 public API scenario | `evidence/smoke.txt` |
| Данные и сессии переживают рестарт API и хранилищ без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; контейнеры postgres/valkey `Up 5 seconds`, api `Up Less than a second` после hook | `evidence/persistence.txt`, `evidence/restart-before.txt`, `evidence/restart-after.txt` |
| Полный жизненный цикл: тот же токен читает те же данные после рестарта, logout → 401 | `python3 student_tests/test_lifecycle.py` | PASS (7 проверок) | `evidence/lifecycle.txt` |
| Таблицы, PK/FK, UNIQUE username, миграции с нуля | `migrations/001_init.sql`, запуск с пустым volume | миграция применена | `evidence/migrations.txt` |
| Миграции повторно запускаются без дублирования | перезапуск стенда, `logs api \| grep migration` | одна строка `Applied migration 001_init.sql` за все рестарты | `evidence/migrations.txt` |
| Атомарность создания чата | `test_chat_creation_rolls_back` | чат с неизвестным участником → 400, `count(*)` в БД = 0 | `evidence/student-tests-level4.txt` |
| Basic только на `POST /auth/sessions`, Bearer на остальных, `X-User-Id` без доступа, срок жизни, отзыв | `test_lab2.py` (`test_validation_and_unicode`), `test_x_user_id_gives_no_access`, `test_logout_...`, `test_zz_session_expiry` | PASS | `evidence/student-tests.txt`, `evidence/student-tests-level4.txt` |
| Пароли хешируются KDF | `src/auth.py` (Argon2id), в БД только `password_hash` | см. код | `src/auth.py` |
| Secrets/volumes не в Git | `.gitignore`, `.dockerignore`, `git status` перед коммитом | `.env`, `secrets/` не отслеживаются | — |
| **4:** Valkey реально используется (сессии с TTL) | `valkey-cli keys 'sess:*'` после запросов; `test_valkey_flush_keeps_sessions` | ключи `sess:...` есть, после `FLUSHALL` сессия работает и кэш наполняется снова | `evidence/student-tests-level4.txt` |
| **4:** параметризованные запросы, ограниченный пул, таймауты | `src/db.py`, `src/chats.py` (все запросы с `$n`) | пул 2–10, таймауты соединения и команд 5 с | `src/db.py` |
| **4:** гонка регистрации | `test_register_race_same_username` | 10 параллельных POST: ровно один 201, девять 409 | `evidence/student-tests-level4.txt` |
| **4:** индекс истории + EXPLAIN на ≥10 000 сообщений | `scripts/explain.sql` | с индексом `messages_history_idx`: Index Scan, 3 страницы буфера и для первой страницы, и для страницы из середины истории (0.03 мс); без индекса: Seq Scan + сортировка, 123 страницы (0.9 мс) | `evidence/explain.txt` |
| **4:** expiry при коротком TTL, logout, неверный пароль | `test_zz_session_expiry` (TTL=2), `test_logout_...`, `test_wrong_password` | PASS | `evidence/student-tests-level4.txt` |
| **4:** недоступность Valkey и PostgreSQL | `test_valkey_down_falls_back_to_postgres`, `test_postgres_down_returns_bounded_error` | Valkey остановлен: запросы работают через PostgreSQL; PostgreSQL остановлен: `/health/ready` 503, неизвестный токен 503, запрос без токена 401, регистрация 503 | `evidence/student-tests-level4.txt` |
| Собственные тесты | `python3 student_tests/test_lab2.py` | PASS: 12 сценариев | `evidence/student-tests.txt` |
| Корректная остановка | `python3 student_tests/test_sigterm.py` | PASS: exit code 0, idle 0.34 с, с незавершённым POST 8.4 с | `evidence/sigterm.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Трек 5 не заявлен.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Объём данных EXPLAIN: 10 000 сообщений в одном чате, синтетика (`scripts/explain.sql`), PostgreSQL 16.6, все чтения из shared buffers (`shared hit`), диска нет. Замер единичный, прогрев не выполнялся, поэтому важно соотношение (3 страницы против 123), а не абсолютные миллисекунды.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Полный рестарт api + postgres + valkey (volumes сохранены) | токен и данные сохраняются | тот же токен читает ту же историю | сервисы `Up` через ~5 с; потери данных нет |
| `FLUSHALL` в Valkey | сессии работают, кэш наполняется заново | ответ 200 из PostgreSQL, ключи `sess:*` появляются снова | без прерывания; потери данных нет |
| Остановка Valkey | чтение и вход работают через PostgreSQL | 200 для действующего токена, 401 для неизвестного и анонимного | после `start` кэш снова используется не позднее чем через 5 с; потери данных нет |
| Остановка PostgreSQL | ограниченная ошибка, аноним не доверенный | `/health/ready` 503 (код `unavailable`), неизвестный токен 503, запрос без токена 401, регистрация 503 | API снова готов после старта PostgreSQL в пределах 90 с ожидания теста (точное время не измерялось) |
| `SESSION_TTL_SECONDS=2` | токен истекает | через 3.5 с запрос с тем же токеном → 401 (в том числе из-за TTL кэша ≤ остатка сессии) | не применимо |
Ограничения измерения: нагрузочный профиль не снимался (трек 5 не заявлен), время восстановления PostgreSQL точно не измерялось.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Устаревание кэша при сбое инвалидации.** Если logout выполнился, а `DEL` в Valkey не прошёл (кратковременный сбой), запись может остаться в кэше не дольше `CACHE_TTL_SECONDS` (60 с). Это сознательный компромисс; снизить окно можно, уменьшив TTL кэша.
- **Порядок истории при конкурентной записи.** `created_at` задаётся через `clock_timestamp()` в момент вставки, а видимость строки определяется моментом COMMIT. При конкурентных записях возможно, что сообщение с чуть более ранним `created_at` станет видимым после того, как читатель уже получил курсор за ним; такая запись не повторится и не пропадёт при следующем чтении с начала, но может быть пропущена при продолжении по старому курсору. Гарантируется отсутствие повторов при обходе неизменной истории.
- **Просроченные сессии не удаляются** из таблицы `sessions` (нет фоновой очистки); они не принимаются, но занимают место. Следующий шаг - периодическая очистка по индексу `sessions_expires_idx`.
- **Один экземпляр PostgreSQL и Valkey**, без репликации и бэкапов; отказ диска PostgreSQL приведёт к потере данных (backup/restore - трек 2 уровня 5, не реализован).
- **HTTP и Basic без TLS** - допустимо только для локального изолированного стенда с синтетическими данными. Права `644` у секретов - учебное упрощение для локального запуска.
- **Argon2id** использует параметры по умолчанию библиотеки; подбор параметров под целевое железо не выполнялся.
- Удалённый CI для сборки приложения не добавлен: `.github/workflows/contracts.yml` проверяет только контракт.
## Ответы на вопросы защиты
- **Что подтверждает COMMIT?** Транзакция записана в WAL и (при `synchronous_commit=on`, значение по умолчанию) сброшена на диск до ответа клиенту; гарантия зависит от настроек `fsync`/`synchronous_commit` и от надёжности диска и Docker volume.
- **Где хранятся сессии и что будет после flush/restart Redis/Valkey?** Источник истины - таблица `sessions` в PostgreSQL; Valkey лишь кэш без persistence. После flush или рестарта кэш пуст, сессии не теряются и наполняют кэш заново (`test_valkey_flush_keeps_sessions`).
- **Чем аутентификация отличается от доступа к чату?** Аутентификация отвечает «кто вы» (Bearer-сессия), доступ - «можно ли этому пользователю в этот чат» (проверка членства в `chat_members`); постороннему возвращается 404, чтобы не раскрывать существование чата.
- **Почему hash пароля и быстрый checksum - разные задачи?** Пароль имеет низкую энтропию и должен защищаться от перебора, поэтому нужен медленный salted KDF (Argon2id); токен сессии - 256 бит случайности, перебор невозможен, и достаточно быстрого SHA-256.
+57
View File
@@ -0,0 +1,57 @@
name: mtusi-lab2
services:
postgres:
image: postgres:16.6-alpine
restart: unless-stopped
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
valkey:
image: valkey/valkey:8.0.1-alpine
restart: unless-stopped
command: ["valkey-server", "--save", "", "--appendonly", "no", "--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"]
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
api:
build: .
image: mtusi-messenger:lab2
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
valkey:
condition: service_started
environment:
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL: redis://valkey:6379/0
secrets:
- database_url
ports:
- "127.0.0.1:8080:8080"
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
volumes:
pgdata:
+55
View File
@@ -0,0 +1,55 @@
BEGIN
INSERT 0 0
INSERT 0 0
INSERT 0 0
INSERT 0 0
COMMIT
ANALYZE
1. Первая страница (limit 50)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..5.33 rows=51 width=64) (actual time=0.015..0.020 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_history_idx on messages (cost=0.29..989.57 rows=10000 width=64) (actual time=0.015..0.017 rows=51 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=23
Planning Time: 0.108 ms
Execution Time: 0.037 ms
(9 rows)
2. Страница из середины истории (keyset cursor)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..6.63 rows=51 width=64) (actual time=0.007..0.011 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_history_idx on messages (cost=0.29..620.78 rows=4991 width=64) (actual time=0.006..0.009 rows=51 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid) AND (ROW(created_at, id) > ROW('2026-11-03 06:25:42.350396+00'::timestamp with time zone, 'e5c90185-a58b-4164-b1b3-cb15e30b97e1'::uuid)))
Buffers: shared hit=3
Planning Time: 0.027 ms
Execution Time: 0.034 ms
(7 rows)
3. Для сравнения: без индекса messages_history_idx
BEGIN
DROP INDEX
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------
Limit (cost=581.83..581.96 rows=51 width=64) (actual time=0.915..0.919 rows=51 loops=1)
Buffers: shared hit=123
-> Sort (cost=581.83..606.83 rows=10000 width=64) (actual time=0.915..0.916 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=123
-> Seq Scan on messages (cost=0.00..248.21 rows=10000 width=64) (actual time=0.004..0.485 rows=10000 loops=1)
Filter: (chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid)
Rows Removed by Filter: 17
Buffers: shared hit=123
Planning:
Buffers: shared hit=4
Planning Time: 0.037 ms
Execution Time: 0.941 ms
(14 rows)
ROLLBACK
+7
View File
@@ -0,0 +1,7 @@
PASS two users created and read two messages: HTTP 201, then HTTP 200
PASS third user cannot read or write the chat: HTTP 404
PASS request logs include IDs and statuses, without message contents
Command: scripts/restart.sh (API + PostgreSQL + Valkey, volumes kept)
PASS after restart: same tokens read the same history
PASS logout revokes only alice's session; bob's session still works
PASS persistent lifecycle: data and sessions survive full restart
+1
View File
@@ -0,0 +1 @@
api-1 | 2026-11-02 22:31:51,587 [INFO] [req_id=-] Applied migration 001_init.sql
+3
View File
@@ -0,0 +1,3 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+4
View File
@@ -0,0 +1,4 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 7 hours ago Up Less than a second (health: starting) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 10 hours ago Up 5 seconds (healthy) 5432/tcp
mtusi-lab2-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 8 hours ago Up 5 seconds (healthy) 6379/tcp
+4
View File
@@ -0,0 +1,4 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 7 hours ago Up 3 minutes (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 10 hours ago Up 3 minutes (healthy) 5432/tcp
mtusi-lab2-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 8 hours ago Up 3 minutes (healthy) 6379/tcp
+6
View File
@@ -0,0 +1,6 @@
Image: mtusi-messenger:lab2
Scenario: idle; docker stop --timeout 10 mtusi-messenger-sigterm-60edb300
PASS idle: exit code 0; shutdown 0.339s; new connections rejected after 0.119s
Scenario: incomplete POST; docker stop --timeout 10 mtusi-messenger-sigterm-859f8a87
PASS incomplete POST: exit code 0; shutdown 8.356s; new connections rejected after 0.117s
PASS SIGTERM: both scenarios completed within 10 seconds
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+32
View File
@@ -0,0 +1,32 @@
test_chat_creation_rolls_back (test_level4.Level4.test_chat_creation_rolls_back) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 400: 'Bad Request'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_logout_revokes_session_and_cache (test_level4.Level4.test_logout_revokes_session_and_cache) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 401: 'Unauthorized'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_postgres_down_returns_bounded_error (test_level4.Level4.test_postgres_down_returns_bounded_error) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 503: 'Service Unavailable'>
_warnings.warn(self.warn_message, ResourceWarning)
/opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 401: 'Unauthorized'>
_warnings.warn(self.warn_message, ResourceWarning)
/opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 503: 'Service Unavailable'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_register_race_same_username (test_level4.Level4.test_register_race_same_username) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 409: 'Conflict'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_valkey_down_falls_back_to_postgres (test_level4.Level4.test_valkey_down_falls_back_to_postgres) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 401: 'Unauthorized'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_valkey_flush_keeps_sessions (test_level4.Level4.test_valkey_flush_keeps_sessions) ... ok
test_wrong_password (test_level4.Level4.test_wrong_password) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 401: 'Unauthorized'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
test_x_user_id_gives_no_access (test_level4.Level4.test_x_user_id_gives_no_access) ... ok
test_zz_session_expiry (test_level4.Level4.test_zz_session_expiry) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up <HTTPError 401: 'Unauthorized'>
_warnings.warn(self.warn_message, ResourceWarning)
ok
----------------------------------------------------------------------
Ran 9 tests in 16.447s
OK
+15
View File
@@ -0,0 +1,15 @@
Testing http://localhost:8080
PASS malformed JSON and invalid UTF-8 -> 400 with error envelope
PASS duplicate username -> 409
PASS outsider cannot access chat -> 404
PASS empty/whitespace message -> 400
PASS extra JSON field -> 400
PASS pagination: 7 messages read through multiple pages
PASS concurrency: 10 clients sent 100 messages; exactly 100 unique messages stored
PASS invalid chat UUID -> 400; unknown valid UUID -> 404
PASS chat members: 1..100, unique, existing, caller included
PASS invalid cursor/limit and cursor from another chat -> 400
PASS pagination: 7 chats, changing limit between pages
PASS strict types, Unicode, password rules, Bearer-only identification
PASS: 12 student test scenarios completed
+63
View File
@@ -0,0 +1,63 @@
-- 001_init: базовая схема лабы 2. Повторный запуск безопасен (IF NOT EXISTS).
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL, -- Argon2id, никогда не отдаётся в API
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (
char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> ''
)
);
CREATE TABLE IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT chats_title_len CHECK (
char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''
)
);
-- Порядок списка чатов: (created_at, id)
CREATE INDEX IF NOT EXISTS chats_created_idx ON chats (created_at, id);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL, -- порядок member_ids как в запросе
PRIMARY KEY (chat_id, user_id)
);
-- Список чатов пользователя и проверка членства
CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users (id),
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT messages_text_len CHECK (
char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''
)
);
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
-- ORDER BY created_at, id LIMIT n -> index scan без сортировки и полного прохода
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash bytea PRIMARY KEY, -- SHA-256 токена; сам токен не хранится
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
);
CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id);
CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at);
+16
View File
@@ -0,0 +1,16 @@
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
fastapi==0.115.2
h11==0.16.0
idna==3.20
pydantic==2.14.1
pydantic-core==2.50.1
starlette==0.40.0
typing-extensions==4.16.0
typing-inspection==0.4.4
uvicorn==0.32.0
asyncpg==0.30.0
argon2-cffi==23.1.0
argon2-cffi-bindings==21.2.0
redis==5.2.1
+45
View File
@@ -0,0 +1,45 @@
-- Нагрузочные данные для EXPLAIN: 10 000 сообщений в одном чате (синтетика).
\set ON_ERROR_STOP on
BEGIN;
INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_user', 'Explain', 'x')
ON CONFLICT DO NOTHING;
INSERT INTO chats (id, title)
VALUES ('00000000-0000-4000-8000-0000000000c1', 'explain-chat')
ON CONFLICT DO NOTHING;
INSERT INTO chat_members (chat_id, user_id, position)
VALUES ('00000000-0000-4000-8000-0000000000c1', '00000000-0000-4000-8000-000000000001', 0)
ON CONFLICT DO NOTHING;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), '00000000-0000-4000-8000-0000000000c1',
'00000000-0000-4000-8000-000000000001', 'msg ' || g,
now() - (10001 - g) * interval '1 second'
FROM generate_series(1, 10000) g
WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-0000000000c1');
COMMIT;
ANALYZE messages;
\echo '1. Первая страница (limit 50)'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000c1'
ORDER BY created_at, id LIMIT 51;
\echo '2. Страница из середины истории (keyset cursor)'
SELECT created_at AS c_ts, id AS c_id FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000c1'
ORDER BY created_at, id OFFSET 5000 LIMIT 1 \gset
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000c1'
AND (created_at, id) > (:'c_ts'::timestamptz, :'c_id'::uuid)
ORDER BY created_at, id LIMIT 51;
\echo '3. Для сравнения: без индекса messages_history_idx'
BEGIN;
DROP INDEX messages_history_idx;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000c1'
ORDER BY created_at, id LIMIT 51;
ROLLBACK;
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Перезапуск API и PostgreSQL с сохранением volume (никаких down -v).
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env stop api
docker compose --env-file .env restart postgres valkey
docker compose --env-file .env start api
+87
View File
@@ -0,0 +1,87 @@
import asyncio
import base64
import binascii
import hashlib
import secrets
from typing import Optional, Tuple
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from fastapi import HTTPException, Request
_hasher = PasswordHasher()
# Хеш-заглушка: для несуществующего пользователя тратим столько же времени, сколько для существующего.
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
async def hash_password(password: str) -> str:
return await asyncio.to_thread(_hasher.hash, password) # Argon2 грузит CPU, не блокируем event loop
async def verify_password(stored_hash: Optional[str], password: str) -> bool:
try:
return await asyncio.to_thread(_hasher.verify, stored_hash or _DUMMY_HASH, password)
except (VerificationError, InvalidHashError):
return False
def new_token() -> str:
return secrets.token_urlsafe(32) # 256 бит случайности
def token_hash(token: str) -> bytes:
return hashlib.sha256(token.encode()).digest()
def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]:
if not header:
return None
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value:
return None
try:
raw = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError):
return None
username, sep, password = raw.partition(":") # двоеточие в пароле допустимо
return (username, password) if sep else None
def parse_bearer(header: Optional[str]) -> Optional[str]:
if not header:
return None
scheme, _, value = header.partition(" ")
value = value.strip()
if scheme.lower() != "bearer" or not value or len(value) > 512:
return None
return value
_SESSION_SQL = """
SELECT u.id, u.username, u.display_name, u.created_at,
EXTRACT(EPOCH FROM (s.expires_at - now())) AS remaining
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()
"""
async def current_user(request: Request):
# Только Bearer. Сначала кэш, при промахе или сбое - PostgreSQL (источник истины).
token = parse_bearer(request.headers.get("Authorization"))
if token is None:
raise HTTPException(401, headers=BEARER_CHALLENGE)
digest = token_hash(token)
cache = request.app.state.cache
user = await cache.get(digest)
if user is None:
row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest)
if row is None:
raise HTTPException(401, headers=BEARER_CHALLENGE)
user = {k: row[k] for k in ("id", "username", "display_name", "created_at")}
await cache.put(digest, user, int(row["remaining"]))
request.state.token_hash = digest
return user
+82
View File
@@ -0,0 +1,82 @@
import asyncio
import json
import logging
import time
import uuid
from datetime import datetime
from typing import Optional
import redis.asyncio as redis
from redis.exceptions import RedisError
from . import config
from .common import iso
logger = logging.getLogger("messenger")
_FAILURES = (RedisError, OSError, asyncio.TimeoutError)
_RETRY_AFTER = 5.0 # после сбоя 5 секунд не обращаемся к кэшу, чтобы не ждать таймаут на каждом запросе
def _key(digest: bytes) -> str:
return "sess:" + digest.hex()
class SessionCache:
"""Кэш проверенных сессий. Любой сбой = промах: ответ берётся из PostgreSQL."""
def __init__(self, url: str):
self._client = (
redis.Redis.from_url(
url, decode_responses=True,
socket_timeout=config.CACHE_TIMEOUT, socket_connect_timeout=config.CACHE_TIMEOUT,
) if url else None
)
self._down_until = 0.0
def _usable(self) -> bool:
return self._client is not None and time.monotonic() >= self._down_until
def _mark_down(self, exc: Exception) -> None:
self._down_until = time.monotonic() + _RETRY_AFTER
logger.warning("Cache unavailable, bypassing: %s", type(exc).__name__)
async def get(self, digest: bytes) -> Optional[dict]:
if not self._usable():
return None
try:
raw = await self._client.get(_key(digest))
except _FAILURES as exc:
self._mark_down(exc)
return None
if raw is None:
return None
try:
d = json.loads(raw)
return {"id": uuid.UUID(d["id"]), "username": d["username"],
"display_name": d["display_name"], "created_at": datetime.fromisoformat(d["created_at"])}
except (ValueError, KeyError):
return None
async def put(self, digest: bytes, user: dict, remaining_seconds: int) -> None:
ttl = min(remaining_seconds, config.CACHE_TTL_SECONDS) # кэш никогда не живёт дольше сессии
if ttl < 1 or not self._usable():
return
value = json.dumps({"id": str(user["id"]), "username": user["username"],
"display_name": user["display_name"], "created_at": iso(user["created_at"])})
try:
await self._client.set(_key(digest), value, ex=ttl)
except _FAILURES as exc:
self._mark_down(exc)
async def delete(self, digest: bytes) -> None:
if not self._usable():
return
try:
await self._client.delete(_key(digest))
except _FAILURES as exc:
self._mark_down(exc)
async def close(self) -> None:
if self._client is not None:
await self._client.aclose()
+208
View File
@@ -0,0 +1,208 @@
import base64
import json
import uuid
from datetime import datetime
from typing import List, Optional, Tuple
import asyncpg
from fastapi import APIRouter, Depends, Query, Request
from pydantic import BaseModel, ConfigDict, Field
from .auth import current_user
from .common import iso, make_error_response
router = APIRouter()
class StrictRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateChatRequest(StrictRequest):
title: str
member_ids: List[str] = Field(min_length=1, max_length=100)
class CreateMessageRequest(StrictRequest):
text: str
def _req_id(request: Request) -> str:
return request.state.request_id
# курсор: непрозрачная строка, привязанная к ресурсу (scope)
def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str:
raw = json.dumps([scope, iso(created_at), str(row_id)]).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]:
"""ValueError, если курсор повреждён или выдан для другого ресурса."""
try:
sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if sc != scope:
raise ValueError("scope mismatch")
return datetime.fromisoformat(ts), uuid.UUID(rid)
except Exception as exc:
raise ValueError("invalid cursor") from exc
def _bad_text(value: str) -> bool:
return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text
_CHAT_COLUMNS = (
"c.id, c.title, c.created_at, "
"array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids"
)
def chat_dict(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": iso(row["created_at"]),
}
def message_dict(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": iso(row["created_at"]),
}
def _check_limit(limit: int) -> bool:
return 1 <= limit <= 100
# чаты
@router.post("/chats", status_code=201)
async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)):
req_id = _req_id(request)
if not (1 <= len(req.title) <= 100) or _bad_text(req.title):
return make_error_response(400, "invalid_request", "Invalid title", req_id)
try:
members = [uuid.UUID(m) for m in req.member_ids]
except ValueError:
return make_error_response(400, "invalid_request", "Invalid member id", req_id)
if len(members) != len(set(members)):
return make_error_response(400, "invalid_request", "Duplicate members found", req_id)
if user["id"] not in members:
return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id)
chat_id = uuid.uuid4()
try:
async with request.app.state.pool.acquire() as conn:
# Чат и все участники - одна транзакция: неизвестный участник откатывает всё.
async with conn.transaction():
created_at = await conn.fetchval(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at",
chat_id, req.title,
)
await conn.execute(
"INSERT INTO chat_members (chat_id, user_id, position) "
"SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)",
chat_id, members,
)
except asyncpg.ForeignKeyViolationError:
return make_error_response(400, "invalid_request", "Unknown member", req_id)
return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members],
"created_at": iso(created_at)}
@router.get("/chats")
async def list_chats(request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
scope = "chats:" + str(user["id"])
base = (f"SELECT {_CHAT_COLUMNS} FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ")
if cursor is None:
rows = await request.app.state.pool.fetch(
base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await request.app.state.pool.fetch(
base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) "
"ORDER BY c.created_at, c.id LIMIT $4",
user["id"], ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor}
@router.get("/chats/{chat_id}")
async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)):
row = await request.app.state.pool.fetchrow(
f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 "
"AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)",
chat_id, user["id"],
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", _req_id(request))
return chat_dict(row)
# сообщения
@router.post("/chats/{chat_id}/messages", status_code=201)
async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request,
user=Depends(current_user)):
req_id = _req_id(request)
if _bad_text(req.text):
return make_error_response(400, "invalid_request", "Empty message text", req_id)
if len(req.text) > 4000:
return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id)
# Проверка членства и вставка - один атомарный оператор.
row = await request.app.state.pool.fetchrow(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"SELECT $1, $2, $3, $4, clock_timestamp() "
"WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3) "
"RETURNING id, chat_id, sender_id, text, created_at",
uuid.uuid4(), chat_id, user["id"], req.text,
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", req_id)
return message_dict(row)
@router.get("/chats/{chat_id}/messages")
async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
pool = request.app.state.pool
is_member = await pool.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"])
if not is_member:
return make_error_response(404, "not_found", "Chat not found", req_id)
scope = "msgs:" + str(chat_id)
base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
if cursor is None:
rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await pool.fetch(
base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4",
chat_id, ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor}
+29
View File
@@ -0,0 +1,29 @@
from datetime import datetime, timezone
from typing import Optional
from fastapi.responses import JSONResponse
def iso(dt: datetime) -> str:
"""RFC 3339 UTC с Z; микросекунды нужны, чтобы курсор был точным."""
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def make_error_response(status_code: int, code: str, message: str, req_id: str, headers: Optional[dict] = None):
h = {"X-Request-Id": req_id}
if headers:
h.update(headers)
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": req_id}},
headers=h,
)
def user_dict(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": iso(row["created_at"]),
}
+24
View File
@@ -0,0 +1,24 @@
import os
from pathlib import Path
def _read_secret(file_var: str, direct_var: str) -> str:
"""Секрет из файла (DATABASE_URL_FILE), с запасным вариантом из переменной окружения."""
path = os.environ.get(file_var)
if path:
return Path(path).read_text().strip()
return os.environ.get(direct_var, "")
DATABASE_URL = _read_secret("DATABASE_URL_FILE", "DATABASE_URL")
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
DB_POOL_MIN = int(os.environ.get("DB_POOL_MIN", "2"))
DB_POOL_MAX = int(os.environ.get("DB_POOL_MAX", "10"))
DB_CONNECT_TIMEOUT = float(os.environ.get("DB_CONNECT_TIMEOUT", "5"))
DB_COMMAND_TIMEOUT = float(os.environ.get("DB_COMMAND_TIMEOUT", "5"))
MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations"))
CACHE_URL = _read_secret("CACHE_URL_FILE", "CACHE_URL")
CACHE_TTL_SECONDS = int(os.environ.get("CACHE_TTL_SECONDS", "60"))
CACHE_TIMEOUT = float(os.environ.get("CACHE_TIMEOUT", "0.5"))
+56
View File
@@ -0,0 +1,56 @@
import asyncio
import logging
import asyncpg
from . import config
logger = logging.getLogger("messenger")
# Произвольный константный ключ: один экземпляр выполняет миграции, остальные ждут.
MIGRATION_LOCK_KEY = 727_001
async def create_pool() -> asyncpg.Pool:
# Пул ограничен по размеру; у соединений и команд есть таймауты.
return await asyncpg.create_pool(
dsn=config.DATABASE_URL,
min_size=config.DB_POOL_MIN,
max_size=config.DB_POOL_MAX,
timeout=config.DB_CONNECT_TIMEOUT,
command_timeout=config.DB_COMMAND_TIMEOUT,
)
async def create_pool_with_retry(attempts: int = 30, delay: float = 1.0) -> asyncpg.Pool:
# БД в compose может подняться позже API.
for attempt in range(1, attempts + 1):
try:
return await create_pool()
except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc:
logger.warning("DB not ready (%d/%d): %s", attempt, attempts, type(exc).__name__)
await asyncio.sleep(delay)
raise RuntimeError("database is unavailable")
async def run_migrations(pool: asyncpg.Pool) -> None:
# Применяет migrations/*.sql по порядку имён, каждую один раз.
files = sorted(config.MIGRATIONS_DIR.glob("*.sql"))
async with pool.acquire() as conn:
await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY)
try:
await conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY,"
" applied_at timestamptz NOT NULL DEFAULT now())"
)
applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")}
for path in files:
if path.name in applied:
continue
async with conn.transaction():
await conn.execute(path.read_text())
await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", path.name)
logger.info("Applied migration %s", path.name)
finally:
await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY)
+187
View File
@@ -0,0 +1,187 @@
import asyncio
import logging
import re
import sys
import uuid
from contextlib import asynccontextmanager
import asyncpg
from fastapi import Depends, FastAPI, Request, Response
from fastapi.exceptions import RequestValidationError
from pydantic import BaseModel, ConfigDict
from starlette.exceptions import HTTPException
from . import config
from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token,
parse_basic, token_hash, verify_password)
from .chats import router as chats_router
from .common import iso, make_error_response, user_dict
from .db import create_pool_with_retry, run_migrations
from .cache import SessionCache
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] [req_id=%(request_id)s] %(message)s",
handlers=[logging.StreamHandler(sys.stdout)],
)
class RequestIdFilter(logging.Filter):
def filter(self, record):
if not hasattr(record, "request_id"):
record.request_id = "-"
return True
logger = logging.getLogger("messenger")
logger.addFilter(RequestIdFilter())
is_shutting_down = False
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
@asynccontextmanager
async def lifespan(app: FastAPI):
app.state.pool = await create_pool_with_retry()
await run_migrations(app.state.pool)
app.state.cache = SessionCache(config.CACHE_URL)
yield
global is_shutting_down
is_shutting_down = True
await app.state.cache.close()
await app.state.pool.close()
logger.info("Application shutdown complete")
app = FastAPI(title="MTUSI Messenger - Lab 2", lifespan=lifespan)
app.include_router(chats_router, prefix="/api/v1")
@app.middleware("http")
async def middleware_pipeline(request: Request, call_next):
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = req_id
if is_shutting_down and request.url.path != "/health/live":
return make_error_response(503, "unavailable", "Server is shutting down", req_id)
logger.info(f"Incoming request {request.method} {request.url.path}", extra={"request_id": req_id})
response: Response = await call_next(request)
response.headers["X-Request-Id"] = req_id
logger.info(f"Completed {request.method} {request.url.path} with status {response.status_code}",
extra={"request_id": req_id})
return response
def _req_id(request: Request) -> str:
return getattr(request.state, "request_id", str(uuid.uuid4()))
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
return make_error_response(400, "invalid_request", "Validation error", _req_id(request))
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
code = {
400: "invalid_request", 401: "unauthorized", 404: "not_found", 409: "conflict",
413: "payload_too_large", 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable",
}.get(exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request")
return make_error_response(exc.status_code, code, "Request failed", _req_id(request), exc.headers)
async def dependency_unavailable_handler(request: Request, exc: Exception):
"""БД недоступна или не ответила в срок: ограниченная 503, без деталей и без доверия анониму."""
logger.error("Dependency failure: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request))
for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, OSError, asyncio.TimeoutError):
app.add_exception_handler(_exc, dependency_unavailable_handler)
@app.exception_handler(Exception)
async def generic_exception_handler(request: Request, exc: Exception):
logger.error("Unhandled exception: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
return make_error_response(500, "internal_error", "Internal server error", _req_id(request))
class StrictRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateUserRequest(StrictRequest):
username: str
display_name: str
password: str
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready(request: Request):
# Критичная зависимость для готовности - PostgreSQL.
await request.app.state.pool.fetchval("SELECT 1", timeout=2)
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def register_user(req: CreateUserRequest, request: Request):
req_id = _req_id(request)
if not USERNAME_RE.fullmatch(req.username):
return make_error_response(400, "invalid_request", "Invalid username format", req_id)
if not (1 <= len(req.display_name) <= 100) or not req.display_name.strip() or "\x00" in req.display_name:
return make_error_response(400, "invalid_request", "Invalid display_name", req_id)
if not (12 <= len(req.password) <= 128):
return make_error_response(400, "invalid_request", "Invalid password length", req_id)
pw_hash = await hash_password(req.password)
try:
row = await request.app.state.pool.fetchrow(
"INSERT INTO users (id, username, display_name, password_hash, created_at) "
"VALUES ($1, $2, $3, $4, clock_timestamp()) "
"RETURNING id, username, display_name, created_at",
uuid.uuid4(), req.username, req.display_name, pw_hash,
)
except asyncpg.UniqueViolationError: # гонку одинаковых username решает UNIQUE, а не SELECT
return make_error_response(409, "conflict", "Username already exists", req_id)
return user_dict(row)
@app.get("/api/v1/users/me")
async def get_current_user(user=Depends(current_user)):
return user_dict(user)
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session(request: Request):
req_id = _req_id(request)
creds = parse_basic(request.headers.get("Authorization"))
if creds is None:
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
username, password = creds
pool = request.app.state.pool
row = await pool.fetchrow(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username
)
ok = await verify_password(row["password_hash"] if row else None, password)
if row is None or not ok:
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
token = new_token()
expires_at = await pool.fetchval(
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at) "
"VALUES ($1, $2, now(), now() + make_interval(secs => $3)) RETURNING expires_at",
token_hash(token), row["id"], float(config.SESSION_TTL_SECONDS),
)
return {"token": token, "token_type": "Bearer", "expires_at": iso(expires_at), "user": user_dict(row)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request, user=Depends(current_user)):
await request.app.state.pool.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = $1", request.state.token_hash
)
await request.app.state.cache.delete(request.state.token_hash)
return Response(status_code=204)
+585
View File
@@ -0,0 +1,585 @@
#!/usr/bin/env python3
import concurrent.futures
import json
import os
import sys
import uuid
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime
import base64
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
PASSWORD = "correct-horse-battery"
def request(method, path, expected, body=None, headers=None, raw_body=None):
url = BASE_URL + path
request_headers = dict(headers or {})
if raw_body is not None:
data = raw_body
elif body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
else:
data = None
if body is not None or raw_body is not None:
request_headers.setdefault("Content-Type", "application/json")
req = urllib.request.Request(
url,
data=data,
method=method,
headers=request_headers,
)
try:
with urllib.request.urlopen(req, timeout=10) as response:
status = response.status
response_headers = response.headers
response_body = response.read()
except urllib.error.HTTPError as exc:
status = exc.code
response_headers = exc.headers
response_body = exc.read()
if status != expected:
raise AssertionError(
f"{method} {path}: expected HTTP {expected}, got {status}. "
f"Body={response_body!r}"
)
request_id = response_headers.get("X-Request-Id")
if not request_id:
raise AssertionError(
f"{method} {path}: missing X-Request-Id"
)
parsed = None
if response_body:
content_type = response_headers.get_content_type()
if content_type == "application/json":
parsed = json.loads(response_body.decode("utf-8"))
if status >= 400:
codes = {
400: "invalid_request", 401: "unauthorized", 404: "not_found",
409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type",
429: "rate_limited", 500: "internal_error", 503: "unavailable",
}
if not isinstance(parsed, dict) or set(parsed) != {"error"}:
raise AssertionError(f"Invalid error response: {parsed!r}")
error = parsed["error"]
if not isinstance(error, dict) or set(error) != {"code", "message", "request_id"}:
raise AssertionError(f"Invalid error fields: {error!r}")
if error["code"] != codes[status] or error["request_id"] != request_id:
raise AssertionError(f"Wrong error code or request ID: {error!r}")
if not isinstance(error["message"], str) or not error["message"].strip():
raise AssertionError("Error message must be a nonempty string")
return {
"status": status,
"headers": response_headers,
"json": parsed,
"bytes": response_body,
}
def unique_username(prefix):
# username должен соответствовать [a-z0-9_]{3,32}
suffix = uuid.uuid4().hex[:12]
return f"{prefix}_{suffix}"
def basic(username, password=PASSWORD):
raw = f"{username}:{password}".encode("utf-8")
return "Basic " + base64.b64encode(raw).decode()
def create_user(prefix="usr", login=True):
user = request("POST", "/api/v1/users", 201, body={
"username": unique_username(prefix),
"display_name": f"Test {prefix}",
"password": PASSWORD,
})["json"]
if login:
session = request("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": basic(user["username"])})["json"]
user["token"] = session["token"]
return user
def auth(user):
return {"Authorization": "Bearer " + user["token"]}
def create_chat(owner, members, title="Student test chat"):
result = request(
"POST",
"/api/v1/chats",
201,
headers=auth(owner),
body={
"title": title,
"member_ids": [u["id"] for u in members],
},
)
return result["json"]
def create_message(user, chat, text):
return request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
201,
headers=auth(user),
body={"text": text},
)["json"]
def test_malformed_json():
for body in (b'{"username": "broken",', b"\xff"):
request("POST", "/api/v1/users", 400, raw_body=body)
print("PASS malformed JSON and invalid UTF-8 -> 400 with error envelope")
def test_duplicate_username():
username = unique_username("dup")
body = {
"username": username,
"display_name": "First",
"password": PASSWORD,
}
request(
"POST",
"/api/v1/users",
201,
body=body,
)
request(
"POST",
"/api/v1/users",
409,
body={
"username": username,
"display_name": "Second",
"password": PASSWORD,
},
)
print("PASS duplicate username -> 409")
def test_outsider_chat():
alice = create_user("alice")
bob = create_user("bob")
eve = create_user("eve")
chat = create_chat(
alice,
[alice, bob],
"Private chat",
)
request(
"GET",
f"/api/v1/chats/{chat['id']}",
404,
headers=auth(eve),
)
request(
"GET",
f"/api/v1/chats/{chat['id']}/messages",
404,
headers=auth(eve),
)
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
404,
headers=auth(eve),
body={"text": "Not allowed"},
)
page = request("GET", "/api/v1/chats", 200, headers=auth(eve))["json"]
if page != {"items": [], "next_cursor": None}:
raise AssertionError("Outsider can see a private chat in the list")
print("PASS outsider cannot access chat -> 404")
def test_empty_and_whitespace_message():
alice = create_user("emptya")
bob = create_user("emptyb")
chat = create_chat(
alice,
[alice, bob],
"Empty message test",
)
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
400,
headers=auth(alice),
body={"text": ""},
)
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
400,
headers=auth(alice),
body={"text": " \t\n"},
)
print("PASS empty/whitespace message -> 400")
def test_extra_json_field():
request(
"POST",
"/api/v1/users",
400,
body={
"username": unique_username("extra"),
"display_name": "Extra",
"password": PASSWORD,
"admin": True,
},
)
print("PASS extra JSON field -> 400")
def test_multi_page_history():
alice = create_user("pagea")
bob = create_user("pageb")
chat = create_chat(
alice,
[alice, bob],
"Pagination test",
)
expected = []
for i in range(7):
message = create_message(
alice,
chat,
f"pagination-message-{i}",
)
expected.append(message)
expected.sort(
key=lambda message: (
datetime.fromisoformat(
message["created_at"].replace("Z", "+00:00")
),
uuid.UUID(message["id"]).int,
)
)
expected_ids = [
message["id"]
for message in expected
]
collected = []
cursor = None
for _ in range(len(expected) + 1):
path = (
f"/api/v1/chats/{chat['id']}/messages"
f"?limit=2"
)
if cursor is not None:
path += "&cursor=" + urllib.parse.quote(
cursor,
safe="",
)
page = request(
"GET",
path,
200,
headers=auth(bob),
)["json"]
ids = [item["id"] for item in page["items"]]
collected.extend(ids)
cursor = page["next_cursor"]
if cursor is None:
break
else:
raise AssertionError("Pagination did not reach the last page")
if collected != expected_ids:
raise AssertionError(
"Pagination lost, duplicated or reordered messages.\n"
f"Expected: {expected_ids}\n"
f"Received: {collected}"
)
if len(collected) != len(set(collected)):
raise AssertionError(
"Pagination returned duplicate messages"
)
print(
f"PASS pagination: {len(collected)} messages "
"read through multiple pages"
)
def test_concurrent_100_messages():
users = [
create_user(f"c{i}")
for i in range(10)
]
chat = create_chat(
users[0],
users,
"Concurrency test",
)
def worker(client_index):
sent = []
for message_index in range(10):
text = (
f"client-{client_index}-"
f"message-{message_index}"
)
result = create_message(
users[client_index],
chat,
text,
)
sent.append(result)
return sent
all_sent = []
with concurrent.futures.ThreadPoolExecutor(
max_workers=10
) as executor:
futures = [
executor.submit(worker, i)
for i in range(10)
]
for future in concurrent.futures.as_completed(
futures
):
all_sent.extend(future.result())
if len(all_sent) != 100:
raise AssertionError(
f"Expected 100 successful POSTs, got {len(all_sent)}"
)
page = request(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=100",
200,
headers=auth(users[0]),
)["json"]
messages = page["items"]
if len(messages) != 100:
raise AssertionError(
f"Expected exactly 100 stored messages, "
f"got {len(messages)}"
)
ids = [message["id"] for message in messages]
if len(set(ids)) != 100:
raise AssertionError(
"Expected 100 unique message IDs"
)
if set(ids) != {message["id"] for message in all_sent}:
raise AssertionError("Stored messages differ from successful POST responses")
texts = [message["text"] for message in messages]
if len(set(texts)) != 100:
raise AssertionError(
"Expected 100 unique message texts"
)
if page["next_cursor"] is not None:
raise AssertionError(
"100 messages with limit=100 should fit in one page"
)
print(
"PASS concurrency: 10 clients sent 100 messages; "
"exactly 100 unique messages stored"
)
def test_invalid_chat_ids():
user = create_user("uuid")
for chat_id, expected in (("not-a-uuid", 400), (str(uuid.uuid4()), 404)):
path = f"/api/v1/chats/{chat_id}"
request("GET", path, expected, headers=auth(user))
request("GET", path + "/messages", expected, headers=auth(user))
request("POST", path + "/messages", expected,
headers=auth(user), body={"text": "Test"})
print("PASS invalid chat UUID -> 400; unknown valid UUID -> 404")
def test_chat_member_limits():
users = [create_user("member", login=(i == 0)) for i in range(101)]
owner = users[0]
for members in ([], users, [owner, owner], users[1:3]):
request("POST", "/api/v1/chats", 400, headers=auth(owner), body={
"title": "Invalid members", "member_ids": [user["id"] for user in members],
})
request("POST", "/api/v1/chats", 400, headers=auth(owner), body={
"title": "Unknown member", "member_ids": [owner["id"], str(uuid.uuid4())],
})
chat = create_chat(owner, users[:100])
if len(chat["member_ids"]) != 100:
raise AssertionError("Chat must accept exactly 100 members")
print("PASS chat members: 1..100, unique, existing, caller included")
def test_invalid_pagination():
user = create_user("cursor")
chat = create_chat(user, [user])
other_chat = create_chat(user, [user])
other_message = create_message(user, other_chat, "Other history")
paths = ("/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages")
for path in paths:
for query in ("cursor=", "cursor=unknown", "limit=0", "limit=101", "limit=abc", "limit=1.5"):
request("GET", path + "?" + query, 400, headers=auth(user))
request("GET", paths[1] + "?cursor=" + other_message["id"], 400, headers=auth(user))
print("PASS invalid cursor/limit and cursor from another chat -> 400")
def test_multi_page_chats():
user = create_user("chatpage")
chats = [create_chat(user, [user], f"Chat {i}") for i in range(7)]
chats.sort(key=lambda chat: (chat["created_at"], uuid.UUID(chat["id"]).int))
collected = []
cursor = None
for page_number in range(len(chats) + 1):
query = {"limit": 2 if page_number == 0 else 3}
if cursor is not None:
query["cursor"] = cursor
page = request("GET", "/api/v1/chats?" + urllib.parse.urlencode(query),
200, headers=auth(user))["json"]
collected.extend(chat["id"] for chat in page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
else:
raise AssertionError("Chat pagination did not reach the last page")
if collected != [chat["id"] for chat in chats]:
raise AssertionError("Chat pagination lost, duplicated or reordered chats")
print("PASS pagination: 7 chats, changing limit between pages")
def test_validation_and_unicode():
for display_name in ("", " \t", "x" * 101, 123, None):
request("POST", "/api/v1/users", 400, body={
"username": unique_username("invalid"), "display_name": display_name, "password": PASSWORD,
})
request("POST", "/api/v1/users", 400,
body={"username": True, "display_name": "Test", "password": PASSWORD})
for password in ("short", "x" * 129, 12345678901234, None):
request("POST", "/api/v1/users", 400, body={
"username": unique_username("badpw"), "display_name": "Test", "password": password,
})
request("POST", "/api/v1/users", 400,
body={"username": unique_username("nopw"), "display_name": "Test"})
unicode_password = "\U00020000" * 12 # пароль не из ASCII проходит через Basic/UTF-8 и KDF
user = request("POST", "/api/v1/users", 201, body={
"username": unique_username("unicode"), "display_name": "\U00020000" * 100,
"password": unicode_password,
})["json"]
session = request("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": basic(user["username"], unicode_password)})["json"]
user["token"] = session["token"]
chat = create_chat(user, [user])
path = f"/api/v1/chats/{chat['id']}/messages"
text = "\U00020000" * 4000
message = create_message(user, chat, text)
if message["text"] != text:
raise AssertionError("Unicode message was altered")
for invalid in (text + "x", 123, None):
request("POST", path, 400, headers=auth(user), body={"text": invalid})
request("GET", "/api/v1/users/me", 401)
request("GET", "/api/v1/users/me", 401, headers={"X-User-Id": user["id"]})
request("GET", "/api/v1/users/me", 401,
headers={"Authorization": basic(user["username"], unicode_password)})
print("PASS strict types, Unicode, password rules, Bearer-only identification")
def main():
tests = [
test_malformed_json,
test_duplicate_username,
test_outsider_chat,
test_empty_and_whitespace_message,
test_extra_json_field,
test_multi_page_history,
test_concurrent_100_messages,
test_invalid_chat_ids,
test_chat_member_limits,
test_invalid_pagination,
test_multi_page_chats,
test_validation_and_unicode,
]
print(f"Testing {BASE_URL}")
for test in tests:
test()
print()
print(
f"PASS: {len(tests)} student test scenarios completed"
)
if __name__ == "__main__":
try:
main()
except Exception as exc:
print(
f"FAIL: {type(exc).__name__}: {exc}",
file=sys.stderr,
)
sys.exit(1)
+195
View File
@@ -0,0 +1,195 @@
"""Проверки уровня 4. Нужен запущенный стенд (docker compose up -d --build).
Тесты отказов сами останавливают и запускают valkey/postgres/api, volumes не удаляются.
Запуск: python3 -m unittest discover -s student_tests -p "test_level4.py" -v
"""
import base64
import json
import os
import subprocess
import threading
import time
import unittest
import urllib.error
import urllib.request
import uuid
from pathlib import Path
BASE = os.environ.get("BASE_URL", "http://localhost:8080")
ROOT = Path(__file__).resolve().parents[1]
PASSWORD = "correct-horse-battery"
def call(method, path, body=None, headers=None):
data = json.dumps(body).encode() if body is not None else None
h = {"Content-Type": "application/json"} if body is not None else {}
h.update(headers or {})
req = urllib.request.Request(BASE + path, data=data, method=method, headers=h)
try:
with urllib.request.urlopen(req, timeout=15) as resp:
raw = resp.read()
return resp.status, (json.loads(raw) if raw else None)
except urllib.error.HTTPError as exc:
raw = exc.read()
try:
return exc.code, (json.loads(raw) if raw else None)
except ValueError:
return exc.code, None
def register(username=None):
username = username or "u" + uuid.uuid4().hex[:12]
status, user = call("POST", "/api/v1/users",
{"username": username, "display_name": "Test", "password": PASSWORD})
assert status == 201, status
return user
def login(username, password=PASSWORD):
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
return call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic})
def bearer(token):
return {"Authorization": "Bearer " + token}
def compose(*args, env=None):
full_env = dict(os.environ)
full_env.update(env or {})
result = subprocess.run(["docker", "compose", "--env-file", ".env", *args],
cwd=ROOT, env=full_env, check=True, capture_output=True, text=True)
return result.stdout
def wait_ready(timeout=90):
deadline = time.time() + timeout
while time.time() < deadline:
try:
if call("GET", "/health/ready")[0] == 200:
return
except OSError:
pass
time.sleep(1)
raise AssertionError("API did not become ready")
def new_session():
user = register()
status, session = login(user["username"])
assert status == 201
return user, session["token"]
class Level4(unittest.TestCase):
@classmethod
def setUpClass(cls):
wait_ready()
def test_wrong_password(self):
user = register()
status, body = login(user["username"], "definitely-wrong-password")
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
status, _ = login("no_such_user_" + uuid.uuid4().hex[:8])
self.assertEqual(status, 401)
def test_logout_revokes_session_and_cache(self):
_, token = new_session()
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) # прогрев кэша
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 204)
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401)
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 401)
def test_x_user_id_gives_no_access(self):
user = register()
status, _ = call("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]})
self.assertEqual(status, 401)
def test_register_race_same_username(self):
username = "race" + uuid.uuid4().hex[:10]
results = []
def worker():
status, _ = call("POST", "/api/v1/users",
{"username": username, "display_name": "Race", "password": PASSWORD})
results.append(status)
threads = [threading.Thread(target=worker) for _ in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
self.assertEqual(results.count(201), 1, results)
self.assertEqual(results.count(409), 9, results)
def test_chat_creation_rolls_back(self):
user, token = new_session()
title = "rollback-" + uuid.uuid4().hex
status, _ = call("POST", "/api/v1/chats",
{"title": title, "member_ids": [user["id"], str(uuid.uuid4())]},
headers=bearer(token))
self.assertEqual(status, 400)
# Проверяем саму БД: после отката не осталось ни чата, ни участников.
count = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger",
"-tAc", f"SELECT count(*) FROM chats WHERE title = '{title}'").strip()
self.assertEqual(count, "0")
def test_valkey_down_falls_back_to_postgres(self):
user, token = new_session()
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200)
compose("stop", "valkey")
try:
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200)
self.assertEqual(login(user["username"])[0], 201)
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401)
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("x" * 43))[0], 401)
finally:
compose("start", "valkey")
def test_valkey_flush_keeps_sessions(self):
_, token = new_session()
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200)
compose("exec", "-T", "valkey", "valkey-cli", "FLUSHALL")
# кэш пуст, но сессия живёт в PostgreSQL; ответ не зависит от состояния кэша
deadline = time.time() + 10
refilled = False
while time.time() < deadline:
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200)
keys = compose("exec", "-T", "valkey", "valkey-cli", "keys", "sess:*")
if keys.strip():
refilled = True
break
time.sleep(1)
self.assertTrue(refilled, "cache should be refilled after a miss")
def test_postgres_down_returns_bounded_error(self):
compose("stop", "postgres")
try:
status, body = call("GET", "/health/ready")
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
# неизвестный токен нельзя ни подтвердить, ни отвергнуть без БД: 503, не 200
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("y" * 43))[0], 503)
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) # аноним не доверенный
self.assertEqual(call("POST", "/api/v1/users",
{"username": "down" + uuid.uuid4().hex[:8], "display_name": "X",
"password": PASSWORD})[0], 503)
finally:
compose("start", "postgres")
wait_ready()
def test_zz_session_expiry(self):
compose("up", "-d", "api", env={"SESSION_TTL_SECONDS": "2"})
try:
wait_ready()
_, token = new_session()
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200)
time.sleep(3.5)
self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401)
finally:
compose("up", "-d", "api") # обратно к TTL из .env
wait_ready()
if __name__ == "__main__":
unittest.main()
+68
View File
@@ -0,0 +1,68 @@
#!/usr/bin/env python3
"""Жизненный цикл ЛР 2: данные и сессии переживают перезапуск всего стенда (API, PostgreSQL, Valkey).
Нужен запущенный compose-стенд; перезапуск делает scripts/restart.sh (volumes сохраняются)."""
import os
import sys
import uuid
import test_lab2 as api
from test_sigterm import ROOT, run, wait_ready
def compose_logs():
return run("docker", "compose", "--project-directory", str(ROOT), "--env-file", str(ROOT / ".env"),
"logs", "api", "--no-color").stdout
def main():
api.BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
wait_ready(api.BASE_URL)
alice = api.create_user("lifealice")
bob = api.create_user("lifebob")
outsider = api.create_user("lifeoutsider")
chat = api.create_chat(alice, [alice, bob], "Lifecycle test")
texts = ["private-lifecycle-" + uuid.uuid4().hex for _ in range(2)]
sent = [api.create_message(user, chat, text) for user, text in zip((alice, bob), texts)]
path = f"/api/v1/chats/{chat['id']}/messages"
page = api.request("GET", path, 200, headers=api.auth(bob))["json"]
if [m["id"] for m in page["items"]] != [m["id"] for m in sent]:
raise AssertionError("Created messages are missing or reordered")
print("PASS two users created and read two messages: HTTP 201, then HTTP 200")
api.request("GET", path, 404, headers=api.auth(outsider))
api.request("POST", path, 404, headers=api.auth(outsider), body={"text": "Forbidden"})
print("PASS third user cannot read or write the chat: HTTP 404")
logs = compose_logs()
if any(text in logs for text in texts):
raise AssertionError("Message contents leaked into container logs")
if "req_id=" not in logs or "with status 201" not in logs:
raise AssertionError("Request logs are missing")
print("PASS request logs include IDs and statuses, without message contents")
print("Command: scripts/restart.sh (API + PostgreSQL + Valkey, volumes kept)", flush=True)
run(str(ROOT / "scripts" / "restart.sh"), timeout=120)
wait_ready(api.BASE_URL, timeout=90)
# те же токены, те же данные
api.request("GET", "/api/v1/users/me", 200, headers=api.auth(alice))
after = api.request("GET", path, 200, headers=api.auth(bob))["json"]
if after["items"] != page["items"]:
raise AssertionError("History changed after restart")
api.request("GET", path, 404, headers=api.auth(outsider))
print("PASS after restart: same tokens read the same history")
api.request("DELETE", "/api/v1/auth/sessions/current", 204, headers=api.auth(alice))
api.request("GET", path, 401, headers=api.auth(alice))
api.request("GET", path, 200, headers=api.auth(bob))
print("PASS logout revokes only alice's session; bob's session still works")
print("PASS persistent lifecycle: data and sessions survive full restart")
if __name__ == "__main__":
try:
main()
except Exception as exc:
print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr)
sys.exit(1)
+129
View File
@@ -0,0 +1,129 @@
#!/usr/bin/env python3
import concurrent.futures
import os
import socket
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
IMAGE = os.environ.get("IMAGE", "mtusi-messenger:lab2")
NETWORK = os.environ.get("COMPOSE_NETWORK", "mtusi-lab2_default")
PORT = int(os.environ.get("SIGTERM_PORT", "18080"))
def run(*args, check=True, timeout=60):
return subprocess.run(
args, check=check, text=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, timeout=timeout,
)
def docker_run_args(name, port):
# Отдельный контейнер API в сети compose: те же PostgreSQL и Valkey, секрет только для чтения
return ["docker", "run", "-d", "--name", name, "--network", NETWORK,
"-p", f"127.0.0.1:{port}:8080",
"-v", f"{ROOT}/secrets/database_url:/run/secrets/database_url:ro",
"-e", "DATABASE_URL_FILE=/run/secrets/database_url",
"-e", "CACHE_URL=redis://valkey:6379/0",
IMAGE]
def wait_ready(base_url, timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
with urllib.request.urlopen(base_url + "/health/ready", timeout=1) as response:
if response.status == 200:
return
except (urllib.error.URLError, ConnectionError, TimeoutError):
pass
time.sleep(0.2)
raise RuntimeError("Test container did not become ready")
def connection_rejected(base_url):
try:
with urllib.request.urlopen(base_url + "/health/ready", timeout=0.5):
return False
except urllib.error.HTTPError:
return False
except (urllib.error.URLError, ConnectionError, TimeoutError):
return True
def test_shutdown(incomplete_request):
name = "mtusi-messenger-sigterm-" + uuid.uuid4().hex[:8]
base_url = f"http://127.0.0.1:{PORT}"
scenario = "incomplete POST" if incomplete_request else "idle"
pending = None
try:
run(*docker_run_args(name, PORT))
wait_ready(base_url)
if incomplete_request:
pending = socket.create_connection(("127.0.0.1", PORT), timeout=3)
pending.sendall(
b"POST /api/v1/users HTTP/1.1\r\n"
b"Host: localhost\r\nContent-Type: application/json\r\n"
b"Content-Length: 100\r\nExpect: 100-continue\r\n\r\n"
)
response = b""
while b"\r\n\r\n" not in response:
part = pending.recv(1024)
if not part:
raise AssertionError("Connection closed before 100 Continue")
response += part
if b"100 Continue" not in response:
raise AssertionError(f"Expected 100 Continue, received {response!r}")
pending.sendall(b"{")
print(f"Scenario: {scenario}; docker stop --timeout 10 {name}", flush=True)
start = time.monotonic()
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
stopped = executor.submit(run, "docker", "stop", "--timeout", "10", name)
deadline = start + 2
while not connection_rejected(base_url):
if time.monotonic() >= deadline:
raise AssertionError("New connections are still accepted during shutdown")
time.sleep(0.05)
rejected_after = time.monotonic() - start
stopped.result(timeout=12)
elapsed = time.monotonic() - start
exit_code = int(run("docker", "inspect", name, "--format", "{{.State.ExitCode}}").stdout)
if exit_code != 0:
raise AssertionError(f"Container exited with code {exit_code}, expected 0")
if elapsed > 10:
raise AssertionError(f"Shutdown exceeded 10 seconds: {elapsed:.3f}s")
if not connection_rejected(base_url):
raise AssertionError("API still accepts connections after shutdown")
logs = run("docker", "logs", name).stdout
if "Application shutdown complete" not in logs:
raise AssertionError("Application did not complete its shutdown handler")
print(f"PASS {scenario}: exit code 0; shutdown {elapsed:.3f}s; "
f"new connections rejected after {rejected_after:.3f}s")
finally:
if pending is not None:
pending.close()
run("docker", "rm", "-f", name, check=False)
def main():
print(f"Image: {IMAGE}")
test_shutdown(False)
test_shutdown(True)
print("PASS SIGTERM: both scenarios completed within 10 seconds")
if __name__ == "__main__":
try:
main()
except Exception as exc:
print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr)
sys.exit(1)