From 786bb2077f68117d182905f52d7b9ebfc8b96e47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=98=D0=BB=D1=8C=D1=8F=D1=81?= Date: Fri, 30 Oct 2026 12:17:01 +0300 Subject: [PATCH] =?UTF-8?q?feat:=20=D0=9B=D0=A03=20-=20Nginx=20=D0=B1?= =?UTF-8?q?=D0=B0=D0=BB=D0=B0=D0=BD=D1=81=D0=B8=D1=80=D0=BE=D0=B2=D0=BA?= =?UTF-8?q?=D0=B0,=20=D0=B8=D0=B4=D0=B5=D0=BC=D0=BF=D0=BE=D1=82=D0=B5?= =?UTF-8?q?=D0=BD=D1=82=D0=BD=D0=BE=D1=81=D1=82=D1=8C=20=D1=81=D0=BE=D0=BE?= =?UTF-8?q?=D0=B1=D1=89=D0=B5=D0=BD=D0=B8=D0=B9=20=D0=B8=20failover?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 17 +- .gitignore | 1 + Dockerfile | 2 +- Makefile | 17 +- REPORT.md | 156 +++++++++++++++-- app/config.py | 3 + app/errors.py | 7 +- app/main.py | 2 +- app/middleware.py | 3 + app/routes/messages.py | 13 +- app/schemas.py | 6 +- app/storage.py | 130 ++++++++++---- compose.yaml | 154 +++++++++++++++++ evidence/check_contract.log | 2 + evidence/docker_services.log | 6 + evidence/failover_test.log | 3 + evidence/load.json | 17 ++ evidence/persistence_test.log | 2 + evidence/round_robin.log | 10 ++ evidence/smoke_test.log | 1 + evidence/student_tests.log | 38 ++++ evidence/validate_openapi.log | 2 + infra/init.sql | 12 ++ infra/nginx.conf | 71 ++++++++ scripts/restart.sh | 8 + scripts/stop-one.sh | 13 ++ tests_student/tests.py | 317 +++++++++++++++++++++++++++++++++- 27 files changed, 943 insertions(+), 70 deletions(-) create mode 100644 compose.yaml create mode 100644 evidence/check_contract.log create mode 100644 evidence/docker_services.log create mode 100644 evidence/failover_test.log create mode 100644 evidence/load.json create mode 100644 evidence/persistence_test.log create mode 100644 evidence/round_robin.log create mode 100644 evidence/smoke_test.log create mode 100644 evidence/student_tests.log create mode 100644 evidence/validate_openapi.log create mode 100644 infra/nginx.conf create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh diff --git a/.env.example b/.env.example index d32b9be..47e9a64 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,18 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url + +# PostgreSQL credentials and database configuration +POSTGRES_USER=postgres +POSTGRES_PASSWORD=postgres +POSTGRES_DB=messenger +DATABASE_URL=postgresql://postgres:postgres@postgres:5432/messenger + +# Redis session store configuration +SESSION_STORE=redis +CACHE_URL=redis://redis:6379/0 + API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 diff --git a/.gitignore b/.gitignore index b5a7189..e6a53fe 100644 --- a/.gitignore +++ b/.gitignore @@ -25,6 +25,7 @@ bin/ obj/ coverage/ *.log +!evidence/*.log .DS_Store .idea/ .vscode/ diff --git a/Dockerfile b/Dockerfile index 8701024..11c8f2a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -22,6 +22,6 @@ USER appuser EXPOSE 8080 HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ - CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')" || exit 1 + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready')" || exit 1 CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "10"] diff --git a/Makefile b/Makefile index 5d86d17..a488330 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,12 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover test-student up down restart help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "test-student: run student tests (pytest); test-persistence: test stack restart with data preservation" + @echo "test-failover: test replica failure handling; up: build and start stack; down: stop stack" check: $(PYTHON) scripts/check_contract.py @@ -28,3 +30,16 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-student: + BASE_URL="$(BASE_URL)" .venv/bin/pytest tests_student/ -v + +up: + docker compose up -d --build + +down: + docker compose down + +restart: + docker compose restart + diff --git a/REPORT.md b/REPORT.md index c267900..e0c4173 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,159 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Герейханов Ильяс, БВТ2301 +- Целевая оценка: 4 +- Commit/PR: ветка `solution/bvt2301-Gereykhanov`. PR: `ЛР 3 — БВТ2301 — Герейханов — на 4` +- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, Uvicorn, PostgreSQL 16, Redis 7, Nginx 1.27, asyncpg, argon2-cffi, Pydantic, Pytest, Docker Compose; документация Nginx, RFC 7231, OpenAPI 3.1.0. ИИ использовался для подготовки скриптов, отладки конфигурации nginx и расширения тестов pytest. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +1. **Версии runtime и базовых образов:** + - Локальный runtime: Linux, Docker 29.9.1, Docker Compose v5.6.0 + - Load Balancer: `nginx:1.27-alpine` + - API контейнеры: `python:3.12-slim` + - PostgreSQL: `postgres:16-alpine` + - Redis: `redis:7-alpine` + +2. **Подготовка окружения и запуск стека:** + ```sh + git checkout solution/bvt2301-Gereykhanov + cp .env.example .env + + # Сборка и запуск всех сервисов + make up + ``` + +3. **Ожидание готовности и запуск тестов:** + ```sh + # Проверка структуры и синтаксиса + make check + + # Проверка smoke теста + make test + + # Проверка сценария сохранности данных и сессий при рестарте + make test-persistence ACTION_SCRIPT=scripts/restart.sh + + # Проверка отказоустойчивости при отключении одной API-реплики + make test-failover ACTION_SCRIPT=scripts/stop-one.sh + + # Восстановление остановленной реплики после теста + docker compose up -d + + # Запуск собственных тестов + .venv/bin/pytest tests_student + + # Запуск нагрузочного теста + python3 tests/load.py --duration 10 --concurrency 4 --output evidence/load.json + ``` + +4. **Остановка и очистка:** + ```sh + # Остановка с сохранением данных volumes + docker compose down + + # Остановка с удалением volumes + docker compose down -v + ``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +- **Топология процессов и распределение ролей:** + - **Клиент** отправляет все HTTP-запросы в единую точку входа **Nginx Load Balancer** на порт `8080`. + - **Nginx** осуществляет Round-Robin балансировку между двумя независимыми репликами API. + - Реплики API без портирования наружу хоста, не обходят балансировщик. + - Каждая реплика API обращается к общему **PostgreSQL** (пользователи, чаты, сообщения, ключи идемпотентности) и общему **Redis** (хранилище сессий). + - Есть отдельный одноразовый контейнер **migration**, применяющий `init.sql` перед стартом API-реплик. +- **Идентификация реплик (`X-Instance-Id`):** + - Каждая реплика API конфигурируется переменной окружения `INSTANCE_ID` (`api-1` и `api-2`). + - Middleware и глобальный обработчик ошибок возвращают заголовок `X-Instance-Id` в каждом HTTP ответе. + - При последовательных запросах идет чередование инстансов `api-1` и `api-2`. +- **Общие сессии без Sticky Sessions:** + - Токены Bearer-сессий хранятся в Redis с TTL (`SESSION_TTL_SECONDS=3600`) и сохраняются на `redis_data` через `--appendonly yes`. + - Вход пользователя через одну реплику дает выполнять запросы через любую другую реплику без повторной аутентификации. +- **Идемпотентность отправки сообщений:** + - Заголовок `Idempotency-Key` обязателен для `POST /api/v1/chats/{chat_id}/messages`. + - Область уникальности: `(user_id, chat_id, idempotency_key)`. + - В PostgreSQL создана таблица `idempotency_keys` с ограничением `PRIMARY KEY (user_id, chat_id, idempotency_key)`. + - В транзакции создания сообщения сохраняется хэш тела запроса (`SHA-256` от нормализованного JSON). + - При одновременных запросах с одним ключом в разные реплики ограничение `PRIMARY KEY` предотвращает вставку дубликата; проигравшая транзакция перехватывает `UniqueViolationError` и возвращает результат победителя. +- **Динамический DNS и быстрый Failover в Nginx:** + - Nginx настроен с внутренним Docker DNS-резолвером `resolver 127.0.0.11 valid=2s ipv6=off;` и зоной разделяемой памяти `zone api_backend 64k;`: + ```nginx + upstream api_backend { + zone api_backend 64k; + server api-1:8080 resolve max_fails=1 fail_timeout=2s; + server api-2:8080 resolve max_fails=1 fail_timeout=2s; + } + ``` + Параметр `resolve` динамически переопределяет IP-адреса реплик в runtime при пересоздании контейнеров без перезагрузки Nginx. +- **Ограничения ресурсов и масштабируемость:** + - Все сервисы с лимитамт CPU и RAM. + - Для API-реплик не задаётся параметр `container_name`, чтобы не мешать масштабированию. + ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Проверка синтаксиса и контракта | `make check` | `PASS: offline skeleton structure, local refs and Python syntax` | [`evidence/check_contract.log`](evidence/check_contract.log) | +| Полная OpenAPI 3.1 валидация | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1 and JSON Schema validation` | [`evidence/validate_openapi.log`](evidence/validate_openapi.log) | +| Публичный smoke-сценарий | `make test` | `PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.` | [`evidence/smoke_test.log`](evidence/smoke_test.log) | +| Чередование реплик (LB) | `for i in {1..10}; do curl -sI http://localhost:8080/health/live \| grep -i x-instance-id; done` | Попеременные ответы `api-1` и `api-2` (Round-Robin 50/50) | [`evidence/round_robin.log`](evidence/round_robin.log) | +| Сохранение данных и сессий при рестарте | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Стек перезапущен, токен и сообщения сохранены | [`evidence/persistence_test.log`](evidence/persistence_test.log) | +| Отказ API-реплики (Failover) | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | Восстановление записи за **0.447 с**, 0 потерь, дубликатов нет | [`evidence/failover_test.log`](evidence/failover_test.log) | +| Собственные расширенные тесты | `make test-student` | **26 тестов проходят**: валидация `Idempotency-Key`, `X-Instance-Id`, ACL-инъекции, пагинация курсором | [`evidence/student_tests.log`](evidence/student_tests.log) | +| Статусы и лимиты контейнеров | `docker compose ps` | Все 5 сервисов запущены и healthy, API не светят порты на хост | [`evidence/docker_services.log`](evidence/docker_services.log) | +| Нагрузочный бенчмарк | `make load` | **337.1 RPS**, p50 = 6.7 ms, p95 = 53.1 ms, p99 = 79.4 ms, 0 ошибок | [`evidence/load.json`](evidence/load.json) | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +- **Профиль нагрузки:** скрипт `tests/load.py`, закрытый цикл параллельных POST-запросов отправки сообщений с уникальными `Idempotency-Key`. +- **Параметры:** длительность 10 секунд, 4 параллельных потока. +- **Результаты нагрузки (`evidence/load.json`):** + ```json + { + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 10.0, + "elapsed_seconds": 10.065, + "concurrency": 4, + "successful_requests": 3393, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 337.112, + "successful_latency_ms": { + "p50": 6.724, + "p95": 53.145, + "p99": 79.35 + } + } + ``` -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Остановка одной реплики API (`scripts/stop-one.sh`) под нагрузкой | Nginx переключает трафик на живую реплику; продолжение записи $\le 10$ с; отсутствие дубликатов | 122 успешных записи во время остановки, 0 ошибок, переключение за 0.447 с | 0.447 сек, потерь данных нет | +| Рестарт всего стека (`scripts/restart.sh`) при активной сессии | Сохранение подтверждённых данных в Postgres и токенов сессий в Redis; восстановление API $\le 90$ с | Контейнеры перезапущены, токен валиден, история сообщений сохранена | Восстановление за 2.1 сек, потеря подтверждённых данных: 0 | +| Повтор отправки сообщения с тем же `Idempotency-Key` и телом | Возврат кода 201 и сохранённого сообщения без создания дубликата в БД | 201 Created, ID и текст сообщения идентичны исходным | Мгновенно, извлечение из таблицы `idempotency_keys` | +| Повтор сообщения с тем же `Idempotency-Key`, но изменённым текстом | Отклонение запроса с конфликтом | 409 Conflict | Мгновенно, защита целостности данных | +| Повтор сообщения с тем же ключом после удаления пользователя из чата | Проверка прав доступа перед возвратом кэшированного ответа | 404 Not Found | Проверка ACL выполняется до чтения кэша идемпотентности | +| Пересоздание контейнера с новым IP (`docker compose up -d --force-recreate api-1`) | Nginx динамически обновляет IP в runtime без ручного reload | Nginx переопределяет IP через Docker DNS `127.0.0.11` за 2 с и продолжает балансировку | До 2 секунд | -## Ограничения и следующие шаги +## Ограничения + +- **Какие отказы выдерживаются и какие нет:** + 1. *Выдерживаются:* + - Внезапная остановка любой одной API-реплики под нагрузкой: балансировщик Nginx переключает входящие запросы на оставшуюся работоспособную реплику за $<0.5$ секунды без потери данных и дубликатов. + - Полный рестарт стека: все подтверждённые данные и активные Bearer-токены сохраняются благодаря volumes `pg_data` и `redis_data` + - Конкурентная отправка сообщений с одинаковым `Idempotency-Key` в разные реплики: ограничение в базе гарантирует, что будет создана ровно одна запись, а проигравшая гонку реплика вернёт созданное сообщение. + - Пересоздание контейнеров со сменой IP: встроенный Docker DNS-резолвер Nginx автоматически обновляет адреса в shared memory zone за 2 секунды. + 2. *Не выдерживаются:* + - Одновременное падение обеих API-реплик (клиент получает HTTP 502 Bad Gateway от Nginx). + - Падение единственного экземпляра PostgreSQL или Redis. + - Удаление Docker volumes через `docker compose down -v`. +- **Учебные упрощения:** + 1. Nginx, PostgreSQL и Redis запущены в единственном экземпляре без кластеризации и репликации. + 2. Ключи идемпотентности сохраняются в БД бессрочно. +- **Следующий шаг (Лаба 4):** + - Подключение S3-совместимого хранилища (MinIO) для бинарных вложений к сообщениям чата и разграничение доступа к файлам по presigned URLs. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. diff --git a/app/config.py b/app/config.py index 96df5c0..008b5ab 100644 --- a/app/config.py +++ b/app/config.py @@ -1,6 +1,7 @@ from __future__ import annotations import os +import socket from pathlib import Path @@ -19,6 +20,8 @@ LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO") SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600")) SESSION_STORE: str = os.getenv("SESSION_STORE", "redis").lower() +INSTANCE_ID: str = os.getenv("INSTANCE_ID") or socket.gethostname() or "api-1" +IDEMPOTENCY_TTL_SECONDS: int = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400")) DATABASE_URL: str = _get_val( "DATABASE_URL", diff --git a/app/errors.py b/app/errors.py index de77950..4fba0cf 100644 --- a/app/errors.py +++ b/app/errors.py @@ -9,6 +9,7 @@ from fastapi.responses import JSONResponse import redis.exceptions from starlette.exceptions import HTTPException as StarletteHTTPException +from app.config import INSTANCE_ID from app.schemas import ErrorCode, ErrorDetail, ErrorResponse @@ -56,7 +57,11 @@ def make_error_response( payload = ErrorResponse( error=ErrorDetail(code=code, message=message, request_id=request_id) ).model_dump() - resp_headers = {"X-Request-Id": request_id, "Content-Type": "application/json"} + resp_headers = { + "X-Request-Id": request_id, + "X-Instance-Id": INSTANCE_ID, + "Content-Type": "application/json", + } if headers: resp_headers.update(headers) return JSONResponse( diff --git a/app/main.py b/app/main.py index 87686eb..14e921c 100644 --- a/app/main.py +++ b/app/main.py @@ -32,7 +32,7 @@ async def lifespan(app: FastAPI): app = FastAPI( title="highload-messenger", - version="1.2.0", + version="1.3.0", docs_url="/docs", redoc_url=None, lifespan=lifespan, diff --git a/app/middleware.py b/app/middleware.py index bb0746b..3bd4574 100644 --- a/app/middleware.py +++ b/app/middleware.py @@ -9,6 +9,8 @@ from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoin from starlette.requests import Request from starlette.responses import Response +from app.config import INSTANCE_ID + logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", @@ -60,6 +62,7 @@ class RequestIdAndLoggingMiddleware(BaseHTTPMiddleware): duration_ms = (time.monotonic() - start_time) * 1000 response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID # лог без логирования тела запросов и текстов сообщений logger.info( diff --git a/app/routes/messages.py b/app/routes/messages.py index 08234f3..3377f45 100644 --- a/app/routes/messages.py +++ b/app/routes/messages.py @@ -1,8 +1,7 @@ -from __future__ import annotations - +import re from uuid import UUID -from fastapi import APIRouter, Depends, Query, status +from fastapi import APIRouter, Depends, Header, Query, status from app.dependencies import get_current_user from app.schemas import ( @@ -15,6 +14,8 @@ from app.storage import InvalidRequestError, storage router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) +IDEMPOTENCY_KEY_REGEX = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") + def validate_uuid(value: str, field_name: str = "id") -> str: try: @@ -32,14 +33,20 @@ def validate_uuid(value: str, field_name: str = "id") -> str: async def create_message( chat_id: str, body: CreateMessageRequest, + idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"), current_user: UserResponse = Depends(get_current_user), ) -> MessageResponse: """Отправка сообщения в чат.""" + if not idempotency_key or not IDEMPOTENCY_KEY_REGEX.match(idempotency_key): + raise InvalidRequestError( + "Заголовок 'Idempotency-Key' обязателен и должен соответствовать шаблону ^[A-Za-z0-9._:-]{1,128}$" + ) valid_id = validate_uuid(chat_id, "chat_id") msg = await storage.send_message( caller_id=current_user.id, chat_id=valid_id, text=body.text, + idempotency_key=idempotency_key, ) return msg diff --git a/app/schemas.py b/app/schemas.py index 24e156d..d44935d 100644 --- a/app/schemas.py +++ b/app/schemas.py @@ -46,7 +46,7 @@ class HealthResponse(BaseModel): class CreateUserRequest(BaseModel): - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) username: str = Field(min_length=3, max_length=32) display_name: str = Field(min_length=1, max_length=100) @@ -93,7 +93,7 @@ class SessionResponse(BaseModel): class CreateChatRequest(BaseModel): - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) title: str = Field(min_length=1, max_length=100) member_ids: list[str] = Field(min_length=1, max_length=100) @@ -135,7 +135,7 @@ class ChatPageResponse(BaseModel): class CreateMessageRequest(BaseModel): - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) text: str = Field(min_length=1, max_length=4000) diff --git a/app/storage.py b/app/storage.py index b3c0a1a..f41f1f1 100644 --- a/app/storage.py +++ b/app/storage.py @@ -2,6 +2,7 @@ import asyncio import base64 from contextlib import asynccontextmanager import datetime as dt +import hashlib import json import logging import uuid @@ -72,10 +73,10 @@ class PostgresStorage: self.redis_client: redis.Redis | None = None @asynccontextmanager - async def acquire_conn(self, timeout: float = 2.0): + async def acquire_conn(self, timeout: float = 5.0): if self.pg_pool is None: raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован") - async with asyncio.timeout(4.0): + async with asyncio.timeout(10.0): async with self.pg_pool.acquire(timeout=timeout) as conn: yield conn @@ -85,8 +86,8 @@ class PostgresStorage: DATABASE_URL, min_size=2, max_size=20, - command_timeout=2.0, - timeout=2.0, + command_timeout=5.0, + timeout=5.0, ) logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1]) @@ -97,18 +98,6 @@ class PostgresStorage: socket_timeout=3.0, ) - try: - async with self.acquire_conn() as conn: - col_type = await conn.fetchval( - "SELECT data_type FROM information_schema.columns WHERE table_name = 'messages' AND column_name = 'text'" - ) - if col_type in ("text", "character varying"): - await conn.execute( - "ALTER TABLE messages ALTER COLUMN text TYPE BYTEA USING text::bytea" - ) - except Exception as exc: - logger.warning("Не удалось проверить/обновить схему messages.text: %s", exc) - async def disconnect(self) -> None: if self.pg_pool: await self.pg_pool.close() @@ -136,7 +125,7 @@ class PostgresStorage: ) -> UserResponse: user_id = uuid.uuid4() now = dt.datetime.now(dt.timezone.utc) - pwd_hash = hash_password(password) + pwd_hash = await asyncio.to_thread(hash_password, password) try: async with self.acquire_conn() as conn: @@ -177,7 +166,8 @@ class PostgresStorage: if not row: return None - if not verify_password(row["password_hash"], password): + is_valid = await asyncio.to_thread(verify_password, row["password_hash"], password) + if not is_valid: return None return UserResponse( @@ -417,8 +407,13 @@ class PostgresStorage: # ------------------ Сообщения ------------------ + @staticmethod + def compute_request_hash(text: str) -> str: + canonical = json.dumps({"text": text}, sort_keys=True, ensure_ascii=False) + return hashlib.sha256(canonical.encode("utf-8")).hexdigest() + async def send_message( - self, caller_id: str, chat_id: str, text: str + self, caller_id: str, chat_id: str, text: str, idempotency_key: str ) -> MessageResponse: try: cid = uuid.UUID(chat_id) @@ -426,9 +421,7 @@ class PostgresStorage: except ValueError: raise NotFoundError("Чат не найден") - msg_id = uuid.uuid4() - now = dt.datetime.now(dt.timezone.utc) - text_bytes = text.encode("utf-8") + req_hash = self.compute_request_hash(text) async with self.acquire_conn() as conn: is_member = await conn.fetchval( @@ -439,17 +432,96 @@ class PostgresStorage: if not is_member: raise NotFoundError("Чат не найден") - await conn.execute( + # 1. Проверяем, обрабатывался ли уже этот idempotency_key + existing = await conn.fetchrow( """ - INSERT INTO messages (id, chat_id, sender_id, text, created_at) - VALUES ($1, $2, $3, $4, $5) + SELECT ik.message_id, ik.request_hash, m.text, m.created_at AS msg_created_at + FROM idempotency_keys ik + JOIN messages m ON m.id = ik.message_id + WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3 """, - msg_id, - cid, c_caller, - text_bytes, - now, + cid, + idempotency_key, ) + if existing: + if existing["request_hash"] == req_hash: + raw_text = existing["text"] + msg_text = ( + raw_text.decode("utf-8") + if isinstance(raw_text, (bytes, bytearray)) + else str(raw_text) + ) + return MessageResponse( + id=str(existing["message_id"]), + chat_id=chat_id, + sender_id=caller_id, + text=msg_text, + created_at=_format_dt(existing["msg_created_at"]), + ) + else: + raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса") + + msg_id = uuid.uuid4() + now = dt.datetime.now(dt.timezone.utc) + text_bytes = text.encode("utf-8") + + try: + async with conn.transaction(): + await conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5) + """, + msg_id, + cid, + c_caller, + text_bytes, + now, + ) + await conn.execute( + """ + INSERT INTO idempotency_keys (user_id, chat_id, idempotency_key, message_id, request_hash, created_at) + VALUES ($1, $2, $3, $4, $5, $6) + """, + c_caller, + cid, + idempotency_key, + msg_id, + req_hash, + now, + ) + except asyncpg.UniqueViolationError: + # Конкурентная вставка из другой реплики выиграла гонку + winner = await conn.fetchrow( + """ + SELECT ik.message_id, ik.request_hash, m.text, m.created_at AS msg_created_at + FROM idempotency_keys ik + JOIN messages m ON m.id = ik.message_id + WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3 + """, + c_caller, + cid, + idempotency_key, + ) + if winner: + if winner["request_hash"] == req_hash: + raw_text = winner["text"] + msg_text = ( + raw_text.decode("utf-8") + if isinstance(raw_text, (bytes, bytearray)) + else str(raw_text) + ) + return MessageResponse( + id=str(winner["message_id"]), + chat_id=chat_id, + sender_id=caller_id, + text=msg_text, + created_at=_format_dt(winner["msg_created_at"]), + ) + else: + raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса") + raise return MessageResponse( id=str(msg_id), diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..3515d13 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,154 @@ +services: + load_balancer: + image: nginx:1.27-alpine + ports: + - "8080:8080" + volumes: + - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + api-1: + condition: service_healthy + api-2: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/live"] + interval: 2s + timeout: 2s + retries: 5 + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.25' + memory: 128M + + migration: + image: postgres:16-alpine + restart: "no" + environment: + PGPASSWORD: postgres + command: > + sh -c "until pg_isready -h postgres -U postgres -d messenger; do sleep 1; done; + psql -h postgres -U postgres -d messenger -f /docker-entrypoint-initdb.d/init.sql" + volumes: + - ./infra/init.sql:/docker-entrypoint-initdb.d/init.sql:ro + depends_on: + postgres: + condition: service_healthy + deploy: + resources: + limits: + cpus: '0.25' + memory: 128M + + api-1: + build: + context: . + dockerfile: Dockerfile + image: highload-messenger:lab3 + stop_grace_period: 15s + environment: + APP_HOST: "0.0.0.0" + APP_PORT: "8080" + APP_ENV: "lab" + INSTANCE_ID: "api-1" + SESSION_TTL_SECONDS: "3600" + DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger" + SESSION_STORE: "redis" + CACHE_URL: "redis://redis:6379/0" + IDEMPOTENCY_TTL_SECONDS: "86400" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migration: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"] + interval: 2s + timeout: 2s + retries: 5 + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.50' + memory: 512M + + api-2: + build: + context: . + dockerfile: Dockerfile + image: highload-messenger:lab3 + stop_grace_period: 15s + environment: + APP_HOST: "0.0.0.0" + APP_PORT: "8080" + APP_ENV: "lab" + INSTANCE_ID: "api-2" + SESSION_TTL_SECONDS: "3600" + DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger" + SESSION_STORE: "redis" + CACHE_URL: "redis://redis:6379/0" + IDEMPOTENCY_TTL_SECONDS: "86400" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migration: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"] + interval: 2s + timeout: 2s + retries: 5 + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.50' + memory: 512M + + postgres: + image: postgres:16-alpine + environment: + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + POSTGRES_DB: messenger + volumes: + - pg_data:/var/lib/postgresql/data + - ./infra/init.sql:/docker-entrypoint-initdb.d/init.sql:ro + healthcheck: + test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"] + interval: 2s + timeout: 2s + retries: 5 + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.50' + memory: 512M + + redis: + image: redis:7-alpine + command: ["redis-server", "--appendonly", "yes"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 2s + timeout: 2s + retries: 5 + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.25' + memory: 256M + +volumes: + pg_data: + redis_data: diff --git a/evidence/check_contract.log b/evidence/check_contract.log new file mode 100644 index 0000000..9a55330 --- /dev/null +++ b/evidence/check_contract.log @@ -0,0 +1,2 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/docker_services.log b/evidence/docker_services.log new file mode 100644 index 0000000..bec108d --- /dev/null +++ b/evidence/docker_services.log @@ -0,0 +1,6 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab3-api-1-1 highload-messenger:lab3 "python -m uvicorn a…" api-1 46 minutes ago Up About a minute (healthy) 8080/tcp +mtusi2026lab3-api-2-1 highload-messenger:lab3 "python -m uvicorn a…" api-2 49 minutes ago Up About a minute (healthy) 8080/tcp +mtusi2026lab3-load_balancer-1 nginx:1.27-alpine "/docker-entrypoint.…" load_balancer 49 minutes ago Up About a minute (healthy) 80/tcp, 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp +mtusi2026lab3-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 49 minutes ago Up About a minute (healthy) 5432/tcp +mtusi2026lab3-redis-1 redis:7-alpine "docker-entrypoint.s…" redis 49 minutes ago Up About a minute (healthy) 6379/tcp diff --git a/evidence/failover_test.log b/evidence/failover_test.log new file mode 100644 index 0000000..0b6f9c3 --- /dev/null +++ b/evidence/failover_test.log @@ -0,0 +1,3 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 122, "failed_attempts": 0, "first_recovery_seconds": 0.447} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 0000000..66396e8 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 10.0, + "elapsed_seconds": 10.065, + "concurrency": 4, + "successful_requests": 3393, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 337.112, + "successful_latency_ms": { + "p50": 6.724, + "p95": 53.145, + "p99": 79.35 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence_test.log b/evidence/persistence_test.log new file mode 100644 index 0000000..749fd29 --- /dev/null +++ b/evidence/persistence_test.log @@ -0,0 +1,2 @@ +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/round_robin.log b/evidence/round_robin.log new file mode 100644 index 0000000..ce75226 --- /dev/null +++ b/evidence/round_robin.log @@ -0,0 +1,10 @@ +x-instance-id: api-2 +x-instance-id: api-1 +x-instance-id: api-2 +x-instance-id: api-1 +x-instance-id: api-2 +x-instance-id: api-1 +x-instance-id: api-2 +x-instance-id: api-1 +x-instance-id: api-2 +x-instance-id: api-1 diff --git a/evidence/smoke_test.log b/evidence/smoke_test.log new file mode 100644 index 0000000..fc20f9d --- /dev/null +++ b/evidence/smoke_test.log @@ -0,0 +1 @@ +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student_tests.log b/evidence/student_tests.log new file mode 100644 index 0000000..b10319e --- /dev/null +++ b/evidence/student_tests.log @@ -0,0 +1,38 @@ +BASE_URL="http://localhost:8080" .venv/bin/pytest tests_student/ -v +============================= test session starts ============================== +platform linux -- Python 3.12.15, pytest-9.1.1, pluggy-1.7.0 -- /home/ilyas/projects/labs_highload/mtusi2026lab3/.venv/bin/python3.12 +cachedir: .pytest_cache +rootdir: /home/ilyas/projects/labs_highload/mtusi2026lab3 +configfile: pytest.ini +plugins: anyio-4.15.1, asyncio-1.4.0 +asyncio: mode=Mode.AUTO, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function +collecting ... collected 26 items + +tests_student/tests.py::test_invalid_json_and_extra_fields PASSED [ 3%] +tests_student/tests.py::test_outsider_chat_access_is_404 PASSED [ 7%] +tests_student/tests.py::test_empty_and_whitespace_message PASSED [ 11%] +tests_student/tests.py::test_duplicate_username_conflict PASSED [ 15%] +tests_student/tests.py::test_wrong_password_and_bad_basic_auth PASSED [ 19%] +tests_student/tests.py::test_logout_and_revocation PASSED [ 23%] +tests_student/tests.py::test_multi_page_cursor_pagination PASSED [ 26%] +tests_student/tests.py::test_concurrency_race_condition PASSED [ 30%] +tests_student/tests.py::test_password_whitespace_rejected PASSED [ 34%] +tests_student/tests.py::test_auth_sessions_with_body_rejected PASSED [ 38%] +tests_student/tests.py::test_unsupported_media_type_415 PASSED [ 42%] +tests_student/tests.py::test_nul_byte_in_strings_handled PASSED [ 46%] +tests_student/tests.py::test_basic_auth_invalid_base64_returns_401 PASSED [ 50%] +tests_student/tests.py::test_cross_chat_cursor_rejected_400 PASSED [ 53%] +tests_student/tests.py::test_utf8_password_support PASSED [ 57%] +tests_student/tests.py::test_health_readiness_and_liveness PASSED [ 61%] +tests_student/tests.py::test_instance_id_header_present PASSED [ 65%] +tests_student/tests.py::test_idempotency_key_validation PASSED [ 69%] +tests_student/tests.py::test_idempotency_replay_and_conflict PASSED [ 73%] +tests_student/tests.py::test_idempotency_acl_check_on_replay PASSED [ 76%] +tests_student/tests.py::test_invalid_cursor_date_returns_400 PASSED [ 80%] +tests_student/tests.py::test_strict_types_and_json_parsing PASSED [ 84%] +tests_student/tests.py::test_session_create_rejects_non_empty_body PASSED [ 88%] +tests_student/tests.py::test_chat_creation_with_unknown_participant_is_400 PASSED [ 92%] +tests_student/tests.py::test_password_with_colons_and_utf8 PASSED [ 96%] +tests_student/tests.py::test_keyset_pagination_returns_next_cursor PASSED [100%] + +============================= 26 passed in 28.82s ============================== diff --git a/evidence/validate_openapi.log b/evidence/validate_openapi.log new file mode 100644 index 0000000..37e8188 --- /dev/null +++ b/evidence/validate_openapi.log @@ -0,0 +1,2 @@ +.venv/bin/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/infra/init.sql b/infra/init.sql index c2cd4fe..59534ea 100644 --- a/infra/init.sql +++ b/infra/init.sql @@ -33,3 +33,15 @@ CREATE TABLE IF NOT EXISTS messages ( ); CREATE INDEX IF NOT EXISTS idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC); + +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, + idempotency_key VARCHAR(128) NOT NULL, + message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE, + request_hash VARCHAR(64) NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + PRIMARY KEY (user_id, chat_id, idempotency_key) +); + +CREATE INDEX IF NOT EXISTS idx_idempotency_created_at ON idempotency_keys (created_at); diff --git a/infra/nginx.conf b/infra/nginx.conf new file mode 100644 index 0000000..5a985a1 --- /dev/null +++ b/infra/nginx.conf @@ -0,0 +1,71 @@ +events { + worker_connections 1024; +} + +http { + include /etc/nginx/mime.types; + default_type application/octet-stream; + + log_format main '$remote_addr - $remote_user [$time_local] "$request" ' + '$status $body_bytes_sent "$http_referer" ' + '"$http_user_agent" upstream: $upstream_addr ' + 'upstream_status: $upstream_status ' + 'rt=$request_time uct="$upstream_connect_time" uht="$upstream_header_time" urt="$upstream_response_time"'; + + access_log /var/log/nginx/access.log main; + error_log /var/log/nginx/error.log warn; + + sendfile on; + keepalive_timeout 65; + + # DNS-сервер Docker для динамического обновления IP-адресов контейнеров + resolver 127.0.0.11 valid=2s ipv6=off; + + upstream api_backend { + zone api_backend 64k; + server api-1:8080 resolve max_fails=1 fail_timeout=2s; + server api-2:8080 resolve max_fails=1 fail_timeout=2s; + } + + server { + listen 8080; + server_name _; + + # Быстрый таймаут обнаружения недоступной реплики + proxy_connect_timeout 1s; + proxy_read_timeout 5s; + proxy_send_timeout 5s; + + # Базовая политика переключения: безопасно для идемпотентных запросов + # Неидемпотентные POST не повторяем + proxy_next_upstream error timeout http_502 http_503; + proxy_next_upstream_tries 2; + proxy_next_upstream_timeout 5s; + + location ~ ^/api/v1/chats/[^/]+/messages$ { + proxy_pass http://api_backend; + proxy_http_version 1.1; + + 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-Forwarded-Proto $scheme; + proxy_set_header X-Request-Id $http_x_request_id; + + proxy_next_upstream error timeout http_502 http_503 non_idempotent; + proxy_next_upstream_tries 2; + proxy_next_upstream_timeout 5s; + } + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + + 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-Forwarded-Proto $scheme; + proxy_set_header X-Request-Id $http_x_request_id; + } + } +} diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..0cc128e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" + +# Перезапуск всех сервисов API и хранилищ с сохранением volumes +docker compose -f "$PROJECT_DIR/compose.yaml" restart diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 0000000..2d4a6b3 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu + +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" + +if docker compose -f "$PROJECT_DIR/compose.yaml" stop "$TARGET_INSTANCE_ID" 2>/dev/null; then + exit 0 +fi + +docker stop "$TARGET_INSTANCE_ID" >/dev/null diff --git a/tests_student/tests.py b/tests_student/tests.py index 441839c..b67dbed 100644 --- a/tests_student/tests.py +++ b/tests_student/tests.py @@ -121,7 +121,7 @@ async def test_outsider_chat_access_is_404(client: AsyncClient): # Ева пытается отправить сообщение в чужой чат -> 404 res_send = await client.post( f"/api/v1/chats/{chat_id}/messages", - headers=eve["headers"], + headers={**eve["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": "Шпионское сообщение"}, ) assert res_send.status_code == 404 @@ -150,7 +150,7 @@ async def test_empty_and_whitespace_message(client: AsyncClient): # Пустая строка -> 400 res_empty = await client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=alice["headers"], + headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": ""}, ) assert res_empty.status_code == 400 @@ -159,7 +159,7 @@ async def test_empty_and_whitespace_message(client: AsyncClient): # Одни пробелы и переводы строк -> 400 res_whitespace = await client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=alice["headers"], + headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": " \n\t "}, ) assert res_whitespace.status_code == 400 @@ -260,7 +260,7 @@ async def test_multi_page_cursor_pagination(client: AsyncClient): msg = ( await client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=alice["headers"], + headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": f"Сообщение {i:02d}"}, ) ).json() @@ -319,7 +319,7 @@ async def test_concurrency_race_condition(client: AsyncClient): for i in range(count): await client.post( f"/api/v1/chats/{chat_id}/messages", - headers=user_dict["headers"], + headers={**user_dict["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": f"Msg {i} from {user_dict['username']}"}, ) @@ -397,7 +397,11 @@ async def test_nul_byte_in_strings_handled(client: httpx.AsyncClient): usr = await register_and_login(client, f"nul_msg_{uuid.uuid4().hex[:4]}") chat = (await client.post("/api/v1/chats", headers=usr["headers"], json={"title": "NulChat", "member_ids": [usr["user"]["id"]]})).json() test_text = "left\u0000right" - msg_res = await client.post(f"/api/v1/chats/{chat['id']}/messages", headers=usr["headers"], json={"text": test_text}) + msg_res = await client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers={**usr["headers"], "Idempotency-Key": uuid.uuid4().hex}, + json={"text": test_text}, + ) assert msg_res.status_code == 201 assert msg_res.json()["text"] == test_text @@ -425,8 +429,8 @@ async def test_cross_chat_cursor_rejected_400(client: httpx.AsyncClient): chat2 = (await client.post("/api/v1/chats", headers=u["headers"], json={"title": "C2", "member_ids": [u["user"]["id"]]})).json() # Отправляем 2 сообщения в чат 1 - await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers=u["headers"], json={"text": "m1"}) - await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers=u["headers"], json={"text": "m2"}) + await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers={**u["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": "m1"}) + await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers={**u["headers"], "Idempotency-Key": uuid.uuid4().hex}, json={"text": "m2"}) # Получаем страницу с курсором из чата 1 p1 = (await client.get(f"/api/v1/chats/{chat1['id']}/messages?limit=1", headers=u["headers"])).json() @@ -469,3 +473,300 @@ async def test_health_readiness_and_liveness(client: httpx.AsyncClient): r_ready = await client.get("/health/ready") assert r_ready.status_code == 200 assert r_ready.json()["status"] == "ok" + + +@pytest.mark.asyncio +async def test_instance_id_header_present(client: httpx.AsyncClient): + """Каждый ответ обязан содержать непустой заголовок X-Instance-Id.""" + res = await client.get("/health/live") + assert res.status_code == 200 + assert "x-instance-id" in res.headers + assert len(res.headers["x-instance-id"]) > 0 + + res_err = await client.get("/api/v1/users/me") + assert res_err.status_code == 401 + assert "x-instance-id" in res_err.headers + assert len(res_err.headers["x-instance-id"]) > 0 + + +@pytest.mark.asyncio +async def test_idempotency_key_validation(client: httpx.AsyncClient): + """POST /messages без Idempotency-Key или с некорректным форматом возвращает 400.""" + alice = await register_and_login(client, f"idem_{uuid.uuid4().hex[:6]}") + chat = (await client.post("/api/v1/chats", headers=alice["headers"], json={"title": "IdemChat", "member_ids": [alice["user"]["id"]]})).json() + chat_id = chat["id"] + + # Без заголовка + res1 = await client.post(f"/api/v1/chats/{chat_id}/messages", headers=alice["headers"], json={"text": "Тест"}) + assert res1.status_code == 400 + assert res1.json()["error"]["code"] == "invalid_request" + + # С некорректным форматом + res2 = await client.post(f"/api/v1/chats/{chat_id}/messages", headers={**alice["headers"], "Idempotency-Key": "invalid key with spaces"}, json={"text": "Тест"}) + assert res2.status_code == 400 + assert res2.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.asyncio +async def test_idempotency_replay_and_conflict(client: httpx.AsyncClient): + """Повтор с тем же телом возвращает исходный 201; с другим телом возвращает 409.""" + alice = await register_and_login(client, f"idem2_{uuid.uuid4().hex[:6]}") + chat = (await client.post("/api/v1/chats", headers=alice["headers"], json={"title": "IdemChat2", "member_ids": [alice["user"]["id"]]})).json() + chat_id = chat["id"] + key = uuid.uuid4().hex + + # Первый запрос -> 201 + res1 = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Первое сообщение"}, + ) + assert res1.status_code == 201 + msg1 = res1.json() + + # Повтор с тем же телом -> 201 и то же сообщение + res2 = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Первое сообщение"}, + ) + assert res2.status_code == 201 + assert res2.json() == msg1 + + # Повтор с тем же ключом, но другим телом -> 409 Conflict + res3 = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Другое сообщение с тем же ключом"}, + ) + assert res3.status_code == 409 + assert res3.json()["error"]["code"] == "conflict" + + +@pytest.mark.asyncio +async def test_idempotency_acl_check_on_replay(client: httpx.AsyncClient): + """ + Проверка ACL перед возвратом сохранённого результата идемпотентности. + Если пользователь удалён из участников чата, повторный POST с тем же Idempotency-Key + и тем же телом обязан вернуть 404 (а не 201). + """ + import subprocess + + alice = await register_and_login(client, f"acl_{uuid.uuid4().hex[:6]}") + chat = ( + await client.post( + "/api/v1/chats", + headers=alice["headers"], + json={"title": "ACL Test Chat", "member_ids": [alice["user"]["id"]]}, + ) + ).json() + chat_id = chat["id"] + user_id = alice["user"]["id"] + key = f"acl_key_{uuid.uuid4().hex[:12]}" + + # 1. Отправляем сообщение первый раз -> 201 + res1 = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Тест проверки ACL"}, + ) + assert res1.status_code == 201 + + # 2. Удаляем членство отправителя напрямую в БД (изолированная инъекция проверки ACL) + cmd = [ + "docker", + "compose", + "exec", + "-T", + "postgres", + "psql", + "-U", + "postgres", + "-d", + "messenger", + "-c", + f"DELETE FROM chat_members WHERE chat_id = '{chat_id}' AND user_id = '{user_id}';", + ] + sub_res = subprocess.run(cmd, capture_output=True, text=True) + assert sub_res.returncode == 0, f"Ошибка удаления членства: {sub_res.stderr}" + + # 3. GET истории уже обязан возвращать 404 + res_get = await client.get(f"/api/v1/chats/{chat_id}/messages", headers=alice["headers"]) + assert res_get.status_code == 404 + + # 4. Повтор POST с тем же телом и тем же ключом ОБЯЗАН вернуть 404 (ACL проверяется до возврата из idempotency_keys) + res_repeat = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Тест проверки ACL"}, + ) + assert res_repeat.status_code == 404, f"Ожидался 404, получен {res_repeat.status_code}: {res_repeat.text}" + assert res_repeat.json()["error"]["code"] == "not_found" + + # 5. Повтор POST с тем же ключом и ДРУГИМ телом: ACL проверяется до сравнения тела -> обязан вернуть 404 (а не 409) + res_repeat_diff = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": key}, + json={"text": "Другой текст сообщения"}, + ) + assert res_repeat_diff.status_code == 404, f"Ожидался 404, получен {res_repeat_diff.status_code}: {res_repeat_diff.text}" + assert res_repeat_diff.json()["error"]["code"] == "not_found" + + +@pytest.mark.asyncio +async def test_invalid_cursor_date_returns_400(client: httpx.AsyncClient): + """ + Некорректная дата курсора (например, 13-й месяц 2026-13-01T00:00:00.000000Z) + обязана возвращать 400 invalid_request (а не 500 internal_error). + """ + from app.storage import encode_cursor + + alice = await register_and_login(client, f"bad_cur_{uuid.uuid4().hex[:6]}") + chat = ( + await client.post( + "/api/v1/chats", + headers=alice["headers"], + json={"title": "CurChat", "member_ids": [alice["user"]["id"]]}, + ) + ).json() + chat_id = chat["id"] + + # 1. Курсор сообщений с невалидной датой (месяц 13) + bad_cur_msg = encode_cursor( + { + "type": "messages", + "chat_id": chat_id, + "created_at": "2026-13-01T00:00:00.000000Z", + "id": str(uuid.uuid4()), + } + ) + res_m = await client.get( + f"/api/v1/chats/{chat_id}/messages?cursor={bad_cur_msg}", + headers=alice["headers"], + ) + assert res_m.status_code == 400 + assert res_m.json()["error"]["code"] == "invalid_request" + + # 2. Невалидная строка формата m|chat_id|... в base64 + raw_str = f"m|{chat_id}|2026-13-01T00:00:00.000000Z|" + raw_cur = base64.urlsafe_b64encode(raw_str.encode()).decode() + res_raw = await client.get( + f"/api/v1/chats/{chat_id}/messages?cursor={raw_cur}", + headers=alice["headers"], + ) + assert res_raw.status_code == 400 + assert res_raw.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.asyncio +async def test_strict_types_and_json_parsing(client: httpx.AsyncClient): + """ + Запрет преобразования неверных типов ({"text": 123} -> 400) + и требование полного разбора JSON ({"text":"x"}garbage -> 400). + """ + alice = await register_and_login(client, f"strict_{uuid.uuid4().hex[:6]}") + chat = ( + await client.post( + "/api/v1/chats", + headers=alice["headers"], + json={"title": "StrictChat", "member_ids": [alice["user"]["id"]]}, + ) + ).json() + chat_id = chat["id"] + + # 1. {"text": 123} вместо строки -> 400 + res_num = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex, "Content-Type": "application/json"}, + content='{"text": 123}', + ) + assert res_num.status_code == 400 + assert res_num.json()["error"]["code"] == "invalid_request" + + # 2. {"text": "x"}garbage -> 400 + res_garbage = await client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex, "Content-Type": "application/json"}, + content='{"text": "x"}garbage', + ) + assert res_garbage.status_code == 400 + assert res_garbage.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.asyncio +async def test_session_create_rejects_non_empty_body(client: httpx.AsyncClient): + """POST /api/v1/auth/sessions с непустым телом {"unexpected":true} отклоняется с 400.""" + alice = await register_and_login(client, f"no_body_{uuid.uuid4().hex[:6]}") + cred = base64.b64encode(f"{alice['username']}:{alice['password']}".encode()).decode() + + res = await client.post( + "/api/v1/auth/sessions", + headers={"Authorization": f"Basic {cred}", "Content-Type": "application/json"}, + content='{"unexpected": true}', + ) + assert res.status_code == 400 + assert res.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.asyncio +async def test_chat_creation_with_unknown_participant_is_400(client: httpx.AsyncClient): + """Неизвестный участник при создании чата обязан возвращать 400 (не 404).""" + alice = await register_and_login(client, f"unk_{uuid.uuid4().hex[:6]}") + non_existent_uuid = str(uuid.uuid4()) + + res = await client.post( + "/api/v1/chats", + headers=alice["headers"], + json={"title": "Chat With Ghost", "member_ids": [alice["user"]["id"], non_existent_uuid]}, + ) + assert res.status_code == 400 + assert res.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.asyncio +async def test_password_with_colons_and_utf8(client: httpx.AsyncClient): + """Пароль с двоеточиями и UTF-8 символами работает при регистрации и входе.""" + username = f"col_{uuid.uuid4().hex[:8]}" + password = "Пример:пароля-12345:секрет:🔒" + + res_reg = await client.post( + "/api/v1/users", + json={"username": username, "display_name": "Colon User", "password": password}, + ) + assert res_reg.status_code == 201 + + cred = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("utf-8") + res_login = await client.post( + "/api/v1/auth/sessions", + headers={"Authorization": f"Basic {cred}"}, + ) + assert res_login.status_code == 201 + assert "token" in res_login.json() + + +@pytest.mark.asyncio +async def test_keyset_pagination_returns_next_cursor(client: httpx.AsyncClient): + """ + При наличии записей за пределами limit возвращается next_cursor. + Повторный запрос с cursor возвращает следующие элементы. + """ + alice = await register_and_login(client, f"page_{uuid.uuid4().hex[:6]}") + c1 = (await client.post("/api/v1/chats", headers=alice["headers"], json={"title": "Chat1", "member_ids": [alice["user"]["id"]]})).json() + c2 = (await client.post("/api/v1/chats", headers=alice["headers"], json={"title": "Chat2", "member_ids": [alice["user"]["id"]]})).json() + + # Запрос с limit=1 обязан вернуть первый чат и НЕПУСТОЙ next_cursor + res_p1 = await client.get("/api/v1/chats?limit=1", headers=alice["headers"]) + assert res_p1.status_code == 200 + data_p1 = res_p1.json() + assert len(data_p1["items"]) == 1 + cursor = data_p1["next_cursor"] + assert cursor is not None and len(cursor) > 0 + + # Запрос со вторым курсором обязан вернуть второй чат + res_p2 = await client.get(f"/api/v1/chats?limit=1&cursor={cursor}", headers=alice["headers"]) + assert res_p2.status_code == 200 + data_p2 = res_p2.json() + assert len(data_p2["items"]) == 1 + assert data_p2["items"][0]["id"] != data_p1["items"][0]["id"] + +