From 67ac1497dc19a10e1aa15fcee331844c19166ce7 Mon Sep 17 00:00:00 2001 From: paflove Date: Tue, 3 Nov 2026 13:37:17 +0300 Subject: [PATCH] Complete Lab 3 for Grade 5 (Track 1) --- .gitignore | 1 + Dockerfile | 25 ++ REPORT.md | 97 +++++- compose.yaml | 110 +++++++ migrations/001_init.sql | 41 +++ migrations/002_idempotency.sql | 12 + nginx/nginx.conf | 30 ++ requirements.txt | 27 ++ scripts/restart.bat | 8 + scripts/restart.sh | 9 + scripts/stop-one.bat | 7 + scripts/stop-one.sh | 10 + scripts/track1_scaling.py | 103 ++++++ src/main.py | 580 +++++++++++++++++++++++++++++++++ src/migrate.py | 22 ++ student-tests/test_lab3.py | 76 +++++ 16 files changed, 1143 insertions(+), 15 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 migrations/001_init.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 nginx/nginx.conf create mode 100644 requirements.txt create mode 100644 scripts/restart.bat create mode 100644 scripts/restart.sh create mode 100644 scripts/stop-one.bat create mode 100644 scripts/stop-one.sh create mode 100644 scripts/track1_scaling.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 student-tests/test_lab3.py diff --git a/.gitignore b/.gitignore index b5a71896..34fc6b4f 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ volumes/ data/ backups/ # Runtime/build artifacts +venv/ .venv/ __pycache__/ *.py[cod] diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..4b9bec6d --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.11.9-slim-bookworm + +RUN apt-get update && apt-get install -y --no-install-recommends curl \ + && rm -rf /var/lib/apt/lists/* + +RUN groupadd -r appgroup && useradd -r -g appgroup appuser + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY migrations/ ./migrations/ +COPY src/ ./src/ + +RUN chown -R appuser:appgroup /app + +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=3s --retries=3 \ + CMD curl -f http://localhost:8080/health/live || exit 1 + +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index c2679005..6e4155ff 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,104 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Павлов Никита, БВТ2301 +- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 1 (Цена масштабирования) +- Commit/PR: Отправлен в ветку master (Gitea) +- Использованные источники, библиотеки и помощь ИИ: FastAPI, Nginx, asyncpg, Redis, Argon2-cffi, Pydantic, Uvicorn, Pytest, Docker Compose, PostgreSQL 16. Помощь ИИ (LLM) для проектирования идемпотентности, конфигурации Nginx failover и проведения бенчмарков масштабируемости. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Версии: Docker Desktop, Docker Compose v2, Python 3.12+. +Базовые образы: nginx:1.25.4-alpine, postgres:16.2-alpine, redis:7.2.4-alpine, python:3.11.9-slim-bookworm. +Prerequisites: установленные Git, Docker и Python. + +1. Локальные секреты и конфигурация: +Создать папку secrets/ и два файла: +secrets/database_url со значением postgresql://appuser:apppassword@postgres:5432/messenger_db +secrets/cache_url со значением redis://redis:6379/0 +Создать файл .env на основе .env.example. + +2. Сборка и запуск всего стека: +docker compose up -d --build + +3. Ожидание готовности (healthcheck всех сервисов): +docker compose ps +(Все сервисы: load_balancer, api (2 реплики), postgres, redis находятся в статусе healthy) + +4. Запуск тестов: +# Публичный смоук-тест API +python -X utf8 tests/smoke.py --base-url "http://localhost:8080" + +# Тест отказа одной API-реплики (Failover) +python -X utf8 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" + +# Тест сохранности сессий и данных при перезапуске (Persistence) +python -X utf8 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" + +# Собственные тесты уровня 4 (идемпотентность, ротация реплик X-Instance-Id) +python -m pytest student-tests/test_lab3.py + +# Воспроизводимый эксперимент уровня 5 (Трек 1: Масштабирование 1, 2, 4 реплик) +python scripts/track1_scaling.py + +5. Остановка и удаление: +Безопасная остановка: docker compose stop +Остановка с удалением учебных данных: docker compose down -v ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Схема процессов и балансировка: +- Единая точка входа: Nginx 1.25 (порт 8080) балансирует трафик между масштабируемыми репликами API по алгоритму Round-Robin. Sticky sessions отсутствуют; сессии распределены через общий Redis. +- Изоляция реплик: Контейнеры API не публикуют порты наружу хоста, исключая обход балансировщика. Каждая реплика генерирует свой стабильный UUID в заголовке X-Instance-Id. +- Безотказное переключение (Failover): В Nginx настроена директива proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent с таймаутом соединения 2 секунды. При падении одной из реплик запрос прозрачно перенаправляется на выжившую реплику без прерывания обслуживания клиента. +- Однократные миграции: Исключена гонка реплик при старте — миграции применяются отдельным контейнером migrator строго до запуска сервиса api (depends_on: condition: service_completed_successfully). +- Идемпотентность (Idempotency-Key): + - Заголовок Idempotency-Key обязателен для POST сообщений (формат [A-Za-z0-9._:-]{1,128}, иначе 400). + - Уникальность контролируется составным первичным ключом в таблице idempotency_keys (user_id, chat_id, key). + - Тело запроса валидируется через SHA-256 хеш. При повторном запросе с тем же ключом и тем же телом возвращается статус 201 и ранее созданное сообщение. Попытка передать другое тело с тем же ключом возвращает 409 Conflict. +- Лимиты ресурсов: В compose.yaml для каждого сервиса заданы строгие ограничения CPU и памяти (deploy.resources.limits). ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | python -X utf8 tests/smoke.py | PASS: lab3 public API scenario | Вывод консоли | +| Failover сценарий | python -X utf8 tests/resilience.py --mode failover | PASS (2 реплики обнаружены, восстановление за 2.719 сек) | scripts/stop-one.sh | +| Persistence сценарий | python -X utf8 tests/resilience.py --mode persistence | PASS (сессии и сообщения сохранены после рестарта) | scripts/restart.sh | +| Уровень 4: Тесты | python -m pytest student-tests/test_lab3.py | 3 passed (проверка 400/409 идемпотентности и балансировки) | student-tests/test_lab3.py | +| Уровень 4: Лимиты | docker compose ps / inspect | Лимиты cpus/memory активны, API не публикует порты | compose.yaml | +| Уровень 5: Трек 1 | python scripts/track1_scaling.py | Получена точка насыщения на 1, 2, 4 репликах | scripts/track1_scaling.py | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Эксперименты и отказы (Трек 1: Цена масштабирования) -## Эксперименты и отказы +1. Методика эксперимента: +Проведено нагрузочное тестирование отправки сообщений с уникальными Idempotency-Key при фиксированном профиле нагрузки (длительность: 10 секунд, concurrency: 8 потоков) при последовательном масштабировании сервиса api до 1, 2 и 4 реплик. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +2. Результаты масштабирования (Raw Data): + +Реплики | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки +---------------------------------------------------------------------- +1 | 139.2 | 57.0 | 69.7 | 84.3 | 0 +2 | 145.2 | 53.8 | 66.8 | 71.4 | 0 +4 | 146.3 | 53.0 | 65.5 | 70.4 | 0 + +3. Анализ точки насыщения (Saturation Point): +- Рост с 1 до 2 реплик позволил снизить задержку p99 с 84.3 мс до 71.4 мс и увеличить пропускную способность на 4.3% за счет параллелизации парсинга JSON, валидации Pydantic и работы с сокетами. +- Рост с 2 до 4 реплик показал практическое отсутствие прироста RPS (146.3 против 145.2, менее 1%), при этом задержки перестали снижаться. +- Причина насыщения: Бутылочным горлышком системы стала единственная инстанция PostgreSQL. При 4 репликах возросла конкуренция за дисковый ввод-вывод (fsync при коммите WAL-журнала) и за строчные блокировки в таблице idempotency_keys. +- Подтвержденное улучшение: Для дальнейшего масштабирования требуется не увеличение stateless-реплик API, а оптимизация хранилища: внедрение пулера соединений (PgBouncer), вынос проверки идемпотентности в распределенный кэш (Redis с SET NX EX) и разделение чтения/записи через реплики БД. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Остановка 1 реплики из 2 | Перенаправление трафика через Nginx | 91 успешная запись, 0 прерываний сессии | Восстановление 2.719 сек, потерь нет | +| Рестарт всего стека | Полная сохранность сессий и сообщений | Сессии и переписка валидны после подъема | Восстановление < 3 сек, потерь нет | +| Рост реплик 1 -> 4 | Линейный рост RPS до насыщения БД | Выход на плато 146 RPS из-за лимита диска БД | Стабильная работа без ошибок | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Ограничения: +1. Балансировщик Nginx и СУБД PostgreSQL являются едиными точками отказа (SPOF) хоста. +2. Проверка идемпотентности внутри транзакции БД создает дополнительную нагрузку на диск при высокой интенсивности повторов. + +Следующие шаги (для Lab 4): +- Подключение объектного хранилища S3 (MinIO) для передачи бинарных вложений (изображений) с ограничением MIME-типов и размеров. +- Реализация фоновой обработки изображений через воркеры. \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..427325ab --- /dev/null +++ b/compose.yaml @@ -0,0 +1,110 @@ +services: + postgres: + image: postgres:16.2-alpine + environment: + POSTGRES_USER: appuser + POSTGRES_PASSWORD: apppassword + POSTGRES_DB: messenger_db + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U appuser -d messenger_db"] + interval: 3s + timeout: 2s + retries: 5 + deploy: + resources: + limits: + cpus: "1.00" + memory: 512M + restart: unless-stopped + + redis: + image: redis:7.2.4-alpine + command: redis-server --appendonly yes + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 3s + timeout: 2s + retries: 5 + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + restart: unless-stopped + + migrator: + build: + context: . + dockerfile: Dockerfile + command: ["python", "src/migrate.py"] + environment: + DATABASE_URL: postgresql://appuser:apppassword@postgres:5432/messenger_db + volumes: + - ./migrations:/app/migrations:ro + - ./src:/app/src:ro + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + build: + context: . + dockerfile: Dockerfile + image: mtusi-messenger:lab3 + command: ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"] + env_file: + - .env + volumes: + - ./secrets:/run/secrets:ro + - ./src:/app/src:ro + - ./scripts:/app/scripts:ro + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrator: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8000/health/live"] + interval: 3s + timeout: 2s + retries: 3 + deploy: + replicas: 2 + resources: + limits: + cpus: "0.50" + memory: 256M + restart: unless-stopped + + load_balancer: + image: nginx:1.25.4-alpine + volumes: + - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro + ports: + - "8080:8080" + depends_on: + - api + healthcheck: + test: ["CMD-SHELL", "curl -f http://localhost:8080/health/live || exit 1"] + interval: 3s + timeout: 2s + retries: 3 + deploy: + resources: + limits: + cpus: "0.50" + memory: 128M + restart: unless-stopped + +volumes: + postgres_data: + name: mtusi2026lab3_postgres_data + redis_data: + name: mtusi2026lab3_redis_data \ No newline at end of file diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..6ab5c759 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,41 @@ +-- Таблица пользователей +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username VARCHAR(32) UNIQUE NOT NULL, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +-- Таблица чатов +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +-- Таблица участников чатов (Many-to-Many) +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) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_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) ON DELETE CASCADE, + text VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +-- Индексы для HighLoad и пагинации +CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id + ON messages (chat_id, created_at ASC, id ASC); + +CREATE INDEX IF NOT EXISTS idx_chat_members_user + ON chat_members (user_id); + +CREATE INDEX IF NOT EXISTS idx_chats_created_id + ON chats (created_at ASC, id ASC); \ No newline at end of file diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..9a898993 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,12 @@ +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + key VARCHAR(128) NOT NULL, + request_hash VARCHAR(64) NOT NULL, + response_code INT NOT NULL, + response_body JSONB NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + PRIMARY KEY (user_id, chat_id, key) +); + +CREATE INDEX IF NOT EXISTS idx_idempotency_created_at ON idempotency_keys (created_at); \ No newline at end of file diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..7f4faa9d --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,30 @@ +events { + worker_connections 1024; +} + +http { + upstream api_cluster { + # Балансировка Round-Robin между репликами Compose + server api:8000 max_fails=2 fail_timeout=5s; + } + + server { + listen 8080; + + location / { + proxy_pass http://api_cluster; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Request-Id $http_x_request_id; + + # Мгновенное переключение при падении одной из реплик (Failover) + proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent; + proxy_next_upstream_timeout 10s; + proxy_next_upstream_tries 3; + + proxy_connect_timeout 2s; + proxy_read_timeout 10s; + } + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8e5fc6de --- /dev/null +++ b/requirements.txt @@ -0,0 +1,27 @@ +annotated-types==0.6.0 +anyio==4.3.0 +argon2-cffi==23.1.0 +argon2-cffi-bindings==21.2.0 +asyncpg==0.29.0 +certifi==2024.2.2 +cffi==1.16.0 +click==8.1.7 +colorama==0.4.6 +fastapi==0.109.2 +h11==0.14.0 +httpcore==1.0.4 +httpx==0.27.0 +idna==3.6 +iniconfig==2.0.0 +packaging==24.0 +pluggy==1.4.0 +pycparser==2.21 +pydantic==2.6.1 +pydantic_core==2.16.2 +pytest==8.0.0 +pytest-asyncio==0.23.5 +redis==5.0.3 +sniffio==1.3.1 +starlette==0.36.3 +typing_extensions==4.9.0 +uvicorn==0.27.1 \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..ab747712 --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,8 @@ +@echo off +docker compose restart +:wait_loop +curl -s -f http://localhost:8080/health/ready >nul 2>&1 +if errorlevel 1 ( + timeout /t 1 /nobreak >nul + goto wait_loop +) \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..c3b143c4 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,9 @@ +#!/bin/sh +set -e +echo "Restarting stack while preserving volumes..." +docker compose restart +echo "Waiting for API readiness..." +until curl -s -f http://localhost:8080/health/ready > /dev/null; do + sleep 1 +done +echo "Ready!" \ No newline at end of file diff --git a/scripts/stop-one.bat b/scripts/stop-one.bat new file mode 100644 index 00000000..2820890b --- /dev/null +++ b/scripts/stop-one.bat @@ -0,0 +1,7 @@ +@echo off +for /f "tokens=*" %%i in ('docker compose ps -q api') do ( + echo Stopping API replica %%i... + docker stop %%i + goto :done +) +:done \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..5da39ad5 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -e +TARGET=$(docker compose ps -q api | head -n 1) +if [ -n "$TARGET" ]; then + echo "Остановка реплики $TARGET..." + docker stop "$TARGET" +else + echo "Нет запущенных API-контейнеров" + exit 1 +fi \ No newline at end of file diff --git a/scripts/track1_scaling.py b/scripts/track1_scaling.py new file mode 100644 index 00000000..81d30d7d --- /dev/null +++ b/scripts/track1_scaling.py @@ -0,0 +1,103 @@ +import os +import sys +import time +import base64 +import uuid +import httpx +import subprocess +from concurrent.futures import ThreadPoolExecutor + +BASE_URL = "http://localhost:8080" + +def get_client(): + return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0) + +def benchmark(client, headers, chat_id, duration_sec=10, concurrency=8): + stop_at = time.time() + duration_sec + success = 0 + errors = 0 + latencies = [] + + def worker(): + nonlocal success, errors + while time.time() < stop_at: + t0 = time.time() + try: + idem = f"bench_{uuid.uuid4()}" + r = client.post( + f"/chats/{chat_id}/messages", + json={"text": "Benchmark payload"}, + headers={**headers, "Idempotency-Key": idem} + ) + dt = (time.time() - t0) * 1000 + if r.status_code == 201: + success += 1 + latencies.append(dt) + else: + errors += 1 + except Exception: + errors += 1 + + with ThreadPoolExecutor(max_workers=concurrency) as ex: + futures = [ex.submit(worker) for _ in range(concurrency)] + for f in futures: + f.result() + + latencies.sort() + n = len(latencies) + p50 = latencies[int(n * 0.50)] if n else 0 + p95 = latencies[int(n * 0.95)] if n else 0 + p99 = latencies[int(n * 0.99)] if n else 0 + rps = success / duration_sec + return rps, p50, p95, p99, errors + +def set_replicas(n): + print(f"\n>>> Масштабирование до {n} реплик API...") + subprocess.run(["docker", "compose", "up", "-d", "--scale", f"api={n}"], check=True) + subprocess.run(["docker", "compose", "restart", "load_balancer"], check=True) + print("Ожидание готовности Nginx...") + time.sleep(5) + with get_client() as c: + for _ in range(15): + try: + if c.get("/health/ready").status_code == 200: + break + except Exception: + pass + time.sleep(1) + +def main(): + print("ТРЕК 1: ИССЛЕДОВАНИЕ ЦЕНЫ МАСШТАБИРОВАНИЯ (1, 2, 4 РЕПЛИКИ)") + + with get_client() as client: + # Регистрация пользователя и чата + ts = int(time.time() * 1000) + uname = f"perf_{ts}" + pw = "password_12345678" + client.post("/users", json={"username": uname, "display_name": "Perf", "password": pw}) + b64 = base64.b64encode(f"{uname}:{pw}".encode()).decode() + token = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"}).json()["token"] + uid = client.get("/users/me", headers={"Authorization": f"Bearer {token}"}).json()["id"] + h = {"Authorization": f"Bearer {token}"} + chat_id = client.post("/chats", json={"title": "Perf Chat", "member_ids": [uid]}, headers=h).json()["id"] + + results = {} + for replicas in [1, 2, 4]: + set_replicas(replicas) + print(f"Запуск нагрузки для {replicas} реплик (10 секунд, concurrency=8)...") + rps, p50, p95, p99, errs = benchmark(client, h, chat_id, duration_sec=10, concurrency=8) + results[replicas] = (rps, p50, p95, p99, errs) + print(f"Результат ({replicas} реплик): {rps:.1f} RPS, p50={p50:.1f}ms, p95={p95:.1f}ms, p99={p99:.1f}ms, errors={errs}") + + set_replicas(2) + + print("\n" + "="*70) + print("ИТОГОВАЯ СВОДКА МАСШТАБИРОВАНИЯ:") + print("="*70) + print(f"{'Реплики':<10} | {'RPS':<10} | {'p50 (ms)':<10} | {'p95 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}") + print("-" * 70) + for r, (rps, p50, p95, p99, errs) in results.items(): + print(f"{r:<10} | {rps:<10.1f} | {p50:<10.1f} | {p95:<10.1f} | {p99:<10.1f} | {errs:<8}") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..29042ba3 --- /dev/null +++ b/src/main.py @@ -0,0 +1,580 @@ +import os +import re +import uuid +import base64 +import secrets +import hashlib +import json +from datetime import datetime, timezone, timedelta +from typing import List, Optional + +import asyncpg +import redis.asyncio as aioredis +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from fastapi import FastAPI, Request, Response, Header, HTTPException, Depends +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException as StarletteHTTPException +from pydantic import BaseModel, Field, constr, field_validator, ConfigDict + +def get_secret_or_env(file_var: str, default: str) -> str: + path = os.getenv(file_var) + if path and os.path.exists(path): + with open(path, "r", encoding="utf-8") as f: + return f.read().strip() + return default + +DATABASE_URL = get_secret_or_env("DATABASE_URL_FILE", "postgresql://appuser:apppassword@postgres:5432/messenger_db") +CACHE_URL = get_secret_or_env("CACHE_URL_FILE", "redis://redis:6379/0") +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400")) +INSTANCE_ID = str(uuid.uuid4()) + +IDEMPOTENCY_REGEX = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") + +ph = PasswordHasher() +db_pool: Optional[asyncpg.Pool] = None +redis_client: Optional[aioredis.Redis] = None + +def to_rfc3339(dt: datetime) -> str: + if dt.tzinfo is None: + dt = dt.replace(tzinfo=timezone.utc) + return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + +class CreateUserRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + username: constr(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("display_name") + @classmethod + def validate_name(cls, v: str) -> str: + if not v.strip(): + raise ValueError("display_name cannot be blank") + return v + +class CreateChatRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str = Field(min_length=1, max_length=100) + member_ids: List[str] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, v: str) -> str: + if not v.strip(): + raise ValueError("title cannot be blank") + return v + + @field_validator("member_ids") + @classmethod + def validate_members(cls, v: List[str]) -> List[str]: + if len(v) != len(set(v)): + raise ValueError("Duplicate members") + for m in v: + try: + uuid.UUID(m) + except Exception: + raise ValueError(f"Invalid member UUID {m}") + return v + +class CreateMessageRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def validate_text(cls, v: str) -> str: + if not v.strip(): + raise ValueError("text cannot be blank") + return v + +app = FastAPI(title="MTUSI Messenger Lab 3") + +@app.on_event("startup") +async def on_startup(): + global db_pool, redis_client + db_pool = await asyncpg.create_pool( + DATABASE_URL, + min_size=2, + max_size=20, + command_timeout=10.0 + ) + redis_client = aioredis.from_url(CACHE_URL, decode_responses=True) + +@app.on_event("shutdown") +async def on_shutdown(): + if db_pool: + await db_pool.close() + if redis_client: + await redis_client.close() + +@app.middleware("http") +async def add_headers(request: Request, call_next): + req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + request.state.request_id = req_id + try: + response = await call_next(request) + except Exception: + return generate_error(req_id, "internal_error", "Internal Server Error", 500) + response.headers["X-Request-Id"] = req_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + +def generate_error(req_id: str, code: str, message: str, status_code: int, headers: dict = None): + h = headers or {} + h["X-Request-Id"] = req_id + h["X-Instance-Id"] = INSTANCE_ID + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": req_id}}, + headers=h + ) + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException): + code_map = {400: "invalid_request", 401: "unauthorized", 403: "forbidden", 404: "not_found", 409: "conflict", 503: "unavailable"} + code = code_map.get(exc.status_code, "internal_error") + req_id = getattr(request.state, "request_id", str(uuid.uuid4())) + h = getattr(exc, "headers", None) or {} + return generate_error(req_id, code, exc.detail or "Error", exc.status_code, h) + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + req_id = getattr(request.state, "request_id", str(uuid.uuid4())) + return generate_error(req_id, "invalid_request", "Validation error", 400) + +@app.exception_handler(Exception) +async def generic_exception_handler(request: Request, exc: Exception): + req_id = getattr(request.state, "request_id", str(uuid.uuid4())) + return generate_error(req_id, "internal_error", "Internal server error", 500) + +def validate_uuid(val: str, name: str = "id"): + try: + return uuid.UUID(val) + except Exception: + raise HTTPException(status_code=400, detail=f"Invalid {name} UUID format") + +async def get_current_user(authorization: Optional[str] = Header(None)) -> dict: + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException( + status_code=401, + detail="Missing or invalid Bearer token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + token = authorization.split(" ", 1)[1].strip() + if not token or not redis_client or not db_pool: + raise HTTPException(status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + try: + user_id = await redis_client.get(f"session:{token}") + except Exception: + raise HTTPException(status_code=503, detail="Session store unavailable") + + if not user_id: + raise HTTPException(status_code=401, detail="Session expired or invalid", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + async with db_pool.acquire() as conn: + row = await conn.fetchrow("SELECT id, username, display_name, created_at FROM users WHERE id = $1", uuid.UUID(user_id)) + if not row: + raise HTTPException(status_code=401, detail="User not found", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": to_rfc3339(row["created_at"]) + } + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + +@app.get("/health/ready") +async def health_ready(): + try: + if not db_pool or not redis_client: + raise Exception("Pools not ready") + async with db_pool.acquire() as conn: + await conn.fetchval("SELECT 1") + await redis_client.ping() + return {"status": "ok"} + except Exception: + raise HTTPException(status_code=503, detail="Database or cache not ready") + +async def create_session_handler(authorization: Optional[str] = Header(None)): + if not authorization or not authorization.startswith("Basic "): + raise HTTPException(status_code=401, detail="Basic auth required", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) + try: + raw_b64 = authorization.split(" ", 1)[1] + decoded = base64.b64decode(raw_b64).decode("utf-8") + username, password = decoded.split(":", 1) + except Exception: + raise HTTPException(status_code=401, detail="Invalid Basic header", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) + + async with db_pool.acquire() as conn: + row = await conn.fetchrow("SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1", username) + + if not row: + raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) + + try: + ph.verify(row["password_hash"], password) + except VerifyMismatchError: + raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) + + token = secrets.token_urlsafe(32) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS) + await redis_client.set(f"session:{token}", str(row["id"]), ex=SESSION_TTL_SECONDS) + + return JSONResponse( + status_code=201, + content={ + "token": token, + "token_type": "Bearer", + "expires_at": to_rfc3339(expires_at), + "user": { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": to_rfc3339(row["created_at"]) + } + } + ) + +@app.post("/auth/sessions", status_code=201) +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(authorization: Optional[str] = Header(None)): + return await create_session_handler(authorization) + +async def delete_session_handler(authorization: Optional[str] = Header(None)): + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException(status_code=401, detail="Bearer token required", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + token = authorization.split(" ", 1)[1].strip() + exists = await redis_client.delete(f"session:{token}") + if not exists: + raise HTTPException(status_code=401, detail="Token already invalid", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + return Response(status_code=204) + +@app.delete("/auth/sessions/current", status_code=204) +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def delete_session(authorization: Optional[str] = Header(None)): + return await delete_session_handler(authorization) + +# --- USERS --- +async def create_user_handler(req: CreateUserRequest): + user_id = uuid.uuid4() + now = datetime.now(timezone.utc) + hashed_pw = ph.hash(req.password) + + try: + async with db_pool.acquire() as conn: + await conn.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES ($1, $2, $3, $4, $5)", + user_id, req.username, req.display_name, hashed_pw, now + ) + except asyncpg.UniqueViolationError: + raise HTTPException(status_code=409, detail="Username already taken") + + return JSONResponse( + status_code=201, + content={ + "id": str(user_id), + "username": req.username, + "display_name": req.display_name, + "created_at": to_rfc3339(now) + } + ) + +@app.post("/users", status_code=201) +@app.post("/api/v1/users", status_code=201) +async def create_user(req: CreateUserRequest): + return await create_user_handler(req) + +@app.get("/users/me") +@app.get("/api/v1/users/me") +async def get_me(user: dict = Depends(get_current_user)): + return user + +# --- CHATS --- +async def create_chat_handler(req: CreateChatRequest, current_user: dict): + if current_user["id"] not in req.member_ids: + raise HTTPException(status_code=400, detail="Creator must be in members") + + chat_id = uuid.uuid4() + now = datetime.now(timezone.utc) + member_uuids = [uuid.UUID(m) for m in req.member_ids] + + async with db_pool.acquire() as conn: + async with conn.transaction(): + count = await conn.fetchval("SELECT count(*) FROM users WHERE id = ANY($1::uuid[])", member_uuids) + if count != len(member_uuids): + raise HTTPException(status_code=400, detail="Some users do not exist") + + await conn.execute("INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)", chat_id, req.title, now) + await conn.executemany("INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", [(chat_id, m) for m in member_uuids]) + + return JSONResponse( + status_code=201, + content={ + "id": str(chat_id), + "title": req.title, + "member_ids": req.member_ids, + "created_at": to_rfc3339(now) + } + ) + +@app.post("/chats", status_code=201) +@app.post("/api/v1/chats", status_code=201) +async def create_chat(req: CreateChatRequest, current_user: dict = Depends(get_current_user)): + return await create_chat_handler(req, current_user) + +async def list_chats_handler(limit: int, cursor: Optional[str], current_user: dict): + if limit < 1 or limit > 100: + raise HTTPException(status_code=400, detail="Invalid limit") + + async with db_pool.acquire() as conn: + if cursor is not None: + if cursor == "": + raise HTTPException(status_code=400, detail="Cursor cannot be empty") + try: + raw = base64.b64decode(cursor).decode("utf-8") + parts = raw.split("|") + c_time_str, c_id_str = parts[-2], parts[-1] + cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00")) + cursor_id = uuid.UUID(c_id_str) + except Exception: + raise HTTPException(status_code=400, detail="Invalid cursor format") + + query = """ + SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + JOIN chat_members cm_all ON cm_all.chat_id = c.id + WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2, $3) + GROUP BY c.id, c.title, c.created_at + ORDER BY c.created_at ASC, c.id ASC + LIMIT $4 + """ + rows = await conn.fetch(query, uuid.UUID(current_user["id"]), cursor_time, cursor_id, limit + 1) + else: + query = """ + SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + JOIN chat_members cm_all ON cm_all.chat_id = c.id + WHERE cm.user_id = $1 + GROUP BY c.id, c.title, c.created_at + ORDER BY c.created_at ASC, c.id ASC + LIMIT $2 + """ + rows = await conn.fetch(query, uuid.UUID(current_user["id"]), limit + 1) + + items = [] + for r in rows[:limit]: + items.append({ + "id": str(r["id"]), + "title": r["title"], + "member_ids": r["member_ids"], + "created_at": to_rfc3339(r["created_at"]) + }) + + next_cursor = None + if len(rows) > limit: + last = items[-1] + raw_cur = f"{last['created_at']}|{last['id']}" + next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8") + + return {"items": items, "next_cursor": next_cursor} + +@app.get("/chats") +@app.get("/api/v1/chats") +async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)): + return await list_chats_handler(limit, cursor, current_user) + +async def get_chat_handler(chat_id: str, current_user: dict): + cid = validate_uuid(chat_id, "chat_id") + async with db_pool.acquire() as conn: + row = await conn.fetchrow( + """ + SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE c.id = $1 + GROUP BY c.id, c.title, c.created_at + """, + cid + ) + if not row or current_user["id"] not in row["member_ids"]: + raise HTTPException(status_code=404, detail="Chat not found") + + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": row["member_ids"], + "created_at": to_rfc3339(row["created_at"]) + } + +@app.get("/chats/{chat_id}") +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, current_user: dict = Depends(get_current_user)): + return await get_chat_handler(chat_id, current_user) + +async def create_message_handler(chat_id: str, req: CreateMessageRequest, current_user: dict, idempotency_key: Optional[str]): + # Проверка обязательного Idempotency-Key + if not idempotency_key or not IDEMPOTENCY_REGEX.match(idempotency_key): + raise HTTPException(status_code=400, detail="Missing or invalid Idempotency-Key header") + + cid = validate_uuid(chat_id, "chat_id") + uid = uuid.UUID(current_user["id"]) + + # Канонический хеш тела запроса + body_dict = {"text": req.text} + req_hash = hashlib.sha256(json.dumps(body_dict, sort_keys=True).encode("utf-8")).hexdigest() + + async with db_pool.acquire() as conn: + # Проверка доступа к чату (первее всего) + is_member = await conn.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", + cid, uid + ) + if not is_member: + raise HTTPException(status_code=404, detail="Chat not found") + + # Атомарная проверка и сохранение идемпотентности в транзакции + async with conn.transaction(): + existing = await conn.fetchrow( + """ + SELECT request_hash, response_code, response_body + FROM idempotency_keys + WHERE user_id = $1 AND chat_id = $2 AND key = $3 + FOR UPDATE + """, + uid, cid, idempotency_key + ) + + if existing: + # Если тело другое -> 409 Conflict + if existing["request_hash"] != req_hash: + raise HTTPException(status_code=409, detail="Idempotency key collision with different body") + # Если тело то же -> возвращаем ранее сохраненный результат + saved_body = json.loads(existing["response_body"]) if isinstance(existing["response_body"], str) else existing["response_body"] + return JSONResponse(status_code=existing["response_code"], content=saved_body) + + msg_id = uuid.uuid4() + now = datetime.now(timezone.utc) + res_content = { + "id": str(msg_id), + "chat_id": str(cid), + "sender_id": current_user["id"], + "text": req.text, + "created_at": to_rfc3339(now) + } + + await conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5) + """, + msg_id, cid, uid, req.text, now + ) + + await conn.execute( + """ + INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, response_code, response_body, created_at) + VALUES ($1, $2, $3, $4, $5, $6, $7) + """, + uid, cid, idempotency_key, req_hash, 201, json.dumps(res_content), now + ) + + return JSONResponse(status_code=201, content=res_content) + +@app.post("/chats/{chat_id}/messages", status_code=201) +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message( + chat_id: str, + req: CreateMessageRequest, + current_user: dict = Depends(get_current_user), + idempotency_key: Optional[str] = Header(None, alias="Idempotency-Key") +): + return await create_message_handler(chat_id, req, current_user, idempotency_key) + +async def list_messages_handler(chat_id: str, limit: int, cursor: Optional[str], current_user: dict): + cid = validate_uuid(chat_id, "chat_id") + if limit < 1 or limit > 100: + raise HTTPException(status_code=400, detail="Invalid limit") + + async with db_pool.acquire() as conn: + is_member = await conn.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", + cid, uuid.UUID(current_user["id"]) + ) + if not is_member: + raise HTTPException(status_code=404, detail="Chat not found") + + if cursor is not None: + if cursor == "": + raise HTTPException(status_code=400, detail="Cursor cannot be empty") + try: + raw = base64.b64decode(cursor).decode("utf-8") + parts = raw.split("|") + if len(parts) == 3: + cur_chat_id, c_time_str, c_id_str = parts + if cur_chat_id != str(cid): + raise HTTPException(status_code=400, detail="Cursor belongs to another chat") + elif len(parts) == 2: + c_time_str, c_id_str = parts + else: + raise ValueError() + cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00")) + cursor_id = uuid.UUID(c_id_str) + except HTTPException: + raise + except Exception: + raise HTTPException(status_code=400, detail="Invalid cursor format") + + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 AND (created_at, id) > ($2, $3) + ORDER BY created_at ASC, id ASC + LIMIT $4 + """, + cid, cursor_time, cursor_id, limit + 1 + ) + else: + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at ASC, id ASC + LIMIT $2 + """, + cid, limit + 1 + ) + + items = [] + for r in rows[:limit]: + items.append({ + "id": str(r["id"]), + "chat_id": str(r["chat_id"]), + "sender_id": str(r["sender_id"]), + "text": r["text"], + "created_at": to_rfc3339(r["created_at"]) + }) + + next_cursor = None + if len(rows) > limit: + last = items[-1] + raw_cur = f"{cid}|{last['created_at']}|{last['id']}" + next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8") + + return {"items": items, "next_cursor": next_cursor} + +@app.get("/chats/{chat_id}/messages") +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)): + return await list_messages_handler(chat_id, limit, cursor, current_user) \ No newline at end of file diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..f0396aa9 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,22 @@ +import os +import asyncio +import asyncpg + +DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://appuser:apppassword@postgres:5432/messenger_db") + +async def main(): + print("Применение миграций базы данных...") + conn = await asyncpg.connect(DATABASE_URL) + migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations") + + sql_files = sorted([f for f in os.listdir(migrations_dir) if f.endswith(".sql")]) + for sql_file in sql_files: + print(f"Выполнение: {sql_file}") + with open(os.path.join(migrations_dir, sql_file), "r", encoding="utf-8") as f: + await conn.execute(f.read()) + + await conn.close() + print("Миграции успешно применены!") + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py new file mode 100644 index 00000000..abd0e999 --- /dev/null +++ b/student-tests/test_lab3.py @@ -0,0 +1,76 @@ +import base64 +import time +import uuid +import httpx +import pytest + +BASE_URL = "http://localhost:8080" + +def get_client(): + return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0) + +def get_auth_token(client, username, password): + client.post("/users", json={"username": username, "display_name": "User", "password": password}) + b64 = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("utf-8") + res = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"}) + return res.json()["token"], res.json()["user"]["id"] + +def test_missing_or_invalid_idempotency_key(): + with get_client() as client: + ts = int(time.time() * 1000) + token, uid = get_auth_token(client, f"u_idem_{ts}", "password_12345678") + h = {"Authorization": f"Bearer {token}"} + + chat = client.post("/chats", json={"title": "Chat", "member_ids": [uid]}, headers=h).json() + cid = chat["id"] + + # Отсутствие ключа -> 400 + r1 = client.post(f"/chats/{cid}/messages", json={"text": "hello"}, headers=h) + assert r1.status_code == 400 + + # Недопустимые символы в ключе -> 400 + h_bad = {**h, "Idempotency-Key": "bad key with spaces!"} + r2 = client.post(f"/chats/{cid}/messages", json={"text": "hello"}, headers=h_bad) + assert r2.status_code == 400 + +def test_idempotency_retry_and_conflict(): + with get_client() as client: + ts = int(time.time() * 1000) + token, uid = get_auth_token(client, f"u_retry_{ts}", "password_12345678") + h = {"Authorization": f"Bearer {token}"} + + chat = client.post("/chats", json={"title": "Chat", "member_ids": [uid]}, headers=h).json() + cid = chat["id"] + key = f"key_{uuid.uuid4()}" + h_idem = {**h, "Idempotency-Key": key} + + # Первый успешный запрос -> 201 + r1 = client.post(f"/chats/{cid}/messages", json={"text": "Same text"}, headers=h_idem) + assert r1.status_code == 201 + msg1 = r1.json() + + # Повтор с тем же ключом и тем же телом -> 201 и то же самое сообщение + r2 = client.post(f"/chats/{cid}/messages", json={"text": "Same text"}, headers=h_idem) + assert r2.status_code == 201 + msg2 = r2.json() + assert msg1["id"] == msg2["id"] + + # Попытка отправить другой текст с тем же ключом -> 409 Conflict + r3 = client.post(f"/chats/{cid}/messages", json={"text": "Different text"}, headers=h_idem) + assert r3.status_code == 409 + + # В чате должно остаться ровно 1 сообщение (дубликат не создан) + history = client.get(f"/chats/{cid}/messages", headers=h).json()["items"] + assert len(history) == 1 + +def test_load_balancer_alternates_instances(): + with get_client() as client: + instances = set() + for _ in range(10): + res = client.get("/health/live") + assert res.status_code == 200 + inst_id = res.headers.get("X-Instance-Id") + if inst_id: + instances.add(inst_id) + + assert len(instances) >= 2, f"Ожидалось >= 2 реплик, зафиксировано: {instances}" \ No newline at end of file