diff --git a/.env.example b/.env.example index bc813a80..ec9053e2 100644 --- a/.env.example +++ b/.env.example @@ -15,7 +15,6 @@ SESSION_STORE=redis REDIS_HOST=redis REDIS_PORT=6379 REDIS_DB=0 -REDIS_PASSWORD=change-me REDIS_MAX_CONNECTIONS=20 REDIS_POOL_TIMEOUT_SECONDS=1 REDIS_CONNECT_TIMEOUT_SECONDS=1 @@ -25,7 +24,6 @@ DB_HOST=postgres DB_PORT=5432 DB_NAME=messenger DB_USER=messenger -DB_PASSWORD=change-me # Пул на одну реплику: суммарно API_REPLICAS * (POOL_SIZE + MAX_OVERFLOW) # соединений должно помещаться в max_connections PostgreSQL. @@ -37,12 +35,12 @@ DB_STATEMENT_TIMEOUT_MS=5000 # --- Балансировка и идемпотентность --- API_REPLICAS=2 +API_IMAGE=mtusi-messenger:lab3 +API_BUILD_REVISION=development IDEMPOTENCY_TTL_SECONDS=86400 -# Пусто -> id вычисляется в app/core/instance.py (TODO 3.2) -# INSTANCE_ID=api-1 -# TODO(4.1): сколько секунд отдавать readiness=503 перед закрытием сокета -SHUTDOWN_DRAIN_SECONDS=0 +SHUTDOWN_DRAIN_SECONDS=1 GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5 +READINESS_TIMEOUT_SECONDS=2 # Порт единственной публичной точки входа (nginx) LB_HOST_PORT=8080 diff --git a/.gitignore b/.gitignore index 06112c66..014bc061 100644 --- a/.gitignore +++ b/.gitignore @@ -34,4 +34,5 @@ coverage/ /venv .ruff_cache/ /docs -AGENTS.md \ No newline at end of file +AGENTS.md +.pytest_cache \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index e1b67766..17f476a1 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,7 @@ FROM python:3.12.15-slim-bookworm +LABEL io.mtusi.messenger.secrets="file-v1" + ENV PYTHONDONTWRITEBYTECODE=1 \ PYTHONUNBUFFERED=1 \ PIP_NO_CACHE_DIR=1 \ @@ -16,14 +18,14 @@ COPY alembic.ini ./ COPY migrations ./migrations COPY app ./app -USER appuser +ARG API_BUILD_REVISION +LABEL io.mtusi.messenger.revision=$API_BUILD_REVISION -# TODO(4.1): uvicorn корректно завершается по SIGTERM (сигнал Docker по умолчанию). -# Проверьте, что python — PID 1 (exec-форма CMD), иначе сигнал не дойдёт. +USER appuser EXPOSE 8080 -HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ - CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/live', timeout=2)"] +HEALTHCHECK --interval=3s --timeout=3s --start-period=10s --retries=2 \ + CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"] CMD ["python", "-m", "app"] diff --git a/Makefile b/Makefile index cbc1821b..eac4edc6 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,8 @@ -include .env PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3) -BASE_URL ?= http://localhost:8080 +PYTEST_ARGS ?= +BASE_URL ?= http://localhost:$(LB_HOST_PORT) CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) @@ -10,18 +11,19 @@ COMPOSE = docker compose --env-file .env # Отдельный тестовый стенд: свой compose-проект, свои порты, открытые БД/Redis # (compose.test.yaml). COMPOSE_FILE подхватывают и scripts/*.sh. -TEST_PROJECT ?= $(notdir $(CURDIR))-test +TEST_PROJECT ?= mtusi-messenger-lab3-test TEST_LB_PORT ?= 18080 -TEST_DB_PORT ?= 15432 -TEST_REDIS_PORT ?= 16379 +TEST_DB_PORT ?= $(DB_HOST_PORT) +TEST_REDIS_PORT ?= $(REDIS_HOST_PORT) TEST_BASE_URL = http://localhost:$(TEST_LB_PORT) TEST_ENV = COMPOSE_PROJECT_NAME=$(TEST_PROJECT) COMPOSE_FILE=compose.yaml:compose.test.yaml \ LB_HOST_PORT=$(TEST_LB_PORT) DB_HOST_PORT=$(TEST_DB_PORT) REDIS_HOST_PORT=$(TEST_REDIS_PORT) TEST_COMPOSE = $(TEST_ENV) $(COMPOSE) -TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test +TEST_DB_PASSWORD = $(if $(wildcard secrets/db_password),$(file _test` и +Redis DB 15. `make test-stand-destroy` удаляет именно тестовые volumes. -## Эксперименты и отказы +## Реализация и результаты -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Nginx → две API → общие PostgreSQL и Redis. Сообщение, счётчик и результат ключа +фиксируются одной транзакцией; PostgreSQL-блокировка сериализует одинаковый ключ +между репликами. Подробности, файлы и параметры — [EXPLAIN.md](EXPLAIN.md), ответы +для защиты — [DEFENCE.md](DEFENCE.md), методика — [evidence/README.md](evidence/README.md). -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Все строки ниже проверены командой `make test-grade4 PYTHON=.venv/bin/python`; +исходный вывод — [test-output.txt](evidence/test-output.txt). -## Ограничения и следующие шаги +| Критерий README | Наблюдение | +| --- | --- | +| 3: воспроизводимая топология, ≥2 API, общие хранилища | Стенд создан с нуля; две API, одна PostgreSQL, одна Redis, вход через Nginx. | +| 3: одна сессия на разных API | 24 конкурентных повтора с одной сессией обслужены двумя реальными репликами. | +| 3: чтение/запись при отказе ≤10 с | Публичный failover прошёл; отдельный отказ каждой API — восстановление за 1,800 / 1,782 с. | +| 3: общая идемпотентность | 24 повтора дали один Message и одну запись истории; конфликт тела, TTL и rollback покрыты pytest. | +| 3: smoke, persistence, failover | Все прошли, существующая сессия и подтверждённые сообщения сохранены. | +| 4: health, timeout, SIGTERM | При drain ready=503, live=200, новая работа=503; начатый POST=201, остановка за 2,145 с без SIGKILL. | +| 4: последовательный отказ каждой API | До/после остановки и восстановления записаны состояния; RPS и ошибки приведены ниже. | +| 4: лимиты, порты, секреты, масштабирование | Проверены фактические CPU/RAM, закрытые порты API, read-only секреты по назначению, отсутствие паролей в окружении и container_name. | +| 4: обновление под нагрузкой | Оба контейнера заменены новым образом, миграционная команда вызвана один раз, перед остановкой доступны ≥2 здоровых API. | -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**156 pytest прошли за 42,30 с**. Проверки контракта и OpenAPI прошли. +Отдельный `make test-nginx` подтвердил конфигурацию, DNS без reload, ограничитель, +ошибки и gzip 2060 → 61 байт: [вывод](evidence/nginx-output.txt). + +| Сценарий | Успешных ответов | RPS | Ошибки попыток | Восстановление | +| --- | ---: | ---: | --- | ---: | +| Rolling update, 23,627 с | 456 | 19,300 | 13 × 503 | Не измерялось отдельно | +| Отказ API 1, 13,853 с | 773 | 55,800 | 67 × 429; 16 × 503 | 1,800 с | +| Отказ API 2, 13,875 с | 773 | 55,710 | 99 × 429; 17 × 503 | 1,782 с | + +Подтверждённые сообщения сохранены, дублей нет. Ошибки измерены за весь сценарий; +429 связаны с ограничителем, 503 — с временной недоступностью. Механизм обновления +проверен изменением метки образа без изменения бизнес-кода; новых ожидающих DDL +на этапе rolling не было. Будущие миграции требуют отдельной проверки совместимости. + +## Параметры и ограничения + +API: readiness каждые 3 с, timeout 3 с, две неудачи, start period 10 с; после старта +оценка unhealthy ≤12 с. Nginx использует пассивные проверки: connect ≤0,5 с на попытку, +пауза чтения ≤10 с, исключение peer на 5 с; без трафика обнаружение не происходит. +Drain 1 с + ожидание задач 5 с < Docker grace 8 с. CPU/RAM каждого сервиса, +оборудование, версии и профиль нагрузки — в [run.json](evidence/run.json) и +[методике](evidence/README.md). Это один прогон с двумя клиентами, не измерение +максимальной производительности. Средний RPS может превышать 50 из-за burst=100. + +Стенд односерверный; PostgreSQL, Redis и Nginx остаются единичными точками отказа. +Откат контейнеров не откатывает БД. TTL ключа — 24 часа, очистка при повторном +использовании, фоновой очистки нет. Исходное задание и публичные tests не ослаблены. + +Источники: [контракт](contracts/README.md), [курс](COURSE.md), закреплённые зависимости +и их установленные исходники, ссылки на документацию Docker в [README](README.md#первичные-материалы). +Для реализации, проверок и подготовки пояснений использован ИИ-помощник Codex; +приведённые результаты получены реальным запуском команд. diff --git a/app/core/config.py b/app/core/config.py index 20d0069b..1dedebd7 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -1,11 +1,16 @@ from enum import StrEnum +from pathlib import Path from typing import Literal, Self from pydantic import Field, SecretStr, model_validator -from pydantic_settings import BaseSettings, SettingsConfigDict +from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict from sqlalchemy import URL ASYNC_DRIVER = "postgresql+asyncpg" +SECRETS_DIR = next( + (path for path in (Path("/run/secrets"), Path(__file__).resolve().parents[2] / "secrets") if (path / "db_password").is_file()), + None, +) class LogLevel(StrEnum): @@ -51,23 +56,36 @@ class Settings(BaseSettings): db_connect_timeout_seconds: int = Field(default=3, ge=1) db_statement_timeout_ms: int = Field(default=5000, ge=1) - # Балансировка между репликами и идемпотентность - instance_id: str | None = None # TODO(3.2): None -> вычислить в resolve_instance_id - idempotency_ttl_seconds: int = Field(default=86400, ge=1) # TODO(3.4) - shutdown_drain_seconds: float = Field(default=0, ge=0) # TODO(4.1) - graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1) # TODO(4.1) + instance_id: str | None = None + idempotency_ttl_seconds: int = Field(default=86400, ge=1) + shutdown_drain_seconds: float = Field(default=1, ge=0) + graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1) + readiness_timeout_seconds: float = Field(default=2, gt=0, lt=2.5) - # TODO(4.3): секреты из файлов (Docker secrets): pydantic-settings умеет - # secrets_dir="/run/secrets" — имя файла = имя поля (db_password, ...). model_config = SettingsConfigDict( env_file=".env", env_file_encoding="utf-8", case_sensitive=False, extra="ignore", + secrets_dir=SECRETS_DIR, ) + @classmethod + def settings_customise_sources( + cls, + settings_cls: type[BaseSettings], + init_settings: PydanticBaseSettingsSource, + env_settings: PydanticBaseSettingsSource, + dotenv_settings: PydanticBaseSettingsSource, + file_secret_settings: PydanticBaseSettingsSource, + ) -> tuple[PydanticBaseSettingsSource, ...]: + """Явные параметры и файлы имеют приоритет над окружением.""" + return init_settings, file_secret_settings, env_settings, dotenv_settings + @model_validator(mode="after") def _require_database_source(self) -> Self: + if self.shutdown_drain_seconds + self.graceful_shutdown_timeout_seconds >= 8: + raise ValueError("Drain и graceful shutdown должны суммарно занимать менее 8 секунд") if self.database_url is not None: if not self.database_url.get_secret_value().startswith(ASYNC_DRIVER): raise ValueError(f"DATABASE_URL должен начинаться с {ASYNC_DRIVER}://") @@ -75,7 +93,7 @@ class Settings(BaseSettings): if not (self.db_host and self.db_name and self.db_user and self.db_password): raise ValueError( - "Задайте DATABASE_URL или DB_HOST, DB_NAME, DB_USER и DB_PASSWORD" + "Нужны DATABASE_URL либо DB_HOST, DB_NAME, DB_USER и секрет db_password" ) return self diff --git a/app/core/instance.py b/app/core/instance.py index 6ab0d3f1..75bf8449 100644 --- a/app/core/instance.py +++ b/app/core/instance.py @@ -1,5 +1,8 @@ """Идентификатор API-реплики и заголовок X-Instance-Id.""" +import os +from uuid import uuid4 + from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint from starlette.requests import Request from starlette.responses import Response @@ -8,25 +11,19 @@ INSTANCE_ID_HEADER = "X-Instance-Id" def resolve_instance_id(configured: str | None) -> str: - """Возвращает id реплики, стабильный в течение жизни процесса. + """Выбирает INSTANCE_ID, HOSTNAME или UUID при старте приложения.""" + if configured and configured.strip(): + return configured.strip() - TODO(3.2): выбрать источник id. - - Если задан непустой INSTANCE_ID в настройках — вернуть его. - - Иначе — что-то, что позволит stop-one.sh найти именно этот контейнер - (подсказка: Docker кладёт короткий id контейнера в переменную HOSTNAME, - а `docker stop <короткий id>` работает). - - Значение вычисляется один раз при старте и не меняется до конца процесса. - """ - raise NotImplementedError("TODO(3.2): resolve_instance_id") + hostname = os.getenv("HOSTNAME", "").strip() + if hostname: + return hostname + + return str(uuid4()) class InstanceIdMiddleware(BaseHTTPMiddleware): - """Добавляет X-Instance-Id в каждый ответ API, включая ошибки и /health/*. - - TODO(3.2): реализовать dispatch по образцу RequestIdMiddleware - (app/core/request_id.py) и подключить в create_app (app/main.py). - Проверьте, что заголовок есть и у ответов из exception handlers. - """ + """Добавляет сохранённый идентификатор реплики в ответ.""" def __init__(self, app, instance_id: str) -> None: super().__init__(app) @@ -37,4 +34,7 @@ class InstanceIdMiddleware(BaseHTTPMiddleware): request: Request, call_next: RequestResponseEndpoint, ) -> Response: - raise NotImplementedError("TODO(3.2): InstanceIdMiddleware.dispatch") + response = await call_next(request) + response.headers[INSTANCE_ID_HEADER] = self.instance_id + + return response diff --git a/app/core/lifecycle.py b/app/core/lifecycle.py index 5756d856..c9e06a8c 100644 --- a/app/core/lifecycle.py +++ b/app/core/lifecycle.py @@ -1,12 +1,14 @@ -"""Состояние жизненного цикла реплики: готова / уходит (graceful shutdown). +"""Готовность реплики и мягкое завершение сервера.""" -Идея: при SIGTERM реплика сначала перестаёт быть "ready" (/health/ready -> 503), -чтобы балансировщик успел исключить её, и только затем uvicorn перестаёт -принимать соединения и дожидается текущих запросов. -""" +import asyncio +from types import FrameType + +import uvicorn class Lifecycle: + """Хранит состояние завершения реплики.""" + def __init__(self) -> None: self._draining = False @@ -15,18 +17,34 @@ class Lifecycle: return self._draining def start_draining(self) -> None: - """TODO(4.1): вызвать при получении SIGTERM / в начале shutdown.""" + """Отключает приём новых бизнес-запросов.""" self._draining = True -# TODO(4.1): решить, где перехватывать SIGTERM. -# uvicorn сам ставит обработчик SIGTERM и сразу закрывает listening socket, -# поэтому "сначала readiness=503, потом закрыть приём" нужно сделать явно: -# - либо обернуть/переопределить обработчик сигнала uvicorn -# (uvicorn.Server.handle_exit) так, чтобы он сначала вызывал -# lifecycle.start_draining(), ждал SHUTDOWN_DRAIN_SECONDS и только потом -# передавал управление штатному завершению; -# - либо полагаться на passive-проверки nginx (proxy_next_upstream) и честно -# описать в REPORT.md, сколько запросов теряется. -# Сумма drain + timeout_graceful_shutdown должна быть меньше stop_grace_period -# в compose.yaml, иначе Docker добьёт процесс SIGKILL. +class GracefulServer(uvicorn.Server): + """Оставляет время для исключения завершающейся реплики.""" + + def __init__( + self, config: uvicorn.Config, lifecycle: Lifecycle, drain_seconds: float + ) -> None: + super().__init__(config) + self.lifecycle = lifecycle + self.drain_seconds = drain_seconds + self._drain_task: asyncio.Task[None] | None = None + + def handle_exit(self, sig: int, frame: FrameType | None) -> None: + """Первый сигнал запускает drain, повторный ускоряет остановку.""" + if self._drain_task is not None: + if not self._drain_task.done(): + self._drain_task.cancel() + super().handle_exit(sig, frame) + return + self.lifecycle.start_draining() + self._drain_task = asyncio.get_running_loop().create_task( + self._finish_draining(sig, frame) + ) + + async def _finish_draining(self, sig: int, frame: FrameType | None) -> None: + """Передаёт остановку Uvicorn после drain-периода.""" + await asyncio.sleep(self.drain_seconds) + super().handle_exit(sig, frame) diff --git a/app/core/request_capacity.py b/app/core/request_capacity.py index acfb15a3..31968e70 100644 --- a/app/core/request_capacity.py +++ b/app/core/request_capacity.py @@ -2,7 +2,7 @@ from collections.abc import AsyncIterator from fastapi import Request -from app.errors.exceptions import rate_limited +from app.errors.exceptions import rate_limited, unavailable class RequestCapacity: @@ -29,6 +29,8 @@ def create_request_capacity(max_in_flight: int) -> RequestCapacity: async def acquire_request_slot(request: Request) -> AsyncIterator[None]: + if request.app.state.lifecycle.draining: + raise unavailable("Реплика завершает работу") capacity: RequestCapacity = request.app.state.request_capacity if not capacity.try_acquire(): diff --git a/app/core/security.py b/app/core/security.py index 70952e78..bfddf197 100644 --- a/app/core/security.py +++ b/app/core/security.py @@ -13,7 +13,7 @@ TOKEN_BYTES = 32 _hasher = PasswordHasher() _executor = ThreadPoolExecutor( - max_workers=max(1, (os.cpu_count() or 1) // _hasher.parallelism), + max_workers=max(1, min(2, (os.cpu_count() or 1) // _hasher.parallelism)), thread_name_prefix="argon2", ) diff --git a/app/domain/idempotency.py b/app/domain/idempotency.py index c5e1cff1..04b5501d 100644 --- a/app/domain/idempotency.py +++ b/app/domain/idempotency.py @@ -1,15 +1,4 @@ -"""Идемпотентность POST сообщения, общая для всех API-реплик. - -Семантика: - - ключ: ASCII [A-Za-z0-9._:-]{1,128}; нет/неверный — 400; - - область уникальности: пользователь + метод + путь чата + ключ; - - тот же JSON в течение 24 ч -> тот же 201 и то же Message; - - другой JSON с тем же ключом -> 409; - - одновременные повторы через разные реплики -> ровно одно сообщение; - - повтор снова проверяет сессию и членство в чате; - - транзиентная 5xx не фиксируется как окончательный результат; - - побочный эффект (INSERT сообщения) и запись результата — атомарно. -""" +"""Атомарная отправка сообщения с защитой от повторов.""" import hashlib import json @@ -18,27 +7,26 @@ from uuid import UUID from sqlalchemy.ext.asyncio import AsyncSession +from app.domain.chats import ensure_chat_member +from app.errors.exceptions import conflict, invalid_request, unavailable +from app.models.message import Message as MessageModel from app.schemas.message import CreateMessage, Message from app.schemas.user import User +from app.storage import idempotency as key_storage +from app.storage import messages as message_storage IDEMPOTENCY_KEY_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}") def validate_idempotency_key(key: str | None) -> str: - """Возвращает ключ или бросает invalid_request (400). - - TODO(3.4): проверить наличие и формат (fullmatch по IDEMPOTENCY_KEY_PATTERN). - """ - raise NotImplementedError("TODO(3.4): validate_idempotency_key") + """Проверяет обязательный ASCII-ключ запроса.""" + if key is None or IDEMPOTENCY_KEY_PATTERN.fullmatch(key) is None: + raise invalid_request("Требуется корректный Idempotency-Key") + return key def request_fingerprint(new_message: CreateMessage) -> str: - """Хеш семантического содержимого запроса для сравнения повторов. - - Порядок ключей JSON не должен влиять на результат, поэтому хешируйте - нормализованную форму (например, json.dumps(..., sort_keys=True) - от new_message.model_dump()), а не сырые байты тела. - """ + """Хеширует нормализованное содержимое запроса.""" canonical = json.dumps( new_message.model_dump(mode="json"), sort_keys=True, ensure_ascii=False ) @@ -54,22 +42,25 @@ async def send_message_idempotent( max_messages: int, ttl_seconds: int, ) -> Message: - """Отправляет сообщение ровно один раз для (sender, POST, chat_id, key). + """Создаёт сообщение или возвращает результат прежнего запроса.""" + await ensure_chat_member(session, sender, chat_id) + scope = (sender.id, "POST", f"/api/v1/chats/{chat_id}/messages", idempotency_key) + fingerprint = request_fingerprint(new_message) - TODO(3.4). Один из рабочих вариантов на PostgreSQL: - 1. ensure_chat_member(...) — доступ проверяется и на повторе. - 2. В одной транзакции: - INSERT INTO idempotency_keys (...) VALUES (...) - ON CONFLICT (user_id, method, path, key) DO NOTHING RETURNING ... - - вставилось -> создать сообщение, записать message_id в строку ключа, - COMMIT (сообщение и ключ фиксируются вместе или не фиксируются вовсе); - - конфликт -> прочитать существующую строку. Параллельная транзакция - с тем же ключом будет ждать на уникальном индексе, пока первая - не завершится, поэтому дубля не будет. - 3. Если fingerprint отличается -> conflict() (409). - 4. Если совпадает -> вернуть сохранённое сообщение (тот же id/created_at). - 5. Просроченные (> ttl_seconds) ключи считать отсутствующими. - Альтернатива — Redis SET NX + PostgreSQL; тогда отдельно продумайте - атомарность "сообщение записано, а ключ — нет" и наоборот. - """ - raise NotImplementedError("TODO(3.4): send_message_idempotent") + await key_storage.lock_key(session, scope) + previous = await key_storage.get_active_key(session, scope, ttl_seconds) + if previous is not None: + if previous.request_hash != fingerprint: + raise conflict("Idempotency-Key уже использован для другого сообщения") + message = await session.get(MessageModel, previous.message_id) + else: + if not await message_storage.reserve_message_slot(session, max_messages): + raise unavailable("Достигнут лимит количества сообщений") + message = await message_storage.create_message( + session, chat_id=chat_id, sender_id=sender.id, text=new_message.text + ) + await key_storage.save_result(session, scope, fingerprint, message.id) + + result = Message.model_validate(message) + await session.commit() + return result diff --git a/app/domain/messages.py b/app/domain/messages.py index 2f7405f1..c92b8556 100644 --- a/app/domain/messages.py +++ b/app/domain/messages.py @@ -9,35 +9,12 @@ from app.domain.pagination import ( decode_cursor, split_page, ) -from app.errors.exceptions import unavailable -from app.schemas.message import CreateMessage, Message, MessagePage +from app.schemas.message import Message, MessagePage from app.schemas.user import User from app.storage import messages as messages_storage from app.storage.types import Position -async def send_message( - session: AsyncSession, - sender: User, - chat_id: UUID, - new_message: CreateMessage, - max_messages: int, -) -> Message: - """Отправляет сообщение от имени участника; при исчерпании лимита даёт 503.""" - await ensure_chat_member(session, sender, chat_id) - - if not await messages_storage.reserve_message_slot(session, max_messages): - raise unavailable("Достигнут лимит количества сообщений") - - message = await messages_storage.create_message( - session, chat_id=chat_id, sender_id=sender.id, text=new_message.text - ) - await session.commit() - - sent_message = Message.model_validate(message) - return sent_message - - async def list_messages( session: AsyncSession, user: User, diff --git a/app/endpoints/health.py b/app/endpoints/health.py index daf8a37f..4f38fe07 100644 --- a/app/endpoints/health.py +++ b/app/endpoints/health.py @@ -1,3 +1,5 @@ +import asyncio + from fastapi import APIRouter, Request from app.core.database import check_database @@ -15,12 +17,16 @@ async def liveness() -> Health: @router.get("/ready") async def readiness(request: Request) -> Health: - # TODO(4.1): если реплика получила SIGTERM (lifecycle.draining) — сразу 503, - # чтобы LB исключил её до закрытия сокета. - # TODO(4.1): проверки зависимостей должны укладываться в timeout healthcheck; - # зафиксируйте в REPORT.md, какие зависимости критичны. - if not await check_database(request.app.state.engine): + if request.app.state.lifecycle.draining: raise unavailable() - if not await check_redis(request.app.state.redis): + try: + async with asyncio.timeout(request.app.state.settings.readiness_timeout_seconds): + dependencies = await asyncio.gather( + check_database(request.app.state.engine), + check_redis(request.app.state.redis), + ) + except TimeoutError: + raise unavailable() from None + if not all(dependencies): raise unavailable() return Health(status="ok") diff --git a/app/endpoints/messages.py b/app/endpoints/messages.py index f8a734d9..50dc1a18 100644 --- a/app/endpoints/messages.py +++ b/app/endpoints/messages.py @@ -1,9 +1,10 @@ from typing import Annotated from uuid import UUID -from fastapi import APIRouter, Query +from fastapi import APIRouter, Header, Query -from app.domain.messages import list_messages, send_message +from app.domain.idempotency import send_message_idempotent, validate_idempotency_key +from app.domain.messages import list_messages from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession from app.schemas.message import CreateMessage, Message, MessagePage @@ -17,14 +18,12 @@ async def send_new_message( sender: CurrentUser, session: DbSession, settings: AppSettings, - # TODO(3.4): принять заголовок Idempotency-Key: - # idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None - # и вызывать app.domain.idempotency.send_message_idempotent(...) вместо send_message. - # Нет/неверный ключ -> 400 (validate_idempotency_key). Валидацию делайте сами, - # а не через pattern= у Header, чтобы текст ошибки был в общем формате. + idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None, ) -> Message: - return await send_message( - session, sender, chat_id, new_message, settings.max_messages + return await send_message_idempotent( + session, sender, chat_id, new_message, + validate_idempotency_key(idempotency_key), + settings.max_messages, settings.idempotency_ttl_seconds, ) diff --git a/app/errors/handlers.py b/app/errors/handlers.py index 8aa80a78..7216a134 100644 --- a/app/errors/handlers.py +++ b/app/errors/handlers.py @@ -11,6 +11,7 @@ from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError from sqlalchemy.exc import TimeoutError as PoolTimeoutError from starlette.exceptions import HTTPException as StarletteHTTPException +from app.core.instance import INSTANCE_ID_HEADER from app.core.request_id import REQUEST_ID_HEADER from app.errors.exceptions import ApiError, internal_error, unavailable @@ -43,6 +44,9 @@ def _build_response( **(headers or {}), REQUEST_ID_HEADER: request_id, } + instance_id = getattr(request.app.state, "instance_id", None) + if instance_id is not None: + response_headers[INSTANCE_ID_HEADER] = instance_id body = { "error": { diff --git a/app/main.py b/app/main.py index f0a4c12a..a21be50a 100644 --- a/app/main.py +++ b/app/main.py @@ -7,6 +7,8 @@ from fastapi import Depends, FastAPI from app.core.config import Settings from app.core.database import create_db_engine, create_session_factory +from app.core.instance import InstanceIdMiddleware, resolve_instance_id +from app.core.lifecycle import GracefulServer, Lifecycle from app.core.redis import create_redis_client from app.core.request_capacity import acquire_request_slot, create_request_capacity from app.core.request_id import RequestIdMiddleware @@ -45,12 +47,12 @@ def create_app(settings: Settings | None = None) -> FastAPI: application.state.session_factory = create_session_factory(engine) application.state.redis = redis application.state.request_capacity = create_request_capacity(settings.max_in_flight) - - # TODO(3.2): application.state.instance_id = resolve_instance_id(settings.instance_id) - # и application.add_middleware(InstanceIdMiddleware, instance_id=...) - # (app/core/instance.py). Middleware, добавленный последним, — внешний. - # TODO(4.1): application.state.lifecycle = Lifecycle() (app/core/lifecycle.py) + application.state.instance_id = resolve_instance_id(settings.instance_id) + application.state.lifecycle = Lifecycle() application.add_middleware(RequestIdMiddleware) + application.add_middleware( + InstanceIdMiddleware, instance_id=application.state.instance_id + ) register_exception_handlers(application) limited = [Depends(acquire_request_slot)] @@ -65,15 +67,17 @@ def create_app(settings: Settings | None = None) -> FastAPI: def main() -> None: settings = Settings() # type: ignore - uvicorn.run( - "app.main:create_app", - factory=True, + application = create_app(settings) + config = uvicorn.Config( + application, host=settings.app_host, port=settings.app_port, log_level=settings.log_level.lower(), - # TODO(4.1): согласовать с stop_grace_period в compose.yaml и drain-периодом timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds, ) + GracefulServer( + config, application.state.lifecycle, settings.shutdown_drain_seconds + ).run() if __name__ == "__main__": diff --git a/app/models/__init__.py b/app/models/__init__.py index 9d56e6e2..1417151a 100644 --- a/app/models/__init__.py +++ b/app/models/__init__.py @@ -2,7 +2,8 @@ from app.models.base import Base from app.models.chat import Chat from app.models.chat_member import ChatMember from app.models.counter import Counter +from app.models.idempotency_key import IdempotencyKey from app.models.message import Message from app.models.user import User -__all__ = ["Base", "Chat", "ChatMember", "Counter", "Message", "User"] +__all__ = ["Base", "Chat", "ChatMember", "Counter", "IdempotencyKey", "Message", "User"] diff --git a/app/models/idempotency_key.py b/app/models/idempotency_key.py index 7c10fdd2..5b1d3551 100644 --- a/app/models/idempotency_key.py +++ b/app/models/idempotency_key.py @@ -1,28 +1,24 @@ -"""ORM-модель записи идемпотентности. +"""Сохранённый результат отправки сообщения.""" -TODO(3.4): раскомментировать/доработать, добавить в app/models/__init__.py -и сгенерировать миграцию: `make migration m="add idempotency keys"` -(с поднятой БД), затем проверить сгенерированный файл руками. +import uuid +from datetime import datetime -Примерная схема: +from sqlalchemy import ForeignKey, Index, String, func +from sqlalchemy.orm import Mapped, mapped_column - class IdempotencyKey(Base): - __tablename__ = "idempotency_keys" - __table_args__ = ( - PrimaryKeyConstraint("user_id", "method", "path", "key"), - Index("ix_idempotency_keys_created_at", "created_at"), # для чистки по TTL - ) +from app.models.base import Base - user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id")) - method: Mapped[str] = mapped_column(String(8)) - path: Mapped[str] = mapped_column(String(255)) - key: Mapped[str] = mapped_column(String(128)) - request_hash: Mapped[str] = mapped_column(String(64)) - message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id")) - created_at: Mapped[datetime] = mapped_column(server_default=func.now()) -Вопросы проектирования: - - почему достаточно сохранить message_id, а не весь JSON ответа; - - как и когда удаляются ключи старше IDEMPOTENCY_TTL_SECONDS; - - что видит второй параллельный запрос, пока первый ещё не COMMIT. -""" +class IdempotencyKey(Base): + """Ключ запроса и связанное сообщение.""" + + __tablename__ = "idempotency_keys" + __table_args__ = (Index("ix_idempotency_keys_created_at", "created_at"),) + + user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True) + method: Mapped[str] = mapped_column(String(8), primary_key=True) + path: Mapped[str] = mapped_column(String(255), primary_key=True) + key: Mapped[str] = mapped_column(String(128), primary_key=True) + request_hash: Mapped[str] = mapped_column(String(64)) + message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id")) + created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp()) diff --git a/app/storage/idempotency.py b/app/storage/idempotency.py new file mode 100644 index 00000000..5cfcf709 --- /dev/null +++ b/app/storage/idempotency.py @@ -0,0 +1,63 @@ +"""Хранение и блокировка ключей в PostgreSQL.""" + +from datetime import timedelta +import hashlib +import json +from uuid import UUID + +from sqlalchemy import BigInteger, func, literal, select, tuple_ +from sqlalchemy.dialects.postgresql import insert +from sqlalchemy.ext.asyncio import AsyncSession + +from app.models.idempotency_key import IdempotencyKey + +Scope = tuple[UUID, str, str, str] + + +async def lock_key(session: AsyncSession, scope: Scope) -> None: + """Сериализует один ключ до конца транзакции.""" + raw = json.dumps([str(scope[0]), *scope[1:]]).encode() + lock_id = int.from_bytes(hashlib.sha256(raw).digest()[:8], signed=True) + await session.execute( + select(func.pg_advisory_xact_lock(literal(lock_id, type_=BigInteger))) + ) + + +async def get_active_key( + session: AsyncSession, scope: Scope, ttl_seconds: int +) -> IdempotencyKey | None: + """Читает результат, пока срок ключа не истёк.""" + stmt = select(IdempotencyKey).where( + tuple_( + IdempotencyKey.user_id, + IdempotencyKey.method, + IdempotencyKey.path, + IdempotencyKey.key, + ) == tuple_(*scope), + IdempotencyKey.created_at + > func.clock_timestamp() - timedelta(seconds=ttl_seconds), + ) + return await session.scalar(stmt) + + +async def save_result( + session: AsyncSession, scope: Scope, request_hash: str, message_id: UUID +) -> None: + """Сохраняет новый результат или заменяет истёкший.""" + stmt = insert(IdempotencyKey).values( + user_id=scope[0], method=scope[1], path=scope[2], key=scope[3], + request_hash=request_hash, message_id=message_id, + ) + await session.execute( + stmt.on_conflict_do_update( + index_elements=[ + IdempotencyKey.user_id, IdempotencyKey.method, + IdempotencyKey.path, IdempotencyKey.key, + ], + set_={ + "request_hash": request_hash, + "message_id": message_id, + "created_at": func.clock_timestamp(), + }, + ) + ) diff --git a/compose.test.yaml b/compose.test.yaml index 46c9448f..140a2a1d 100644 --- a/compose.test.yaml +++ b/compose.test.yaml @@ -4,7 +4,7 @@ services: postgres: ports: - - "127.0.0.1:${DB_HOST_PORT:-15432}:5432" + - "127.0.0.1:${DB_HOST_PORT:?Set DB_HOST_PORT in .env}" redis: ports: - - "127.0.0.1:${REDIS_HOST_PORT:-16379}:6379" + - "127.0.0.1:${REDIS_HOST_PORT:?Set REDIS_HOST_PORT in .env}" diff --git a/compose.yaml b/compose.yaml index cc05f4c5..be31ed12 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,75 +1,125 @@ -# Клиент → nginx (LB) → api × N → postgres + redis. -# Незавершённые места помечены TODO(<номер>). -# -# Запуск: docker compose --env-file .env up -d --build (или make up) +name: mtusi-messenger-lab3 x-api-image: &api-image - build: . - image: mtusi-messenger:lab3 + build: + context: . + args: + API_BUILD_REVISION: ${API_BUILD_REVISION:?Set API_BUILD_REVISION in .env} + image: ${API_IMAGE:?Set API_IMAGE in .env} + +x-base-env: &base-env + APP_HOST: ${APP_HOST:?Set APP_HOST in .env} + APP_PORT: ${APP_PORT:?Set APP_PORT in .env} + APP_ENV: ${APP_ENV:?Set APP_ENV in .env} + LOG_LEVEL: ${LOG_LEVEL:?Set LOG_LEVEL in .env} + MAX_MESSAGES: ${MAX_MESSAGES:?Set MAX_MESSAGES in .env} + MAX_IN_FLIGHT: ${MAX_IN_FLIGHT:?Set MAX_IN_FLIGHT in .env} + DB_HOST: ${DB_HOST:?Set DB_HOST in .env} + DB_PORT: ${DB_PORT:?Set DB_PORT in .env} + DB_NAME: ${DB_NAME:?Set DB_NAME in .env} + DB_USER: ${DB_USER:?Set DB_USER in .env} + DB_POOL_SIZE: ${DB_POOL_SIZE:?Set DB_POOL_SIZE in .env} + DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:?Set DB_MAX_OVERFLOW in .env} + DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:?Set DB_POOL_TIMEOUT_SECONDS in .env} + DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:?Set DB_CONNECT_TIMEOUT_SECONDS in .env} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:?Set DB_STATEMENT_TIMEOUT_MS in .env} + SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:?Set SHUTDOWN_DRAIN_SECONDS in .env} + GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS: ${GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS:?Set GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS in .env} + READINESS_TIMEOUT_SECONDS: ${READINESS_TIMEOUT_SECONDS:?Set READINESS_TIMEOUT_SECONDS in .env} services: postgres: image: postgres:16.10-bookworm restart: unless-stopped - # TODO(4.3): секреты через `secrets:` (POSTGRES_PASSWORD_FILE), а не env. environment: - POSTGRES_USER: ${DB_USER} - POSTGRES_DB: ${DB_NAME} - POSTGRES_PASSWORD: ${DB_PASSWORD} + POSTGRES_USER: ${DB_USER:?Set DB_USER in .env} + POSTGRES_DB: ${DB_NAME:?Set DB_NAME in .env} + POSTGRES_PASSWORD_FILE: /run/secrets/db_password + secrets: + - db_password volumes: - pgdata:/var/lib/postgresql/data - # Порты наружу не публикуются; для локальных pytest см. compose.test.yaml. healthcheck: test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] - interval: 5s + interval: 3s timeout: 3s retries: 10 - # TODO(4.3): deploy.resources.limits (cpus / memory) + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M redis: image: redis:7.4.2-bookworm restart: unless-stopped - # TODO(4.3): пароль через secrets, а не в командной строке - command: ["redis-server", "/usr/local/etc/redis/redis.conf", "--requirepass", "${REDIS_PASSWORD}"] - environment: - REDISCLI_AUTH: ${REDIS_PASSWORD} + entrypoint: ["/bin/sh", "/usr/local/bin/start-redis.sh"] + secrets: + - redis_password volumes: - ./infra/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro + - ./infra/redis/start-redis.sh:/usr/local/bin/start-redis.sh:ro - redisdata:/data healthcheck: - test: ["CMD", "redis-cli", "ping"] - interval: 5s + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping"] + interval: 3s timeout: 3s retries: 10 - # TODO(4.3): deploy.resources.limits + deploy: + resources: + limits: + cpus: "0.5" + memory: 512M - # Однократные миграции до старта реплик: api ждёт service_completed_successfully, - # поэтому реплики не устраивают гонку `alembic upgrade`. - # TODO(4.4): описать совместимость миграций с работающей версией (expand/contract). migrate: <<: *api-image command: ["alembic", "upgrade", "head"] - env_file: .env + environment: *base-env + secrets: + - db_password depends_on: postgres: condition: service_healthy restart: "no" + healthcheck: + disable: true + deploy: + resources: + limits: + cpus: "0.5" + memory: 256M api: <<: *api-image restart: unless-stopped - env_file: .env environment: - SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} - # Не задавайте container_name и ports: несколько реплик одного service, - # доступ только через nginx. + <<: *base-env + REDIS_HOST: ${REDIS_HOST:?Set REDIS_HOST in .env} + REDIS_PORT: ${REDIS_PORT:?Set REDIS_PORT in .env} + REDIS_DB: ${REDIS_DB:?Set REDIS_DB in .env} + REDIS_MAX_CONNECTIONS: ${REDIS_MAX_CONNECTIONS:?Set REDIS_MAX_CONNECTIONS in .env} + REDIS_POOL_TIMEOUT_SECONDS: ${REDIS_POOL_TIMEOUT_SECONDS:?Set REDIS_POOL_TIMEOUT_SECONDS in .env} + REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:?Set REDIS_CONNECT_TIMEOUT_SECONDS in .env} + REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:?Set REDIS_SOCKET_TIMEOUT_SECONDS in .env} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:?Set SESSION_TTL_SECONDS in .env} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:?Set IDEMPOTENCY_TTL_SECONDS in .env} + secrets: + - db_password + - redis_password deploy: - replicas: ${API_REPLICAS:-2} - # TODO(4.3): resources.limits: { cpus: "...", memory: "..." } - # TODO(4.1): healthcheck по /health/ready (interval/timeout/retries), - # согласованный с проверками nginx; сейчас действует HEALTHCHECK - # из Dockerfile по /health/live. - # TODO(4.1): stop_signal / stop_grace_period > drain + graceful timeout. + replicas: ${API_REPLICAS:?Set API_REPLICAS in .env} + resources: + limits: + cpus: "1.0" + memory: 512M + healthcheck: + test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"] + interval: 3s + timeout: 3s + start_period: 10s + retries: 2 + stop_signal: SIGTERM + stop_grace_period: 8s depends_on: postgres: condition: service_healthy @@ -84,8 +134,7 @@ services: volumes: - ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro ports: - # Единственная публичная точка входа. - - "127.0.0.1:${LB_HOST_PORT:-8080}:8080" + - "127.0.0.1:${LB_HOST_PORT:?Set LB_HOST_PORT in .env}:8080" healthcheck: test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb-health"] interval: 5s @@ -94,12 +143,18 @@ services: depends_on: api: condition: service_healthy - # TODO(4.3): deploy.resources.limits + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M volumes: pgdata: redisdata: -# TODO(4.3): secrets: -# db_password: -# file: ./secrets/db_password # каталог secrets/ в .gitignore +secrets: + db_password: + file: ./secrets/db_password + redis_password: + file: ./secrets/redis_password diff --git a/evidence/README.md b/evidence/README.md index 8df70015..5ab9bdf8 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -1,5 +1,101 @@ -# Доказательства +# Доказательства лабораторной 3 -Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. +Прогон от 04.11.2026, автор: Григорян Илья Мурадович, БПИ2303. Цель — оценка 4. +Команды выполнялись на незакоммиченном рабочем дереве поверх commit +`f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit. +Состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt). +Документация не включена в этот fingerprint; её подготовка продолжалась после тестов. -Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. +## Артефакты + +| Файл | Содержание | +| --- | --- | +| [run.json](run.json) | Время прогона, базовый commit, версии Docker/Compose/Python, оборудование, параметры, лимиты и команды. | +| [test-output.txt](test-output.txt) | Реальный stdout/stderr полного `test-grade4`: 156 pytest, smoke, конкурентные повторы, persistence, failover, SIGTERM, rolling и остановка каждой реплики. Абсолютный путь checkout заменён на ``. | +| [nginx-output.txt](nginx-output.txt) | Реальный вывод отдельного `test-nginx`, включая gzip, ограничение частоты и DNS. | +| [metrics.json](metrics.json) | Машиночитаемые строки метрик и состояний реплик из полного вывода, без пересчёта чисел. | +| [source-sha256.txt](source-sha256.txt) | SHA-256 исходников, скриптов, тестов и конфигурации, использованных при запуске. Проверка: `sha256sum -c evidence/source-sha256.txt`. | +| [cleanup.txt](cleanup.txt) | Итоговая проверка удаления ресурсов лабораторной; conserver и его данные сохранены. | + +Результаты относятся только к этому прогону и составу файлов. После изменения кода, +окружения или ресурсов их нужно получить заново. Ниже приведён способ повторения; +старые численные значения при новом запуске не обязаны совпасть. + +## Как повторить + +Нужны Docker, Compose и Python 3.12 с зависимостями проекта. Из корня: + +```sh +test -f .env || cp .env.example .env +make prepare-secrets PYTHON=.venv/bin/python +make test-grade4 PYTHON=.venv/bin/python +make test-nginx PYTHON=.venv/bin/python +``` + +Существующий `.env` не заменяется. Пароли находятся в `secrets/`, а не в артефактах. +`test-grade4` создаёт отдельный проект `mtusi-messenger-lab3-test` с двумя API, +PostgreSQL, Redis, migrate и Nginx. Вход — localhost:18080, PostgreSQL:15432, +Redis:16379. Фактические параметры этого запуска перечислены в `run.json`. +В конце, включая ошибку, тестовые контейнеры, сеть и volumes удаляются. + +## Что измерялось + +1. Контракт и OpenAPI; 156 pytest с реальными PostgreSQL и Redis, включая реальный + restart Redis. Собственные тесты используют отдельную БД `_test` + и Redis DB 15; API стенда использует свою основную БД и Redis DB 0. +2. Публичный HTTP smoke, 24 одновременных повтора одного ключа восемью потоками + через Nginx, restart всех компонентов с сохранением volumes и существующей + сессии, публичный failover. +3. Проверка фактических Docker CPU/RAM, портов, read-only секретов и окружения. + Пароли не считываются в вывод inspect; аудит проверяет имена переменных/монтирований. +4. SIGTERM одной API: незавершённый POST удерживается PostgreSQL advisory lock, + сигнал отправляется процессу, проверяются ready=503/live=200/новая работа=503. + Через 1,2 с блокировка освобождается; исходный POST получает 201. Проверяются + выход без OOM/SIGKILL, бюджет <8 с и наличие сообщения в истории. API восстановлена. +5. Rolling: два клиента пишут в общий чат, timeout 2 с, пауза 80 мс после каждой + попытки, одна секунда до и после обновления. Новая метка `API_BUILD_REVISION` + даёт новый образ с прежним бизнес-кодом. Сборка одна, `alembic upgrade head` + вызван один раз без ожидающих новых миграций. Перед каждой остановкой проверяются + две другие здоровые API; в конце оба старых контейнера и образ API заменены. +6. Отказ каждой из двух актуальных API: два клиента, закрытый цикл без заданного + arrival rate, 2 с прогрева, остановка выбранной API с timeout 8 с, 10 с после + завершения hook. При ошибке пауза 100 мс, ключ сохраняется до успешного ответа. + Перед следующим отказом предыдущая API восстановлена и отвечает через LB. + Состояния `before`, `stopped`, `restored` записаны для каждой цели. +7. После обновления и отказов прочитана полная история: все подтверждённые ID + присутствуют, текстовые метки не дублируются. Nginx отдельно проверен временными + HTTP-backend без данных мессенджера, включая третью реплику через DNS без reload. + +RPS rolling = успешные ответы запросов, начатых в интервале обновления / длительность +этого интервала. Его p95 относится к этим успешным запросам. Счётчик ошибок rolling +охватывает всё время работы двух клиентов, включая секунду до и после. +RPS failover = число успешных ответов / время от запуска клиентов до последнего +успешного завершения. Это ответы, а не обязательно число новых уникальных строк: +ответ на повтор ключа также считается успешным. `first_recovery_seconds` — время +от начала hook до первого завершения успешного POST, начатого после конца hook. +Показатель включает длительность команды остановки, а не только сетевой простой. + +Ошибки разделены на `http_429` (ограничитель), `http_503` (временная недоступность), +`connection` и `contract`; в успешном прогоне последние две категории отсутствовали +в rolling и последовательном failover. Нельзя приписывать все ошибки отказу API: +профиль также достигает ограничителя Nginx 50 запросов/с с burst=100. + +## Ресурсы и границы + +| Контейнер | CPU | RAM | +| --- | ---: | ---: | +| PostgreSQL | 1 | 512 MiB | +| Redis | 0,5 | 512 MiB | +| API, каждый | 1 | 512 MiB | +| migrate | 0,5 | 256 MiB | +| Nginx | 0,5 | 128 MiB | + +Обычно работают две API, при обновлении временно три. Пулы БД: 5 + 10 на API, +до 45 соединений на три API, не считая миграций и диагностики. Redis: AOF, +appendfsync always, maxmemory 256 MiB, noeviction. Нагрузка синтетическая, один +прогон на одном хосте. Это не поиск предельного RPS, не отказ хоста, диска или +хранилища и не доказательство совместимости произвольных будущих миграций. + +В доказательства не включены `.env`, пароли, токены сессий, cookies, приватные +ключи, дампы БД и тела сообщений. При добавлении новых артефактов сохраняйте это +правило; большие логи и бинарные traces храните отдельно по правилам преподавателя. diff --git a/evidence/cleanup.txt b/evidence/cleanup.txt new file mode 100644 index 00000000..89a0ebbd --- /dev/null +++ b/evidence/cleanup.txt @@ -0,0 +1,19 @@ +Cleanup at 2026-11-04T14:08:42.159262+00:00 +$ docker compose --env-file .env -p mtusi-messenger-lab3 -f compose.yaml down --volumes --remove-orphans + +$ docker compose --env-file .env -p mtusi-messenger-lab3-test -f compose.yaml -f compose.test.yaml down --volumes --remove-orphans + +Containers: +conserver: Exited (128) 4 weeks ago +Volumes: +test_conserver-logs +Images: +mtusi-messenger:lab3 +conserver:latest +postgres:16.10-bookworm +nginx:1.28.0-alpine +redis:7.4.2-bookworm +Project containers and volumes: absent. +Existing .env and secrets/: preserved. +conserver and its volume: preserved. +Only main Compose images and conserver image retained. diff --git a/evidence/metrics.json b/evidence/metrics.json new file mode 100644 index 00000000..2eca4b4f --- /dev/null +++ b/evidence/metrics.json @@ -0,0 +1,147 @@ +[ + { + "observed_instances_before": 2, + "successful_writes": 108, + "failed_attempts": 4, + "first_recovery_seconds": 1.845 + }, + { + "scenario": "rolling update", + "replacements": 2, + "migration_runs": 1, + "successful_writes": 456, + "failed_attempts": 13, + "errors_by_kind": { + "http_503": 13 + }, + "elapsed_seconds": 23.627, + "successful_rps": 19.3, + "p95_seconds": 0.043 + }, + { + "scenario": "replica_failure", + "phase": "before", + "target": "bcbb50630124", + "replicas": [ + { + "instance": "bcbb50630124", + "running": true, + "health": "healthy" + }, + { + "instance": "df18f4fb557f", + "running": true, + "health": "healthy" + } + ] + }, + { + "scenario": "replica_failure", + "phase": "stopped", + "target": "bcbb50630124", + "replicas": [ + { + "instance": "bcbb50630124", + "running": false, + "health": "unhealthy" + }, + { + "instance": "df18f4fb557f", + "running": true, + "health": "healthy" + } + ] + }, + { + "scenario": "replica_failure", + "phase": "restored", + "target": "bcbb50630124", + "replicas": [ + { + "instance": "bcbb50630124", + "running": true, + "health": "healthy" + }, + { + "instance": "df18f4fb557f", + "running": true, + "health": "healthy" + } + ] + }, + { + "instance": "bcbb50630124", + "successful_writes": 773, + "failed_attempts": 83, + "errors_by_kind": { + "http_429": 67, + "http_503": 16 + }, + "elapsed_seconds": 13.853, + "successful_rps": 55.8, + "first_recovery_seconds": 1.8 + }, + { + "scenario": "replica_failure", + "phase": "before", + "target": "df18f4fb557f", + "replicas": [ + { + "instance": "bcbb50630124", + "running": true, + "health": "healthy" + }, + { + "instance": "df18f4fb557f", + "running": true, + "health": "healthy" + } + ] + }, + { + "scenario": "replica_failure", + "phase": "stopped", + "target": "df18f4fb557f", + "replicas": [ + { + "instance": "bcbb50630124", + "running": true, + "health": "healthy" + }, + { + "instance": "df18f4fb557f", + "running": false, + "health": "unhealthy" + } + ] + }, + { + "scenario": "replica_failure", + "phase": "restored", + "target": "df18f4fb557f", + "replicas": [ + { + "instance": "bcbb50630124", + "running": true, + "health": "healthy" + }, + { + "instance": "df18f4fb557f", + "running": true, + "health": "healthy" + } + ] + }, + { + "instance": "df18f4fb557f", + "successful_writes": 773, + "failed_attempts": 116, + "errors_by_kind": { + "http_429": 99, + "http_503": 17 + }, + "elapsed_seconds": 13.875, + "successful_rps": 55.71, + "first_recovery_seconds": 1.782 + } +] diff --git a/evidence/nginx-output.txt b/evidence/nginx-output.txt new file mode 100644 index 00000000..7797318f --- /dev/null +++ b/evidence/nginx-output.txt @@ -0,0 +1,11 @@ +.venv/bin/python scripts/check_nginx.py +nginx version: nginx/1.28.0 +PASS: nginx -t и балансировка двух реплик +PASS: gzip 2060 → 61 байт, содержимое сохранено +PASS: JSON и заголовки ошибки API передаются без подмены +PASS: отправленный POST не повторяется на другой реплике +PASS: лимит вернул 391 ответов 429; health доступен +PASS: третья реплика обнаружена через DNS без reload nginx +PASS: отказ реплики, первое успешное чтение через 0.207 с +PASS: недоступность всех backend возвращает JSON 503 +PASS: JSON access log содержит время backend и результат лимита diff --git a/evidence/run.json b/evidence/run.json new file mode 100644 index 00000000..5130cf26 --- /dev/null +++ b/evidence/run.json @@ -0,0 +1,149 @@ +{ + "started_at_utc": "2026-11-04T13:59:48.203542+00:00", + "base_commit": "f20b751207ed9948bfcdab829c458a4af122d611", + "worktree_dirty": true, + "source_manifest_sha256": "73187c6a987b4fce648f79198a89a99b238bc5aa0617339d662b09c86cb423cb", + "runtime_profile": { + "API_REPLICAS": "2", + "APP_PORT": "8080", + "LB_HOST_PORT": "8080", + "DB_HOST_PORT": "15432", + "REDIS_HOST_PORT": "16379", + "MAX_MESSAGES": "100000", + "MAX_IN_FLIGHT": "16", + "DB_POOL_SIZE": "5", + "DB_MAX_OVERFLOW": "10", + "DB_POOL_TIMEOUT_SECONDS": "3", + "DB_CONNECT_TIMEOUT_SECONDS": "3", + "DB_STATEMENT_TIMEOUT_MS": "5000", + "REDIS_MAX_CONNECTIONS": "20", + "REDIS_POOL_TIMEOUT_SECONDS": "1", + "REDIS_CONNECT_TIMEOUT_SECONDS": "1", + "REDIS_SOCKET_TIMEOUT_SECONDS": "0.5", + "SESSION_TTL_SECONDS": "3600", + "IDEMPOTENCY_TTL_SECONDS": "86400", + "SHUTDOWN_DRAIN_SECONDS": "1", + "GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS": "5", + "READINESS_TIMEOUT_SECONDS": "2" + }, + "commands": [ + "make test-grade4 PYTHON=.venv/bin/python", + "make test-nginx PYTHON=.venv/bin/python" + ], + "local_python": "Python 3.12.14", + "docker_compose": "5.6.1", + "docker_host": { + "server_version": "29.9.2", + "os": "linux", + "architecture": "x86_64", + "cpus": 8, + "memory_bytes": 16400363520, + "kernel": "7.2.11-zen1-1-zen" + }, + "host_cpu_model": "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz", + "finished_at_utc": "2026-11-04T14:07:19.867546+00:00", + "results": { + "test_grade4_exit_code": 0, + "test_nginx_exit_code": 0, + "pytest_passed": 156, + "pytest_seconds": 42.3 + }, + "container_limits": { + "postgres": { + "cpus": 1, + "memory_mib": 512 + }, + "redis": { + "cpus": 0.5, + "memory_mib": 512 + }, + "api_each": { + "cpus": 1, + "memory_mib": 512 + }, + "migrate": { + "cpus": 0.5, + "memory_mib": 256 + }, + "nginx": { + "cpus": 0.5, + "memory_mib": 128 + } + }, + "test_profile": { + "project": "mtusi-messenger-lab3-test", + "compose_files": [ + "compose.yaml", + "compose.test.yaml" + ], + "lb_host_port": 18080, + "api_replicas": 2, + "test_postgres_port": 15432, + "test_redis_port": 16379, + "pytest_redis_db": 15, + "rolling": { + "clients": 2, + "timeout_seconds": 2, + "pause_after_attempt_seconds": 0.08, + "warmup_seconds": 1, + "after_update_seconds": 1, + "image_change": "API_BUILD_REVISION label; same business code", + "pending_migrations": false + }, + "failover_each": { + "clients": 2, + "timeout_seconds": 2, + "warmup_seconds": 2, + "after_stop_hook_seconds": 10, + "error_backoff_seconds": 0.1, + "stop_timeout_seconds": 8 + } + }, + "installed_local_packages": { + "fastapi": "0.143.3", + "uvicorn": "0.54.0", + "pydantic": "2.14.1", + "pydantic-settings": "2.16.0", + "SQLAlchemy": "2.1.4", + "alembic": "1.20.0", + "asyncpg": "0.32.0", + "redis": "8.1.0", + "pytest": "9.1.1", + "pytest-asyncio": "1.4.1" + }, + "images": [ + { + "tag": "mtusi-messenger:lab3", + "id": "sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413", + "repo_digests": [ + "mtusi-messenger@sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413" + ], + "revision": "verification-81ccd2376178" + }, + { + "tag": "postgres:16.10-bookworm", + "id": "sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74", + "repo_digests": [ + "postgres@sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74" + ], + "revision": null + }, + { + "tag": "redis:7.4.2-bookworm", + "id": "sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9", + "repo_digests": [ + "redis@sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9" + ], + "revision": null + }, + { + "tag": "nginx:1.28.0-alpine", + "id": "sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284", + "repo_digests": [ + "nginx@sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284" + ], + "revision": null + } + ], + "manifest_scope": "Executable sources, tests and configuration; excludes documentation, .env and secrets." +} diff --git a/evidence/source-sha256.txt b/evidence/source-sha256.txt new file mode 100644 index 00000000..f153e6d1 --- /dev/null +++ b/evidence/source-sha256.txt @@ -0,0 +1,107 @@ +ce3cd59eb07b3f3cfb85c19c9dfcba82aeca3b4231d523c6a2c85d28bf2b66f9 .env.example +2ea849842e877eca40e5dd853a5299a81be15fa414476fbfe434ac487f59ec1f Dockerfile +dd18f3dabac00cf562e2d4eec2615a3b7e37bb5343b47f1eb0f0fb49c2a11b7e Makefile +274785e9cfb1af978fcdf254f3b9c93847216d9183cf290098f857f174f43b41 alembic.ini +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/__init__.py +5839d94c506f0362278a4f85bca8346774f5f323112963dd3830e525a069fb61 app/__main__.py +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/core/__init__.py +f66f54d722c4bde445e402c5f80fc2c826dd02a35b49a7ef8e78183aae577e30 app/core/config.py +e9ae2ff773dfd0f3f0515b6fd29c8b23820cd1a3b83e2b99dccaca8f0ddf8a40 app/core/database.py +da4dcfda3dabeb595aa7b917d321e794074676fd258828c84be4322b917ac43c app/core/instance.py +aedcaa71c991f0147603bad32bbd105ebdc689cfc388d274e83ce693f32ba534 app/core/lifecycle.py +69056a1660683bc5086b558b38660c304650d261f760248499ace499031c7e4e app/core/redis.py +290d97e3551e1661feb04debc0272c9c91fe7636d1771de9e78055c64e23933c app/core/request_capacity.py +e1f3f08c65cf17ea24574682050e0435d5a5c22b7b2194ea40aad941716871b4 app/core/request_id.py +7717e9ea31415dd9803f14e6290e709bfb63aa38cb1524db9b04881cf2512256 app/core/security.py +6acb951afe3a628d9bd9ae25ab8c321b8debb0f481c745881a7af1f48e620c90 app/domain/__init__.py +d7026b518eb7f3f054a5aaa5307171db031718c0c70555d40c03e7aabc9f539d app/domain/auth.py +33f20c63c3fdcb491adb2153a147e822e0a16de4a5f634355a6d2db514aaa668 app/domain/chats.py +a2bc40d13dca0215bc817c8781038586827d8b5601dd916b18c0f472e28e17b3 app/domain/idempotency.py +f127324bf34b423b33dd0e446ab049740ee6364785b34a805556331b8e324c22 app/domain/messages.py +df9aa94fab247467fe5f6fa030bdf3e587b5749060f0c3d663f5bd3e57e8dfe9 app/domain/pagination.py +31ec7ba4c47ae6c31661eb8b4231efe9f561784c3bc0555c7d9b9bde804fe88f app/domain/users.py +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/endpoints/__init__.py +0cb1dded40038b80eafabcb288f43b1b7fcac1d8d41898e657eb9b62afaa2aab app/endpoints/auth.py +2fc7d2b4f155e1cdba6d02ac157b1c2d74932c930d6cba7ac93c0a811af1494a app/endpoints/chats.py +1980c53bce1e96c801bb0ad49c6d35957c07f3e50db1804475a67f07a7d96082 app/endpoints/dependencies.py +2e1606211c689a8959041433bcb4b70e4c5fd1647038fe391eb5435b9d07ddca app/endpoints/health.py +a6424660ce901defac67b5d66a882f8051a531328fc6d4aa998c407ca276c4e3 app/endpoints/messages.py +13fe05bec4b4b0a9e7a2f90756065bf97e257601b119a71465b24fc0144f3bf9 app/endpoints/users.py +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/errors/__init__.py +355a762e6dc81dd844671982a68d944fa10d9631ef91cd3afd9312f2cffb8ec2 app/errors/exceptions.py +5e5616f8bb0b1b3fdaaba69f2e9248de79ebd3c1d0d123c9c613aa106e691960 app/errors/handlers.py +21a24f61599534856d11c5ce574111ce8a1d395f06aef5618558c4e54afefbc0 app/main.py +116ec0d604cecd9306827761bfa2290a87dc99c6c5519bfd5b618f0de6d6dddf app/models/__init__.py +548f10800483dd91a4d321c3cef845f3f5b126169a50474bf846f78839fdb43e app/models/base.py +7076f06111aca1e3845a8515112fa1302da9bd331cf79c699259c91d3d23c9cf app/models/chat.py +dfb64d43bd519d06f09e479eab4bdd277f317fdb92e206fdedf0afbed1fe18ad app/models/chat_member.py +35eaa453501b48d178d7b17fd22314783386b64951cbb518b450698ba65219f8 app/models/counter.py +693039c889d92ebdb5ef3fc6833278f59b4aa88f802b4726b9c3bf441f83fb18 app/models/idempotency_key.py +9bbf725b6eae51e23e4fc71aea3dbc137d5a275b069e7e378351773297a7559f app/models/message.py +b5f1bbdc4370e2671427c8d7590aba58916b1981f225c4734d8bdeb944b1539a app/models/user.py +7c9d4ef216ed8b027ddfbad9746147cf0fed6463baf396b7244bd9b1b286e9ee app/schemas/__init__.py +9a3f14dc23e704d9fdce681ae7187a6b95638f9736711a8edef245fbbaea3eb6 app/schemas/base.py +2111aef9c942b34d02afa99da6d23a1d5ca0f6cfd75a1c0ebfb2ba85a29584b1 app/schemas/chat.py +defae263397458b7b7d1acdb3dfa2b774c00e5ec3981c8b098748d1586777fb6 app/schemas/message.py +617bcba33dcb01e4f66a50b5c425ebcbc1aef1c6148148f0eb862a7743bcf9b6 app/schemas/session.py +01fc238693c3686595cc910fadce6200e9753d0c4a0397ff327d8a0c937dc4df app/schemas/user.py +33296ca85924a22644fda573be072e5b810a284b939469580445925a85f0b5e9 app/storage/__init__.py +e479c8be1f56030fc4faaa74417fb959fb2c1f0c57f72974df8b538ff1209a7b app/storage/chats.py +2a9243ad419e7cc48ce0c6da13053df6773bea53a2342eb408cb3ebe2455f921 app/storage/idempotency.py +f196fc426771cc9a628d25f466113badd1de1f123e9b3adc3cff9dc96e49824d app/storage/messages.py +aeb6851a54d71051912ad588c47de3d5a3d92d518a0a198dbb3e283dd64837c7 app/storage/sessions.py +46a0562d557ac96bd49f9975ff25ac8cce7f7f803b8c280d1d0bf2463ebfdaec app/storage/types.py +f9dc7df7affda7144991944ff20a1ae5b372921b14fd391afa189d0e613dc45e app/storage/users.py +46f25ac85ff2a20a52cddf67b38c69f340bf007a355cd2e18c46e6aab9d22757 compose.test.yaml +2a40970440a7c3fcdcb621a00ba9e55b3d5cae4c8da8cf2b8bef3b70dc29f263 compose.yaml +d88506d8590ce549fd43dda7eea87f040dfff128af071f457b87e17df6282f5a infra/nginx/nginx.conf +9d4e7faeab76340dadda9916430048c32c849fb2bf02206653ea827e3304b666 infra/redis/redis.conf +0f6fe080f5f7cd1d77da5f8ee9989874e9617bd7f4830f90b91978a5bfb88056 infra/redis/start-redis.sh +37dce514d48aa4e021e063f6ebb8fb3e34275f6a76f51926d789802cad8dfa75 migrations/env.py +4ae6aee859bcbcdb238d4cb2fa35419503d7a1d5a3caaffd0f0d2e9e9dce2937 migrations/versions/49d2c947a3f1_add_idempotency_keys.py +cbe0b9e7584f26c0b859936a2584c147fe3f1ffaa9eb55c85ff753ecb10aa5a4 migrations/versions/abd273076068_add_counters.py +dd0e8073817e3a08bae19b17d4d502aa0dca0639f95d0b08caaf0e5dce16f302 migrations/versions/db06fd3126ff_create_initial_schema.py +92ce287c8eb0aa508e0efd4553650b4ebd2474d1987587d6467c26e316e6a547 pytest.ini +4cefdb67007caf026d1613be7c519c01b4c8343db7c4f4b618677e01cf113525 requirements-dev.txt +6f31c6f105a5774db02e970977bf2d26fbdba47dbb6e81836124816555d6d83f requirements.txt +599958169a2b3c35b72b9b27f54d1c156032b2fadf041cc0e905bd49e48d8c60 scripts/__init__.py +7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671 scripts/check_contract.py +22befc4a28b1a08452c769d66106d0a5b7fabc4edca7d5be1657cdf72824d899 scripts/check_grade4.py +1ebdc8a4423305b6b972254e0b856b9381f7a5279aaa537a3c9d3cdb791adccf scripts/check_idempotency.py +c95f74ebfec55b047424d65ed201519a79cd3292b9067fcf6913f5ac1bf3ab0b scripts/check_nginx.py +0926fac2e73573a6e8b32c254bfc635132823aed9c4b429e91bf180e047bc32f scripts/deployment.py +4cf255992270adfdaa0a3fd304050ed858b7a49d9e3c8856337a310cf59f8596 scripts/expiry_demo.sh +21f2e3baa4d9615e0411edbecfbdc394d471b70b4f237d1e45557c9602b0ecad scripts/explain_history.py +af3422b5b039583980599765cea8315546a1a3de80671f78c7c205faa2bac65f scripts/failover_all.py +e06776d5e44eded34a7fc849ba4cabe955428cf9f924e077a48511656538e7b2 scripts/failure_demo.sh +a5dcd78d708a7d1e69d92f56cb97e0a0a4f69577aac530d8ee195cd293dfc0cc scripts/prepare_secrets.py +0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b scripts/restart.example.sh +442cb99a2a32e91f6348b18e2729e777e4f14acf82ed8aa899abdd1bf19ca4cc scripts/restart.sh +60d48ba1c8050a79f8a3725a0ea7bba34dadba3bef0b86bd2d2e6a768e6ca7d5 scripts/rolling_update.py +1bcf34394520b89d95b7605ec56675be799eea920e83cfbba306d5dc0a6d9811 scripts/stop-one.example.sh +c78f3fee788c907764162069ee09e3bd043b3b3eb3823f5bbb8f84dd1ab5bed0 scripts/stop-one.sh +4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54 scripts/validate_openapi.py +fa12e0945cc8d7b3fdfbf476fd6a140c0a8262bb6728a1fd360cac335922da61 student-tests/conftest.py +8c11a6fbc9003c2d92225bfc676edfffe416e70d8b6972a864cf6c5c0b64c95b student-tests/helpers.py +20cd1c8ea397fe558a9ded78723dd319cabe47f520a631375171c448a01b1de2 student-tests/test_auth.py +f57751337441fbc909549d553cd32e20d7f7918dc42f2000c15f9ba2706349a4 student-tests/test_chats.py +b9c2ed985bb2cf0261bfb928f0bcc2694c8980a5c55fea4c445d0ca410ca30c6 student-tests/test_concurrency.py +b8c9a1f7535318b946adff13b11ac2459622a1a9b23962f0981d0fc7793de0c9 student-tests/test_constraints.py +76b4fe648fd257eb603cfc06da76b59b783986f96a9b357bc87238210757ef34 student-tests/test_errors.py +045203d83f8ff50e48b8fad4328dba7f12de8adffebef597efadfd40c79ed5c1 student-tests/test_failures.py +2594b7bce03d36e6c32c1644e76f4d8f40e7099de6c687e13a74706e329bcefe student-tests/test_health.py +edaf79363adb942f9501d933deb86e39aed558f32c1a73188ae2d18d088378ae student-tests/test_history_plan.py +640a12067597a7e576d3db0fb6f9bbb14639a14d701f6a9b682ed97ad70cdf8e student-tests/test_idempotency.py +722951c437488d0c5d63839d418b2456c37a40c9e8dc55a52c7e8ea3a4066c3c student-tests/test_instance.py +e39e046d8fd85711682f43220cbeded8212f9870fb6475d32f946a56b7864332 student-tests/test_lifecycle.py +71e48fab2816753b213603bd977c9c1babb2b540596cd3401c1e62a6f538a3b5 student-tests/test_limits.py +cc040ae5ee2f196362fab4c7006711bf8d8c7f5e2f56acc8c74646ef2efb801d student-tests/test_messages.py +834077f0541a2a939adc726342fba70c0b7da4b54cd8715709685a3ad23cc16c student-tests/test_migrations.py +2c573efd6b0a6204a8bac483bb6e2594c565f2d32faa04ebc3540298eb02af2d student-tests/test_pagination.py +cb981f15ad186faa2e1f8b6aecb7766eed66378b6db9dfc496dd1d76afc94b1b student-tests/test_sessions.py +bf840d8dcb6094412b9e2947df4a0a3c3f32c5d80af9df19693ed5b52b9c8d6d student-tests/test_users.py +851376079a214a655f6343bbc3f34b0e57192d8f7d84c33eb4e0a79a22d6a1bb tests/__init__.py +8d50976fc7c7bbb81e88a152f613c61ab25eaf53dba33c6a9dfab19f868d546d tests/client.py +6d3511ea719c7a7e841083e73d435c86dcbfd9f4e5c2a07d62eb9614b01d9933 tests/load.py +1f96663a174b3978d24eff66f2741f5f8c9b788d3242261d37a972720c52788b tests/resilience.py +52ac38eb343ff7d43e7543588e1da58ca06c9fce74b2b0d0bf0e4982bc23c1db tests/smoke.py diff --git a/evidence/test-output.txt b/evidence/test-output.txt new file mode 100644 index 00000000..1f81a110 --- /dev/null +++ b/evidence/test-output.txt @@ -0,0 +1,254 @@ +make[1]: Entering directory '' +.venv/bin/python -m scripts.prepare_secrets +Готов файл secrets/db_password +Готов файл secrets/redis_password +.venv/bin/python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +.venv/bin/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. +make[1]: Leaving directory '' +make[1]: Entering directory '' +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env up -d --build + Image mtusi-messenger:lab3 Building + Image mtusi-messenger:lab3 Building +#1 [internal] load local bake definitions +#1 reading from stdin 1.17kB done +#1 DONE 0.0s + +#2 [migrate internal] load build definition from Dockerfile +#2 transferring dockerfile: 797B done +#2 DONE 0.0s + +#3 [api internal] load metadata for docker.io/library/python:3.12.15-slim-bookworm +#3 DONE 1.6s + +#4 [api internal] load .dockerignore +#4 transferring context: 196B done +#4 DONE 0.0s + +#5 [migrate internal] load build context +#5 transferring context: 9.54kB done +#5 DONE 0.0s + +#6 [api 1/8] FROM docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70 +#6 resolve docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70 0.1s done +#6 resolve docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70 0.1s done +#6 DONE 0.1s + +#7 [api 3/8] RUN useradd --system --uid 10001 --no-create-home appuser +#7 CACHED + +#8 [api 2/8] WORKDIR /app +#8 CACHED + +#9 [api 4/8] COPY requirements.txt . +#9 CACHED + +#10 [api 5/8] RUN pip install -r requirements.txt +#10 CACHED + +#11 [api 6/8] COPY alembic.ini ./ +#11 CACHED + +#12 [migrate 7/8] COPY migrations ./migrations +#12 CACHED + +#13 [api 8/8] COPY app ./app +#13 DONE 0.1s + +#14 [api] exporting to image +#14 exporting layers +#14 exporting layers 0.2s done +#14 exporting manifest sha256:a38b66c8e8c9b12b9eab37bd5b9001417df363c0db1c134dd9a886f1b1d38db0 0.1s done +#14 exporting config sha256:85fe2165395388f47b557b69d0bcd64f5ca03b55e357bdf82a61d574a1e9d0a1 0.1s done +#14 exporting attestation manifest sha256:2566fe78ad8b26cb5663b995fc409959a46564667f75ca05ca0a7f9f27b66cb9 +#14 exporting attestation manifest sha256:2566fe78ad8b26cb5663b995fc409959a46564667f75ca05ca0a7f9f27b66cb9 0.1s done +#14 exporting manifest list sha256:435908277c9d70ce7fe230dc31513387f06f3db8988a195098d73696063f3019 0.0s done +#14 naming to docker.io/library/mtusi-messenger:lab3 0.0s done +#14 unpacking to docker.io/library/mtusi-messenger:lab3 +#14 unpacking to docker.io/library/mtusi-messenger:lab3 0.1s done +#14 DONE 0.6s + +#15 [migrate] exporting to image +#15 exporting layers 0.2s done +#15 exporting manifest sha256:31fea3178ed4db5e71fcf6539c49c1d989201a9a161da75e6c7cdd462f629b20 0.0s done +#15 exporting config sha256:9f951ee3892d23fe585ad14c06c3d35f7b7ad9c7c1b22f2552f60aa9737267f0 0.1s done +#15 exporting attestation manifest sha256:a9852058a36e506388255dc54e4ed346c65721e78d66eb74902a12a7f2805971 0.1s done +#15 exporting manifest list sha256:7e9d2b8b999e69f985a7f29c0e29d0189287c744dc76e9a2e1d761c4ebba33f2 0.0s done +#15 naming to docker.io/library/mtusi-messenger:lab3 0.0s done +#15 unpacking to docker.io/library/mtusi-messenger:lab3 0.1s done +#15 DONE 0.5s + +#16 [migrate] resolving provenance for metadata file +#16 DONE 0.0s + +#17 [api] resolving provenance for metadata file +#17 DONE 0.0s + Image mtusi-messenger:lab3 Built + Image mtusi-messenger:lab3 Built + Volume mtusi-messenger-lab3-test_pgdata Creating + Network mtusi-messenger-lab3-test_default Creating + Volume mtusi-messenger-lab3-test_pgdata Creating + Network mtusi-messenger-lab3-test_default Creating + Volume mtusi-messenger-lab3-test_redisdata Creating + Volume mtusi-messenger-lab3-test_redisdata Creating + Volume mtusi-messenger-lab3-test_pgdata Created + Volume mtusi-messenger-lab3-test_pgdata Created + Volume mtusi-messenger-lab3-test_redisdata Created + Volume mtusi-messenger-lab3-test_redisdata Created + Network mtusi-messenger-lab3-test_default Created + Network mtusi-messenger-lab3-test_default Created + Container mtusi-messenger-lab3-test-redis-1 Creating + Container mtusi-messenger-lab3-test-postgres-1 Creating + Container mtusi-messenger-lab3-test-redis-1 Created + Container mtusi-messenger-lab3-test-postgres-1 Created + Container mtusi-messenger-lab3-test-migrate-1 Creating + Container mtusi-messenger-lab3-test-migrate-1 Created + Container mtusi-messenger-lab3-test-api-2 Creating + Container mtusi-messenger-lab3-test-api-1 Creating + Container mtusi-messenger-lab3-test-api-1 Created + Container mtusi-messenger-lab3-test-api-2 Created + Container mtusi-messenger-lab3-test-nginx-1 Creating + Container mtusi-messenger-lab3-test-nginx-1 Created + Container mtusi-messenger-lab3-test-redis-1 Starting + Container mtusi-messenger-lab3-test-postgres-1 Starting + Container mtusi-messenger-lab3-test-redis-1 Started + Container mtusi-messenger-lab3-test-postgres-1 Started + Container mtusi-messenger-lab3-test-postgres-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Healthy + Container mtusi-messenger-lab3-test-migrate-1 Starting + Container mtusi-messenger-lab3-test-migrate-1 Started + Container mtusi-messenger-lab3-test-redis-1 Waiting + Container mtusi-messenger-lab3-test-migrate-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Healthy + Container mtusi-messenger-lab3-test-redis-1 Healthy + Container mtusi-messenger-lab3-test-migrate-1 Exited + Container mtusi-messenger-lab3-test-api-2 Starting + Container mtusi-messenger-lab3-test-api-2 Started + Container mtusi-messenger-lab3-test-api-1 Starting + Container mtusi-messenger-lab3-test-api-1 Started + Container mtusi-messenger-lab3-test-api-2 Waiting + Container mtusi-messenger-lab3-test-api-1 Waiting + Container mtusi-messenger-lab3-test-api-2 Healthy + Container mtusi-messenger-lab3-test-api-1 Healthy + Container mtusi-messenger-lab3-test-nginx-1 Starting + Container mtusi-messenger-lab3-test-nginx-1 Started +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env exec -T postgres sh -c 'createdb -U "$POSTGRES_USER" "$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true' +make[1]: Leaving directory '' +make[1]: Entering directory '' +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 DOCKER_TESTS=1 .venv/bin/python -m pytest -q +........................................................................ [ 46%] +........................................................................ [ 92%] +............ [100%] +156 passed in 42.30s +.venv/bin/python tests/smoke.py --base-url "http://localhost:18080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. +.venv/bin/python -m scripts.check_idempotency --base-url "http://localhost:18080" +PASS: 24 concurrent replays, 2 replicas, one message +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 54 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 54 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 48 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp +mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up About a minute (healthy) 127.0.0.1:15432->5432/tcp +mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 6 seconds (healthy) 127.0.0.1:16379->6379/tcp +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 .venv/bin/python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "http://localhost:18080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 11 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 11 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 5 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp +mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up 17 seconds (healthy) 127.0.0.1:15432->5432/tcp +mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 21 seconds (healthy) 127.0.0.1:16379->6379/tcp +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 12 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 12 seconds (healthy) 8080/tcp +mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 5 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp +mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up 17 seconds (healthy) 127.0.0.1:15432->5432/tcp +mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 21 seconds (healthy) 127.0.0.1:16379->6379/tcp +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 .venv/bin/python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "http://localhost:18080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 108, "failed_attempts": 4, "first_recovery_seconds": 1.845} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps -a api +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Exited (0) 13 seconds ago +mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 28 seconds (healthy) 8080/tcp +COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env up -d --wait api + Container mtusi-messenger-lab3-test-api-2 Running + Container mtusi-messenger-lab3-test-postgres-1 Running + Container mtusi-messenger-lab3-test-redis-1 Running + Container mtusi-messenger-lab3-test-postgres-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Healthy + Container mtusi-messenger-lab3-test-migrate-1 Starting + Container mtusi-messenger-lab3-test-migrate-1 Started + Container mtusi-messenger-lab3-test-migrate-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Waiting + Container mtusi-messenger-lab3-test-redis-1 Waiting + Container mtusi-messenger-lab3-test-redis-1 Healthy + Container mtusi-messenger-lab3-test-postgres-1 Healthy + Container mtusi-messenger-lab3-test-migrate-1 Exited + Container mtusi-messenger-lab3-test-api-1 Starting + Container mtusi-messenger-lab3-test-api-1 Started + Container mtusi-messenger-lab3-test-redis-1 Waiting + Container mtusi-messenger-lab3-test-migrate-1 Waiting + Container mtusi-messenger-lab3-test-api-2 Waiting + Container mtusi-messenger-lab3-test-api-1 Waiting + Container mtusi-messenger-lab3-test-postgres-1 Waiting + Container mtusi-messenger-lab3-test-migrate-1 Exited + Container mtusi-messenger-lab3-test-redis-1 Healthy + Container mtusi-messenger-lab3-test-postgres-1 Healthy + Container mtusi-messenger-lab3-test-api-2 Healthy + Container mtusi-messenger-lab3-test-api-1 Healthy +make[1]: Leaving directory '' +PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords +PASS SIGTERM: readiness 503, live 200, new work 503, in-flight POST 201; exit in 2.145s +Сборка нового образа API +Однократное применение совместимых миграций +Заменена реплика 5955785d8b55 +Заменена реплика 23feb43a87e9 +Готово: 2 здоровых реплик нового образа +{"scenario": "rolling update", "replacements": 2, "migration_runs": 1, "successful_writes": 456, "failed_attempts": 13, "errors_by_kind": {"http_503": 13}, "elapsed_seconds": 23.627, "successful_rps": 19.3, "p95_seconds": 0.043} +{"scenario": "replica_failure", "phase": "before", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]} +{"scenario": "replica_failure", "phase": "stopped", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": false, "health": "unhealthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]} +{"scenario": "replica_failure", "phase": "restored", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]} +{"instance": "bcbb50630124", "successful_writes": 773, "failed_attempts": 83, "errors_by_kind": {"http_429": 67, "http_503": 16}, "elapsed_seconds": 13.853, "successful_rps": 55.8, "first_recovery_seconds": 1.8} +{"scenario": "replica_failure", "phase": "before", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]} +{"scenario": "replica_failure", "phase": "stopped", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": false, "health": "unhealthy"}]} +{"scenario": "replica_failure", "phase": "restored", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]} +{"instance": "df18f4fb557f", "successful_writes": 773, "failed_attempts": 116, "errors_by_kind": {"http_429": 99, "http_503": 17}, "elapsed_seconds": 13.875, "successful_rps": 55.71, "first_recovery_seconds": 1.782} +PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords + Container mtusi-messenger-lab3-test-nginx-1 Stopping + Container mtusi-messenger-lab3-test-nginx-1 Stopped + Container mtusi-messenger-lab3-test-nginx-1 Removing + Container mtusi-messenger-lab3-test-nginx-1 Removed + Container mtusi-messenger-lab3-test-api-3 Stopping + Container mtusi-messenger-lab3-test-api-4 Stopping + Container mtusi-messenger-lab3-test-api-3 Stopped + Container mtusi-messenger-lab3-test-api-3 Removing + Container mtusi-messenger-lab3-test-api-3 Removed + Container mtusi-messenger-lab3-test-api-4 Stopped + Container mtusi-messenger-lab3-test-api-4 Removing + Container mtusi-messenger-lab3-test-api-4 Removed + Container mtusi-messenger-lab3-test-redis-1 Stopping + Container mtusi-messenger-lab3-test-migrate-1 Stopping + Container mtusi-messenger-lab3-test-migrate-1 Stopped + Container mtusi-messenger-lab3-test-migrate-1 Removing + Container mtusi-messenger-lab3-test-migrate-1 Removed + Container mtusi-messenger-lab3-test-postgres-1 Stopping + Container mtusi-messenger-lab3-test-redis-1 Stopped + Container mtusi-messenger-lab3-test-redis-1 Removing + Container mtusi-messenger-lab3-test-redis-1 Removed + Container mtusi-messenger-lab3-test-postgres-1 Stopped + Container mtusi-messenger-lab3-test-postgres-1 Removing + Container mtusi-messenger-lab3-test-postgres-1 Removed + Volume mtusi-messenger-lab3-test_redisdata Removing + Volume mtusi-messenger-lab3-test_pgdata Removing + Network mtusi-messenger-lab3-test_default Removing + Volume mtusi-messenger-lab3-test_pgdata Removed + Volume mtusi-messenger-lab3-test_redisdata Removed + Network mtusi-messenger-lab3-test_default Removed diff --git a/infra/README.md b/infra/README.md index 5a39e862..da3c4f95 100644 --- a/infra/README.md +++ b/infra/README.md @@ -1,7 +1,204 @@ -# Инфраструктура студента +# Инфраструктура проекта -Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли. +Топология — [compose.yaml](../compose.yaml) и [тестовый override](../compose.test.yaml). +Запуск и результаты — [REPORT.md](../REPORT.md), объяснение изменений относительно +lab2 и терминов — [EXPLAIN.md](../EXPLAIN.md), ответы для защиты — +[DEFENCE.md](../DEFENCE.md). `compose.example.yaml` остаётся исходным worksheet задания. -В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд. +## Nginx в текущем решении -Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику. +Конфигурация — [nginx/nginx.conf](nginx/nginx.conf), образ — `nginx:1.28.0-alpine` +из `compose.yaml`. Клиент обращается к Nginx, тот распределяет запросы между +репликами `api`; данные и сессии остаются общими в PostgreSQL и Redis. + +| Настройка | Значение и назначение | +| --- | --- | +| DNS | `127.0.0.11`, `valid=5s`, `resolver_timeout=1s`: обновление адресов сервиса `api` без reload Nginx. `resolve` работает с общей зоной `zone api_backend 64k`. | +| Балансировка | Round-robin, без закрепления клиента за репликой. | +| Проверки отказа | Пассивные: `max_fails=1`, `fail_timeout=5s`. Ошибка запроса временно исключает backend; Nginx сам не опрашивает `/health/ready`. | +| Соединения | HTTP/1.1, пустой `Connection`, кэш до 16 свободных соединений на worker с временем простоя до 4 с. Это не ограничитель одновременных запросов. | +| Тайм-ауты к API | Подключение 500 мс; отправка/чтение 10 с между операциями ввода-вывода. | +| Переключение | Не более двух попыток, окно начала следующей попытки 2 с; условия — ошибка соединения, тайм-аут, 502/503/504. Эти 2 с не являются общим ограничением длительности ответа. | +| Ограничение запросов | На IP, видимый Nginx: в среднем 50 запросов/с, `burst=100 nodelay` допускает всплеск без очереди. Состояние общее для worker-процессов одного Nginx; `/health/*` и `/lb-health` не ограничиваются. | +| Превышение лимита | JSON 429 `rate_limited`, `Retry-After: 1`, `X-Request-Id`, совпадающий с `error.request_id`. | +| Нет доступных backend | Собственная ошибка LB — JSON 503 `unavailable`, `Retry-After: 1` и `X-Request-Id`. У ответов LB нет `X-Instance-Id` реплики. | +| Ошибки приложения | JSON и заголовки API передаются без подмены, в том числе собственный 429 приложения. | +| Gzip | Для `application/json` от 1024 байт, уровень 3, при согласии клиента через `Accept-Encoding`; `Vary: Accept-Encoding` различает варианты ответа. Меньше переданных байт ценой вычислений на сжатие; ускорение нужно измерять. | +| Наблюдение | JSON access log в stdout: request id, статус, время, адрес/статус backend, id реплики и результат ограничения. Заголовок авторизации и тела запросов не журналируются; вместо полного URL записывается путь без query string. | + +`non_idempotent` не включён: уже отправленный POST нельзя прозрачно повторять +для входа или создания чата. Повтор сообщения после неопределённого результата +выполняется клиентом с прежним `Idempotency-Key`; ключ и сообщение сохраняются +атомарно в PostgreSQL. Ошибка подключения до отправки допускает другую попытку. + +Лимит Nginx действует по IP, а `MAX_IN_FLIGHT` приложения — по числу одновременных +запросов на реплику. Это разные ограничения. За NAT несколько клиентов могут +получать один бюджет; произвольный `X-Forwarded-For` не меняет ключ лимита. +При исследовании производительности учитывайте ответы 429 и заданный порог; +50 запросов/с — начальная настройка стенда, а не измеренная ёмкость системы. + +Период DNS 5 с и пассивные проверки не задают универсального срока обнаружения +любого отказа. Например, подключение к молчащему адресу ограничено 500 мс, а +зависание уже установленного соединения — тайм-аутом чтения. Время восстановления +нужно измерять для выбранного отказа и нагрузки; проверка через Nginx входит +в `make test-grade4 PYTHON=.venv/bin/python`. + +## Реализация уровня 4 + +Единый прогон: `make test-grade4 PYTHON=.venv/bin/python`. Он проверяет контракт, +pytest, публичные сценарии, SIGTERM, замену образа под записью и отказ каждой +реплики. Тестовый проект и его volumes удаляются при выходе. Выбор pytest: +`PYTEST_ARGS="student-tests/test_sessions.py"`. Реальный вывод и метаданные +сохранены в [evidence/](../evidence/README.md), таблица критериев — в [отчёте](../REPORT.md). + +### Завершение и readiness + +`GracefulServer` в `app/core/lifecycle.py` перехватывает первый SIGTERM/SIGINT: +переводит приложение в drain, ждёт `SHUTDOWN_DRAIN_SECONDS`, затем запускает +штатное завершение Uvicorn. Во время drain `/health/ready` и новые бизнес-запросы +получают 503; ранее принятые запросы продолжаются. `/health/live` остаётся 200. +Повторный сигнал пропускает оставшуюся drain-паузу. +Реализация рассчитана на установленный Uvicorn 0.54.0 и использует его +`Server.handle_exit`; при обновлении зависимости этот интерфейс нужно пересмотреть. + +Профиль по умолчанию: drain 1 с, ожидание текущих запросов 5 с, Docker grace 8 с. +Настройки приложения требуют `drain + graceful < 8`. В прежнем `.env` следует +изменить `SHUTDOWN_DRAIN_SECONDS=0` на `1`, если он был скопирован из старого примера. +Команда остановки одной реплики использует такой же предел 8 с; требование +публичного hook завершиться за 10 с учитывается отдельно при последующей проверке. + +Readiness одновременно проверяет PostgreSQL и Redis с общим бюджетом 2 с. +Python healthcheck ждёт до 2,5 с, Docker — до 3 с; проверки API выполняются каждые +3 с с двумя неудачами для unhealthy и стартовым периодом 10 с. После выхода из +стартового периода консервативная оценка перехода healthy → unhealthy составляет +`2 × (3 + 3) = 12 с`. Nginx не использует этот статус для маршрутизации: он исключает +backend по собственным пассивным проверкам. Для отказа установления соединения +тайм-аут одной попытки — 500 мс, для зависания чтения — 10 с между порциями данных. +Эти границы относятся к разным отказам, а не к единому времени восстановления. + +### Ресурсы + +| Контейнер | CPU | RAM | +| --- | --- | --- | +| postgres | 1 | 512 MiB | +| redis | 0,5 | 512 MiB | +| api, каждая реплика | 1 | 512 MiB | +| migrate | 0,5 | 256 MiB | +| nginx | 0,5 | 128 MiB | + +У Nginx два worker-процесса. Пул вычисления Argon2 ограничен двумя задачами, чтобы +параллельный вход не расходовал память пропорционально числу CPU Docker-host. +Во время обновления временно работает `N + 1` API-реплик; необходимы свободные +ресурсы и запас соединений PostgreSQL. При стандартных пулах две реплики дают +до 30 соединений, три — до 45, не считая миграций и диагностики. + +### Секреты + +Перед первым запуском нового профиля: + +```sh +make prepare-secrets PYTHON=.venv/bin/python +``` + +Скрипт создаёт отсутствующие `secrets/db_password` и `secrets/redis_password`. +Прежние значения из локального `.env` сохраняются; если их нет, генерируются +случайные пароли. Существующие секреты не перезаписываются, значения не выводятся. +Это не ротация пароля уже созданной БД. Каталог исключён из Git. + +Compose монтирует файлы в `/run/secrets/`. PostgreSQL получает только пароль БД, +Redis — только свой пароль, API — оба, миграции — только пароль БД, Nginx — ни одного. +Все переменные Compose обязательны: значения задаются в `.env`, подстановок +по умолчанию нет; отсутствующая переменная останавливает запуск. Новые ключи +сверяйте с `.env.example`. Контейнерам передаются перечисленные несекретные настройки, весь `.env` +через `env_file` больше не передаётся. Порядок настроек приложения: явные параметры, +файлы секретов, окружение, локальный `.env`. На хосте также поддерживается `secrets/`. +В контейнерах API внутренний порт фиксирован на 8080, идентификатор берётся из +собственного HOSTNAME; общий `INSTANCE_ID` всем репликам из `.env` не передаётся. + +Каталог создаётся с правами 0700, файлы — 0444: Compose использует bind-mount +файлов, и их должны читать UID приложения и служебные UID PostgreSQL/Redis. +Доступ других пользователей хоста ограничивает родительский каталог. Существующие +файлы также получают этот режим. Пароли не должны содержать крайние пробелы или +переносы строк. Локальные тесты Make читают те же файлы, сохраняя fallback старого `.env`. + +Redis запускается через `infra/redis/start-redis.sh`: SHA-256 пароля записывается +во временный ACL-файл с правами 0600 для пользователя redis. В аргументах процесса +и конфигурации окружения контейнера пароль отсутствует. Healthcheck читает файл +только для вызова `redis-cli`. Настройка ACL совместима с Redis 7.4. + +### Обновление и сценарии отказа + +Первый переход со старого образа уровня 3 на файловые секреты выполняется через +`make up` с допустимым окном обслуживания: старый образ не умеет читать секреты +нового профиля и не годится для автоматического отката. После перехода образы +маркируются `io.mtusi.messenger.secrets=file-v1`. + +```sh +make rolling-update PYTHON=.venv/bin/python +make failover-all PYTHON=.venv/bin/python +``` + +Rolling update собирает API один раз, однократно применяет миграции, затем +для каждой старой реплики добавляет одну новую, ждёт healthy и наблюдения её ID +через Nginx, останавливает и удаляет старую. Число реплик возвращается к исходному. +При неизменившемся образе замена пропускается. При неудаче сценарий пытается +восстановить исходный образ через пересоздание API без отката БД; аварийный откат +может вызвать перерыв. Неиспользуемый прежний образ удаляется после успеха, если +у него нет других тегов и контейнеров. + +Миграции при работающих старых репликах должны только расширять схему. Текущие +миграции добавляют таблицы и совместимы с прежним API; удаление или переименование +используемых полей требует отдельного перехода. Совместимость произвольной будущей +миграции сценарий автоматически не доказывает. Откат образа не отменяет миграцию. + +`failover-all` проверяет каждую реплику под записью: +останавливает одну выбранную API, сохраняет ключ при неопределённом POST, +восстанавливает её до следующей, проверяет подтверждённые сообщения и выводит +RPS, ошибки и время восстановления в stdout. По умолчанию два клиента, 2 с прогрева +и 15 с после остановки. Лимит Nginx 50 запросов/с влияет на профиль нагрузки. +После ошибок применяется пауза 100 мс; нагрузка использует закрытый цикл и не +является доказательством максимальной пропускной способности. Для обычного профиля +срок сессии должен быть не менее 300 с. Результаты в файлы не записываются. + +Оба сценария используют общую блокировку проекта, чтобы не выполняться одновременно. +Ручные команды изменения Docker/Compose во время сценария выполнять не следует. +Интеграционная проверка обновления меняет метку `API_BUILD_REVISION`, получая +другой ID образа без изменения бизнес-кода, и проверяет замену обоих контейнеров, +наличие здоровых реплик перед остановкой, однократный запуск миграций и сохранность +записей. Это проверка механизма обновления; произвольные будущие изменения API +и схемы требуют собственных проверок совместимости. Для повторения только +обновления и отказов на готовом тестовом проекте используется +`python -m scripts.check_grade4 --base-url http://localhost:18080 --phase update-and-failover` +с теми же `COMPOSE_FILE` и `COMPOSE_PROJECT_NAME`, что у тестового стенда. + +Конкурентный сценарий сообщений использует локальный `tests/client.py`, а не +внешний пакет `client`. Запуск из корня — `python -m scripts.check_idempotency` +с параметром `--base-url`; цель Make уже использует этот способ запуска. + +## Проверка Nginx без данных мессенджера + +```sh +make test-nginx PYTHON=.venv/bin/python +``` + +Нужны Docker Compose и локальный образ `nginx:1.28.0-alpine`. Скрипт +`scripts/check_nginx.py` создаёт отдельный проект с уникальным именем, случайным +локальным портом и тестовыми HTTP-backend на том же образе; `.env` приложения, +PostgreSQL и Redis не используются. Образы автоматически не скачиваются. +Тестовые контейнеры и сеть удаляются в конце, volumes не создаются. + +Проверяются `nginx -t`, две реплики и добавление третьей через DNS без reload, +gzip с проверкой исходных байт, лимит 429 и исключение health, передача ошибки API, +отсутствие повторной отправки POST, чтение после остановки backend, JSON 503 при +отказе всех backend и формат access log. Сценарий не доказывает сохранность +сообщений, общую идемпотентность и мягкое завершение реального API — для них нужны +публичные и собственные проверки приложения. + +Для уже запущенного основного стенда синтаксис можно проверить командой +`docker compose --env-file .env exec -T nginx nginx -t`; после проверки изменение +применяется через `docker compose --env-file .env exec -T nginx nginx -s reload`. + +Источники директив: [upstream/DNS](https://nginx.org/en/docs/http/ngx_http_upstream_module.html), +[proxy/timeouts/retry](https://nginx.org/en/docs/http/ngx_http_proxy_module.html), +[limit_req](https://nginx.org/en/docs/http/ngx_http_limit_req_module.html), +[gzip](https://nginx.org/en/docs/http/ngx_http_gzip_module.html). diff --git a/infra/nginx/nginx.conf b/infra/nginx/nginx.conf index bc967757..06ede815 100644 --- a/infra/nginx/nginx.conf +++ b/infra/nginx/nginx.conf @@ -1,34 +1,85 @@ -# nginx как единая точка входа перед репликами api. -# Сейчас — минимальный рабочий round-robin; доработки помечены TODO. +# Единая точка входа: round-robin между API-репликами, без sticky sessions. +# Директивы рассчитаны на закреплённый nginx:1.28.0-alpine. -worker_processes auto; +worker_processes 2; events { worker_connections 1024; } http { - access_log /dev/stdout; - error_log /dev/stderr warn; + # В логе используем request_id ответа API, для собственных ошибок — id nginx. + map $upstream_http_x_request_id $response_request_id { + "" $request_id; + default $upstream_http_x_request_id; + } - # TODO(3.3): DNS-обновление адресов backend. - # Сейчас `server api:8080` резолвится ОДИН раз при старте nginx: если - # реплику пересоздали с новым IP или увеличили число реплик, nginx об этом - # не узнает. Варианты: - # resolver 127.0.0.11 valid=5s ipv6=off; # встроенный DNS Docker - # upstream api_backend { zone api_backend 64k; server api:8080 resolve; } - # (параметр `resolve` в open-source nginx доступен с 1.27.3). + log_format requests escape=json + '{"time":"$time_iso8601","request_id":"$response_request_id",' + '"method":"$request_method","uri":"$uri","status":$status,' + '"bytes":$body_bytes_sent,"request_time":$request_time,' + '"upstream":"$upstream_addr","upstream_status":"$upstream_status",' + '"upstream_time":"$upstream_response_time",' + '"instance_id":"$upstream_http_x_instance_id",' + '"limit_status":"$limit_req_status"}'; + + access_log /dev/stdout requests; + error_log /dev/stderr warn; + server_tokens off; + + # DNS Docker возвращает адреса всех реплик сервиса api. + resolver 127.0.0.11 valid=5s ipv6=off; + resolver_timeout 1s; + + # Общий для worker-процессов лимит на IP, который видит nginx. + # Клиентский X-Forwarded-For не используется в качестве ключа лимита. + limit_req_zone $binary_remote_addr zone=per_client:10m rate=50r/s; + + gzip on; + gzip_vary on; + gzip_min_length 1024; + gzip_comp_level 3; + gzip_types application/json; upstream api_backend { - server api:8080; - # TODO(4.1): пассивные проверки: max_fails=... fail_timeout=... - # (активных health checks в open-source nginx нет — это nginx Plus). - # TODO(4.1): keepalive N; + proxy_http_version 1.1 и пустой Connection. + zone api_backend 64k; + server api:8080 resolve max_fails=1 fail_timeout=5s; + + # Кэш свободных соединений на worker, а не лимит запросов к API. + keepalive 16; + keepalive_timeout 4s; } server { listen 8080; + client_header_timeout 10s; + client_body_timeout 10s; + send_timeout 10s; + keepalive_timeout 30s; + + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + proxy_connect_timeout 500ms; + proxy_send_timeout 10s; + proxy_read_timeout 10s; + + # Пассивное обнаружение отказов; Docker healthcheck сам не управляет LB. + # non_idempotent не включён: уже отправленные POST не повторяем. + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + # Окно перехода на другой backend, не общий deadline ответа. + proxy_next_upstream_timeout 2s; + + # JSON и заголовки ошибок API передаются без подмены. + proxy_intercept_errors off; + error_page 429 = @rate_limited; + error_page 502 503 504 = @unavailable; + # Проверка самого LB для healthcheck в compose; не проксируется в API. location = /lb-health { access_log off; @@ -36,20 +87,31 @@ http { return 200 "ok\n"; } - location / { + # Проверки готовности/жизни не расходуют бюджет бизнес-запросов. + location /health/ { proxy_pass http://api_backend; - proxy_set_header Host $host; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + } - # TODO(4.1): таймауты, согласованные с API и тестами: - # proxy_connect_timeout ...; proxy_send_timeout ...; proxy_read_timeout ...; - # TODO(4.1): переключение на другой backend при отказе: - # proxy_next_upstream error timeout http_502 http_503 ...; - # proxy_next_upstream_tries ...; proxy_next_upstream_timeout ...; - # Внимание: POST nginx по умолчанию НЕ повторяет после отправки - # запроса (non_idempotent). Подумайте, безопасно ли добавлять - # non_idempotent при наличии Idempotency-Key. - # Не используйте ip_hash/sticky как "лечение" раздельного состояния. + location / { + limit_req zone=per_client burst=100 nodelay; + limit_req_status 429; + limit_req_log_level warn; + proxy_pass http://api_backend; + } + + # Это ответы балансировщика: X-Instance-Id реплики у них отсутствует. + location @rate_limited { + default_type application/json; + add_header X-Request-Id $request_id always; + add_header Retry-After 1 always; + return 429 '{"error":{"code":"rate_limited","message":"Request rate exceeded","request_id":"$request_id"}}'; + } + + location @unavailable { + default_type application/json; + add_header X-Request-Id $request_id always; + add_header Retry-After 1 always; + return 503 '{"error":{"code":"unavailable","message":"API temporarily unavailable","request_id":"$request_id"}}'; } } } diff --git a/infra/redis/start-redis.sh b/infra/redis/start-redis.sh new file mode 100644 index 00000000..49ee706b --- /dev/null +++ b/infra/redis/start-redis.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu + +password_hash=$(tr -d '\r\n' /run/redis/users.acl +chown redis:redis /run/redis/users.acl +chmod 600 /run/redis/users.acl +exec /usr/local/bin/docker-entrypoint.sh redis-server /usr/local/etc/redis/redis.conf --aclfile /run/redis/users.acl diff --git a/migrations/versions/49d2c947a3f1_add_idempotency_keys.py b/migrations/versions/49d2c947a3f1_add_idempotency_keys.py new file mode 100644 index 00000000..ea3c65fc --- /dev/null +++ b/migrations/versions/49d2c947a3f1_add_idempotency_keys.py @@ -0,0 +1,43 @@ +"""Добавляет результаты идемпотентных запросов.""" + +from alembic import op +import sqlalchemy as sa + +revision = "49d2c947a3f1" +down_revision = "abd273076068" +branch_labels = None +depends_on = None + + +def upgrade() -> None: + """Создаёт таблицу ключей без изменения существующих данных.""" + op.create_table( + "idempotency_keys", + sa.Column("user_id", sa.UUID(), nullable=False), + sa.Column("method", sa.String(8), nullable=False), + sa.Column("path", sa.String(255), nullable=False), + sa.Column("key", sa.String(128), nullable=False), + sa.Column("request_hash", sa.String(64), nullable=False), + sa.Column("message_id", sa.UUID(), nullable=False), + sa.Column( + "created_at", sa.DateTime(timezone=True), + server_default=sa.text("clock_timestamp()"), nullable=False, + ), + sa.ForeignKeyConstraint( + ["user_id"], ["users.id"], name=op.f("fk_idempotency_keys_user_id_users") + ), + sa.ForeignKeyConstraint( + ["message_id"], ["messages.id"], + name=op.f("fk_idempotency_keys_message_id_messages"), + ), + sa.PrimaryKeyConstraint( + "user_id", "method", "path", "key", name=op.f("pk_idempotency_keys") + ), + ) + op.create_index("ix_idempotency_keys_created_at", "idempotency_keys", ["created_at"]) + + +def downgrade() -> None: + """Удаляет таблицу результатов запросов.""" + op.drop_index("ix_idempotency_keys_created_at", table_name="idempotency_keys") + op.drop_table("idempotency_keys") diff --git a/scripts/__init__.py b/scripts/__init__.py new file mode 100644 index 00000000..592ea408 --- /dev/null +++ b/scripts/__init__.py @@ -0,0 +1 @@ +"""Команды управления учебным стендом.""" diff --git a/scripts/check_grade4.py b/scripts/check_grade4.py new file mode 100644 index 00000000..8cae8723 --- /dev/null +++ b/scripts/check_grade4.py @@ -0,0 +1,348 @@ +"""Проверяет инфраструктуру, SIGTERM и обновление реального стенда.""" + +import asyncio +from collections import Counter +from concurrent.futures import ThreadPoolExecutor +import hashlib +import json +from pathlib import Path +import subprocess +from threading import Event +import time +from uuid import uuid4 + +import asyncpg + +from scripts.deployment import ComposeProject, ROOT, deployment_lock +from scripts.failover_all import exercise, failure_kind, history +from scripts.rolling_update import update +from tests.client import Client, Failure, arguments, check, run + +PROBE = """import json, sys, urllib.request, urllib.error +payload = json.load(sys.stdin) +results = [] +for item in payload: + data = json.dumps(item['body']).encode() if 'body' in item else None + request = urllib.request.Request(item['url'], data=data, headers=item.get('headers', {}), method=item.get('method', 'GET')) + try: + response = urllib.request.urlopen(request, timeout=7) + except urllib.error.HTTPError as error: + response = error + with response: + results.append({'status': response.status, 'body': json.loads(response.read())}) +print(json.dumps(results)) +""" + + +def probe(project, runner, requests): + """Обращается к внутреннему API, передавая токен только через stdin.""" + result = subprocess.run( + ["docker", "exec", "-i", runner, "python", "-c", PROBE], + input=json.dumps(requests), + text=True, + capture_output=True, + timeout=10, + ) + check(result.returncode == 0, "internal HTTP probe failed") + return json.loads(result.stdout) + + +def audit(project): + """Проверяет фактические лимиты, порты и область доступа к секретам.""" + allowed = { + "postgres": {"db_password"}, + "redis": {"redis_password"}, + "migrate": {"db_password"}, + "api": {"db_password", "redis_password"}, + "nginx": set(), + } + ids = project.run("ps", "--all", "--quiet").splitlines() + containers = json.loads(project.docker("inspect", *ids)) + for item in containers: + service = item["Config"]["Labels"]["com.docker.compose.service"] + check(service in allowed, "unexpected service") + host = item["HostConfig"] + check( + host["Memory"] > 0 and host["NanoCpus"] > 0, + service + ": missing CPU/RAM limit", + ) + env_names = {entry.split("=", 1)[0] for entry in item["Config"]["Env"]} + check( + not env_names + & { + "DB_PASSWORD", + "REDIS_PASSWORD", + "POSTGRES_PASSWORD", + "REDISCLI_AUTH", + "DATABASE_URL", + }, + service + ": password in environment", + ) + secrets = { + Path(mount["Destination"]).name + for mount in item["Mounts"] + if mount["Destination"].startswith("/run/secrets/") + } + check(secrets == allowed[service], service + ": incorrect secret scope") + if service == "api": + check(not host["PortBindings"], "API publishes ports") + for mount in item["Mounts"]: + if mount["Destination"].startswith("/run/secrets/"): + check(not mount["RW"], "writable secret mount") + check( + "container_name" not in project.config["services"][service], + "fixed container name", + ) + check( + len(containers) == 6, + "expected PostgreSQL, Redis, migrate, Nginx and two API replicas", + ) + print( + "PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords", + flush=True, + ) + + +async def graceful(project, base_url): + """Удерживает реальный POST в БД и завершает его после SIGTERM.""" + replicas = project.replicas() + target, runner = replicas[:2] + client = Client(base_url) + actor, _, _, chat = await asyncio.to_thread(client.bootstrap) + path = f"/api/v1/chats/{chat['id']}/messages" + key = uuid4().hex + raw = json.dumps([actor["id"], "POST", path, key]).encode() + lock_id = int.from_bytes(hashlib.sha256(raw).digest()[:8], signed=True) + database = project.config["services"]["postgres"] + env = database["environment"] + conn = await asyncpg.connect( + host="127.0.0.1", + port=int(database["ports"][0]["published"]), + database=env["POSTGRES_DB"], + user=env["POSTGRES_USER"], + password=(ROOT / "secrets/db_password").read_text().strip(), + timeout=3, + ) + address = project.docker( + "inspect", + "--format", + "{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}", + target.id, + ) + port = project.config["services"]["api"]["environment"]["APP_PORT"] + direct = f"http://{address}:{port}" + started = time.monotonic() + task = None + try: + async with conn.transaction(): + await conn.execute("SELECT pg_advisory_xact_lock($1)", lock_id) + task = asyncio.create_task( + asyncio.to_thread( + probe, + project, + runner.id, + [ + { + "url": direct + path, + "method": "POST", + "body": {"text": "graceful-" + key}, + "headers": { + "Authorization": "Bearer " + actor["token"], + "Idempotency-Key": key, + "Content-Type": "application/json", + }, + } + ], + ) + ) + deadline = time.monotonic() + 3 + while not await conn.fetchval( + "SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE wait_event = 'advisory' AND datname = current_database())" + ): + check(time.monotonic() < deadline, "POST did not reach database lock") + await asyncio.sleep(0.02) + started = time.monotonic() + await asyncio.to_thread( + project.docker, "kill", "--signal", "SIGTERM", target.id + ) + results = await asyncio.to_thread( + probe, + project, + runner.id, + [ + {"url": direct + "/health/ready"}, + {"url": direct + "/health/live"}, + {"url": direct + "/api/v1/users/me"}, + ], + ) + check( + [item["status"] for item in results] == [503, 200, 503], + "incorrect drain readiness/liveness/new work", + ) + await asyncio.sleep(max(0, 1.2 - (time.monotonic() - started))) + result = (await task)[0] + check(result["status"] == 201, "in-flight POST failed during SIGTERM") + await asyncio.to_thread(project.docker, "wait", target.id, timeout=10) + state = json.loads( + project.docker("inspect", "--format", "{{json .State}}", target.id) + ) + check( + not state["OOMKilled"] and state["ExitCode"] != 137, + "forced shutdown instead of graceful completion", + ) + check(time.monotonic() - started < 8, "shutdown exceeded Docker grace budget") + items = await asyncio.to_thread(history, client, actor, chat) + check( + result["body"]["id"] in {item["id"] for item in items}, + "acknowledged in-flight message lost", + ) + print( + f"PASS SIGTERM: readiness 503, live 200, new work 503, in-flight POST 201; exit in {time.monotonic() - started:.3f}s", + flush=True, + ) + finally: + await conn.close() + if task: + await asyncio.gather(task, return_exceptions=True) + if any(item.id == target.id and item.running for item in project.replicas()): + await asyncio.to_thread(project.docker, "stop", target.id) + await asyncio.to_thread(project.docker, "start", target.id) + await asyncio.to_thread(project.wait_healthy, {item.id for item in replicas}) + await asyncio.to_thread(project.wait_routed, target.instance_id, base_url) + + +class ObservedProject(ComposeProject): + """Подсчитывает миграции и проверяет готовность перед заменой.""" + + def __init__(self): + self.migrations = 0 + self.replacements = 0 + self.replacement_started = [] + super().__init__() + + def run(self, *args, **kwargs): + if args[:6] == ("run", "--rm", "--no-deps", "--pull", "never", "migrate"): + self.migrations += 1 + return super().run(*args, **kwargs) + + def docker(self, *args, **kwargs): + if args[0] == "stop": + healthy = [ + item + for item in self.replicas() + if item.id != args[1] and item.running and item.health == "healthy" + ] + check(len(healthy) >= 2, "rolling update reduces healthy capacity") + self.replacements += 1 + self.replacement_started.append(time.monotonic()) + return super().docker(*args, **kwargs) + + +def rolling(base_url): + """Заменяет образ под постоянной записью с проверкой сохранности.""" + project = ObservedProject() + before = project.replicas() + client = Client(base_url) + actor, _, _, chat = client.bootstrap() + stop = Event() + results, errors = [], [] + + def worker(): + local = Client(base_url, timeout=2) + key = uuid4().hex + while not stop.is_set(): + started = time.monotonic() + try: + result = local.message(actor, chat, "rolling-" + key, key=key) + results.append( + (started, time.monotonic(), result["json"]["id"], result["elapsed"]) + ) + key = uuid4().hex + except Failure as error: + errors.append(failure_kind(error)) + stop.wait(0.08) + + with ThreadPoolExecutor(max_workers=2) as pool: + jobs = [pool.submit(worker) for _ in range(2)] + try: + time.sleep(1) + started = time.monotonic() + update(project, base_url, revision="verification-" + uuid4().hex[:12]) + finished = time.monotonic() + time.sleep(1) + finally: + stop.set() + for job in jobs: + job.result(timeout=5) + after = project.replicas() + check( + project.migrations == 1 and project.replacements == len(before), + "migration/replacement count incorrect", + ) + check( + {item.image for item in before}.isdisjoint({item.image for item in after}), + "new image was not deployed", + ) + check( + {item.id for item in before}.isdisjoint({item.id for item in after}), + "old containers remain", + ) + writes = [row for row in results if started <= row[0] <= finished] + check(bool(writes), "no writes during update") + check( + any(project.replacement_started[0] <= row[0] <= finished for row in writes), + "no writes during container replacement", + ) + items = history(client, actor, chat) + check( + {row[2] for row in results} <= {item["id"] for item in items}, + "rolling update lost confirmed messages", + ) + check( + len(items) == len({item["text"] for item in items}), + "rolling update created duplicate messages", + ) + latencies = sorted(row[3] for row in writes) + print( + json.dumps( + { + "scenario": "rolling update", + "replacements": project.replacements, + "migration_runs": project.migrations, + "successful_writes": len(writes), + "failed_attempts": len(errors), + "errors_by_kind": dict(Counter(errors)), + "elapsed_seconds": round(finished - started, 3), + "successful_rps": round(len(writes) / (finished - started), 3), + "p95_seconds": round( + latencies[min(len(latencies) - 1, int(len(latencies) * 0.95))], 3 + ), + } + ), + flush=True, + ) + + +def main(): + """Выполняет проверки только на отдельном тестовом проекте.""" + + def configure(parser): + parser.add_argument( + "--phase", choices=("all", "update-and-failover"), default="all" + ) + + args = arguments("Grade 4 integration checks", configure) + project = ComposeProject() + check(project.name.endswith("-test"), "use isolated test Compose project") + with deployment_lock(project): + audit(project) + if args.phase == "all": + asyncio.run(graceful(project, args.base_url)) + rolling(args.base_url) + args.duration, args.concurrency = 10, 2 + exercise(project, args) + audit(project) + + +if __name__ == "__main__": + run(main) diff --git a/scripts/check_idempotency.py b/scripts/check_idempotency.py new file mode 100644 index 00000000..ae9dfa20 --- /dev/null +++ b/scripts/check_idempotency.py @@ -0,0 +1,39 @@ +"""Проверяет конкурентные повторы через балансировщик.""" + +from concurrent.futures import ThreadPoolExecutor +from uuid import uuid4 + +from tests.client import Client, arguments, check, run + + +def main() -> None: + """Отправляет один ключ параллельно через разные реплики.""" + args = arguments("Concurrent idempotency through load balancer") + client = Client(args.base_url, args.ca_file) + alice, _, _, chat = client.bootstrap() + key = uuid4().hex + body = "parallel-" + key + + def send(_): + return Client(args.base_url, args.ca_file).message(alice, chat, body, key=key) + + with ThreadPoolExecutor(max_workers=8) as pool: + results = list(pool.map(send, range(24))) + ids = {result["json"]["id"] for result in results} + replicas = {result["headers"]["X-Instance-Id"] for result in results} + check(len(ids) == 1, "parallel retries created duplicate messages") + check(len(replicas) >= 2, "parallel retries did not reach two API replicas") + history = client.call( + "GET", + f"/api/v1/chats/{chat['id']}/messages?limit=100", + actor=alice, + schema="MessagePage", + )["json"]["items"] + check( + len(history) == 1 and history[0] == results[0]["json"], "history has duplicates" + ) + print(f"PASS: 24 concurrent replays, {len(replicas)} replicas, one message") + + +if __name__ == "__main__": + run(main) diff --git a/scripts/check_nginx.py b/scripts/check_nginx.py new file mode 100644 index 00000000..e4881fc5 --- /dev/null +++ b/scripts/check_nginx.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Проверки реального nginx в отдельном Compose-проекте без БД и приложения.""" + +from concurrent.futures import ThreadPoolExecutor +import gzip +import json +from pathlib import Path +import subprocess +import tempfile +import time +from urllib.error import HTTPError, URLError +from urllib.request import Request, urlopen +from uuid import uuid4 + +ROOT = Path(__file__).resolve().parents[1] +IMAGE = "nginx:1.28.0-alpine" +PAYLOAD = json.dumps({"text": "message " * 256}).encode() + + +def check(condition: bool, message: str) -> None: + if not condition: + raise AssertionError(message) + + +class Stand: + def __init__(self, directory: str) -> None: + self.directory = Path(directory) + self.project = "mtusi-lab3-nginx-check-" + uuid4().hex[:12] + self.base_url = "" + backend = self.directory / "backend.conf" + backend.write_text( + "worker_processes 1;\n" + "events { worker_connections 1024; }\n" + "http {\n" + " log_format backend 'BACKEND $request_method $uri';\n" + " access_log /dev/stdout backend;\n" + " server {\n" + " listen 8080;\n" + " default_type application/json;\n" + " add_header X-Instance-Id $hostname always;\n" + " add_header X-Request-Id $request_id always;\n" + " add_header Retry-After 7 always;\n" + ' location /health/ { return 200 \'{"status":"ok"}\'; }\n' + " location = /api/limited {\n" + ' return 429 \'{"error":{"code":"rate_limited",' + '"message":"upstream limit","request_id":"$request_id"}}\';\n' + " }\n" + " location = /api/post-failure {\n" + ' return 503 \'{"error":{"code":"unavailable",' + '"message":"upstream failure","request_id":"$request_id"}}\';\n' + " }\n" + " location / { return 200 '" + PAYLOAD.decode() + "'; }\n" + " }\n" + "}\n" + ) + self.compose_file = self.directory / "compose.json" + self.compose_file.write_text( + json.dumps( + { + "services": { + "api": { + "image": IMAGE, + "volumes": [f"{backend}:/etc/nginx/nginx.conf:ro"], + }, + "nginx": { + "image": IMAGE, + "volumes": [ + f"{ROOT / 'infra/nginx/nginx.conf'}:/etc/nginx/nginx.conf:ro" + ], + "ports": ["127.0.0.1::8080"], + }, + } + } + ) + ) + + def compose(self, *args: str) -> str: + # Явный файл, уникальный проект и пустой env-file исключают основной стенд. + result = subprocess.run( + [ + "docker", + "compose", + "--env-file", + "/dev/null", + "-f", + str(self.compose_file), + "-p", + self.project, + *args, + ], + cwd=self.directory, + capture_output=True, + text=True, + timeout=45, + ) + if result.returncode: + raise RuntimeError(result.stdout + result.stderr) + return result.stdout + result.stderr + + def call(self, path: str, *, method: str = "GET", encoding: str = "identity"): + request = Request( + self.base_url + path, + method=method, + headers={"Accept-Encoding": encoding}, + data=b"{}" if method == "POST" else None, + ) + try: + response = urlopen(request, timeout=3) + except HTTPError as error: + response = error + except (URLError, TimeoutError): + return 0, {}, b"" + with response: + return ( + response.status, + {key.lower(): value for key, value in response.headers.items()}, + response.read(), + ) + + def wait_instances(self, count: int) -> set[str]: + seen: set[str] = set() + deadline = time.monotonic() + 15 + while time.monotonic() < deadline: + status, headers, _ = self.call("/health/live") + if status == 200: + seen.add(headers["x-instance-id"]) + if len(seen) == count: + return seen + time.sleep(0.05) + raise AssertionError(f"Ожидалось {count} реплик, наблюдалось {len(seen)}") + + +def check_error(response, status: int, code: str) -> None: + actual_status, headers, body = response + check(actual_status == status, f"Ожидался HTTP {status}, получен {actual_status}") + check( + headers.get("content-type", "").startswith("application/json"), "Ошибка не JSON" + ) + error = json.loads(body)["error"] + check(error["code"] == code, "Неверный код ошибки") + check(error["request_id"] == headers.get("x-request-id"), "request_id не совпадает") + + +def run_checks(stand: Stand) -> None: + stand.compose("up", "-d", "--pull", "never", "--scale", "api=2", "api", "nginx") + address = stand.compose("port", "nginx", "8080").strip() + stand.base_url = "http://" + address + stand.wait_instances(2) + print(stand.compose("exec", "-T", "nginx", "nginx", "-v").strip()) + stand.compose("exec", "-T", "nginx", "nginx", "-t") + print("PASS: nginx -t и балансировка двух реплик") + + status, headers, body = stand.call("/api/large", encoding="gzip") + check( + status == 200 and headers.get("content-encoding") == "gzip", "Нет gzip для JSON" + ) + check(gzip.decompress(body) == PAYLOAD, "gzip изменил содержимое") + check(len(body) < len(PAYLOAD), "gzip не уменьшил тестовый ответ") + check( + "accept-encoding" in headers.get("vary", "").lower(), + "Нет Vary: Accept-Encoding", + ) + check(stand.call("/api/large")[2] == PAYLOAD, "Ответ без gzip изменён") + small = stand.call("/health/live", encoding="gzip") + check( + small[0] == 200 and "content-encoding" not in small[1], "Маленький ответ сжат" + ) + print(f"PASS: gzip {len(PAYLOAD)} → {len(body)} байт, содержимое сохранено") + + limited = stand.call("/api/limited") + check_error(limited, 429, "rate_limited") + check(limited[1].get("retry-after") == "7", "Подменён Retry-After приложения") + check("x-instance-id" in limited[1], "Потерян id backend на ошибке API") + print("PASS: JSON и заголовки ошибки API передаются без подмены") + + failure = stand.call("/api/post-failure", method="POST") + check_error(failure, 503, "unavailable") + backend_logs = stand.compose("logs", "--no-color", "--no-log-prefix", "api") + check(backend_logs.count("BACKEND POST /api/post-failure") == 1, "POST повторился") + print("PASS: отправленный POST не повторяется на другой реплике") + + with ThreadPoolExecutor(max_workers=32) as pool: + responses = list(pool.map(lambda _: stand.call("/api/large"), range(500))) + rejected = [response for response in responses if response[0] == 429] + check(bool(rejected), "Не удалось вызвать ограничение частоты") + check( + all(response[0] in (200, 429) for response in responses), "Ошибка при нагрузке" + ) + for response in rejected: + check_error(response, 429, "rate_limited") + check(response[1].get("retry-after") == "1", "Нет Retry-After балансировщика") + check("x-instance-id" not in response[1], "LB выдал себя за API-реплику") + with ThreadPoolExecutor(max_workers=16) as pool: + health = list(pool.map(lambda _: stand.call("/health/ready"), range(100))) + check(all(response[0] == 200 for response in health), "Лимит затронул health") + check(stand.call("/lb-health")[0] == 200, "Проверка LB недоступна") + print(f"PASS: лимит вернул {len(rejected)} ответов 429; health доступен") + + stand.compose( + "up", "-d", "--pull", "never", "--scale", "api=3", "--no-recreate", "api" + ) + instances = stand.wait_instances(3) + print("PASS: третья реплика обнаружена через DNS без reload nginx") + + target = sorted(instances)[0] + containers = stand.compose("ps", "-q", "api").splitlines() + matching = [container for container in containers if container.startswith(target)] + check(len(matching) == 1, "Не найдена тестовая реплика для остановки") + # Все id взяты только из уникального временного Compose-проекта. + started = time.monotonic() + subprocess.run( + ["docker", "stop", "--time", "1", matching[0]], check=True, capture_output=True + ) + recovery = None + for _ in range(20): + status, headers, _ = stand.call("/health/live") + if status == 200: + check(headers["x-instance-id"] != target, "Остановленная реплика отвечает") + if recovery is None: + recovery = time.monotonic() - started + check(recovery is not None and recovery < 10, "Чтение не восстановилось за 10 с") + print(f"PASS: отказ реплики, первое успешное чтение через {recovery:.3f} с") + + stand.compose("stop", "--timeout", "1", "api") + unavailable = stand.call("/health/ready") + check_error(unavailable, 503, "unavailable") + check( + unavailable[1].get("retry-after") == "1", "Нет Retry-After при отказе всех API" + ) + check("x-instance-id" not in unavailable[1], "У ошибки LB есть id реплики") + check(stand.call("/lb-health")[0] == 200, "Отказ API сломал проверку самого LB") + print("PASS: недоступность всех backend возвращает JSON 503") + + logs = stand.compose("logs", "--no-color", "--no-log-prefix", "nginx") + entries = [json.loads(line) for line in logs.splitlines() if line.startswith("{")] + check(bool(entries), "Нет JSON access log") + check( + all("request_id" in entry and "upstream_time" in entry for entry in entries), + "Неполный лог", + ) + check( + any(entry["limit_status"] == "REJECTED" for entry in entries), + "Лимит не отражён в логе", + ) + print("PASS: JSON access log содержит время backend и результат лимита") + + +def main() -> None: + with tempfile.TemporaryDirectory(prefix="mtusi-lab3-nginx-check-") as directory: + stand = Stand(directory) + try: + run_checks(stand) + except Exception: + print(stand.compose("logs", "--no-color", "--tail", "20"), flush=True) + raise + finally: + stand.compose("down", "--remove-orphans", "--timeout", "1") + + +if __name__ == "__main__": + main() diff --git a/scripts/deployment.py b/scripts/deployment.py new file mode 100644 index 00000000..a2bf38d8 --- /dev/null +++ b/scripts/deployment.py @@ -0,0 +1,107 @@ +"""Общие операции с репликами текущего Compose-проекта.""" + +from contextlib import contextmanager +from dataclasses import dataclass +import fcntl +import json +import os +from pathlib import Path +import ssl +import subprocess +import tempfile +import time +from urllib.error import HTTPError, URLError +from urllib.request import urlopen + +ROOT = Path(__file__).resolve().parents[1] + + +@dataclass(frozen=True) +class Replica: + """Состояние контейнера API.""" + + id: str + image: str + instance_id: str + running: bool + health: str | None + + +class ComposeProject: + """Работает только с выбранным Compose-проектом.""" + + def __init__(self) -> None: + self.command = ["docker", "compose", "--env-file", ".env"] + self.config = json.loads(self.run("config", "--format", "json")) + self.name = self.config["name"] + + def docker(self, *args: str, timeout: int = 90, env=None) -> str: + """Выполняет Docker-команду с ограничением времени.""" + result = subprocess.run( + ["docker", *args], cwd=ROOT, text=True, capture_output=True, + timeout=timeout, env={**os.environ, **(env or {})}, + ) + if result.returncode: + raise RuntimeError(result.stderr.strip() or result.stdout.strip()) + return result.stdout.strip() + + def run(self, *args: str, timeout: int = 90, env=None) -> str: + """Выполняет команду Compose с текущими overrides.""" + return self.docker(*self.command[1:], *args, timeout=timeout, env=env) + + def replicas(self) -> list[Replica]: + """Читает состояние API без окружения контейнеров.""" + ids = self.run("ps", "--all", "--quiet", "api").splitlines() + if not ids: + return [] + template = ( + '{"id":{{json .Id}},"image":{{json .Image}},' + '"hostname":{{json .Config.Hostname}},"running":{{json .State.Running}},' + '"health":{{if .State.Health}}{{json .State.Health.Status}}{{else}}null{{end}}}' + ) + rows = self.docker("inspect", "--format", template, *ids).splitlines() + configured = str(self.config["services"]["api"].get("environment", {}).get("INSTANCE_ID") or "").strip() + return [ + Replica(row["id"], row["image"], configured or row["hostname"], row["running"], row["health"]) + for row in map(json.loads, rows) + ] + + def wait_healthy(self, ids: set[str], timeout: float = 40) -> None: + """Ожидает готовность конкретных реплик.""" + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + current = {replica.id: replica for replica in self.replicas()} + if not ids <= current.keys(): + raise RuntimeError("Контейнер API исчез во время развёртывания") + if all(current[id].running and current[id].health == "healthy" for id in ids): + return + if any(not current[id].running for id in ids): + raise RuntimeError("Контейнер API завершился до готовности") + time.sleep(0.25) + raise TimeoutError("API не стал healthy за отведённое время") + + def wait_routed(self, instance_id: str, base_url: str, ca_file=None) -> None: + """Ожидает ответа реплики через балансировщик.""" + context = ssl.create_default_context(cafile=ca_file) + deadline = time.monotonic() + 40 + while time.monotonic() < deadline: + try: + with urlopen(base_url.rstrip("/") + "/health/live", timeout=3, context=context) as response: + if response.status == 200 and response.headers.get("X-Instance-Id") == instance_id: + return + except (HTTPError, URLError, TimeoutError, OSError): + pass + time.sleep(0.1) + raise TimeoutError("Реплика не появилась в ответах балансировщика") + + +@contextmanager +def deployment_lock(project: ComposeProject): + """Исключает параллельные изменения одного стенда.""" + path = Path(tempfile.gettempdir()) / f"{project.name}-deployment.lock" + with path.open("a") as lock: + try: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError: + raise RuntimeError("Другой процесс уже изменяет этот Compose-проект") from None + yield diff --git a/scripts/failover_all.py b/scripts/failover_all.py new file mode 100644 index 00000000..79745d7e --- /dev/null +++ b/scripts/failover_all.py @@ -0,0 +1,148 @@ +"""Сценарий поочерёдного отказа всех API-реплик под записью.""" + +from collections import Counter +from concurrent.futures import ThreadPoolExecutor +import json +import os +import re +import subprocess +from threading import Event, Lock +import time +from urllib.parse import quote +from uuid import uuid4 + +from scripts.deployment import ComposeProject, ROOT, deployment_lock +from tests.client import Client, Failure, arguments, check, run + + +def failure_kind(error: Failure) -> str: + """Различает HTTP-отказы, ошибки соединения и проверки контракта.""" + match = re.search(r"received (\d{3})$", str(error)) + if match: + return "http_" + match.group(1) + return "connection" if "connection/TLS failure" in str(error) else "contract" + + +def snapshot(project: ComposeProject, phase: str, target: str) -> list: + """Печатает состояние API без окружения и секретов.""" + replicas = project.replicas() + print(json.dumps({ + "scenario": "replica_failure", "phase": phase, "target": target, + "replicas": [{"instance": item.instance_id, "running": item.running, "health": item.health} for item in replicas], + }), flush=True) + return replicas + + +def history(client: Client, actor: dict, chat: dict) -> list[dict]: + """Читает всю историю без повторов курсора.""" + path = f"/api/v1/chats/{chat['id']}/messages?limit=100" + items = [] + cursors = set() + for _ in range(1000): + page = client.call("GET", path, actor=actor, schema="MessagePage")["json"] + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return items + check(cursor not in cursors, "cursor cycle") + cursors.add(cursor) + path = f"/api/v1/chats/{chat['id']}/messages?limit=100&cursor={quote(cursor, safe='')}" + raise Failure("history exceeded safety bound") + + +def exercise(project: ComposeProject, args) -> None: + """Останавливает каждую реплику и восстанавливает её перед следующей.""" + replicas = project.replicas() + check(len(replicas) >= 2, "at least two API replicas are required") + project.wait_healthy({item.id for item in replicas}) + client = Client(args.base_url, args.ca_file, timeout=2) + for item in replicas: + project.wait_routed(item.instance_id, client.base, args.ca_file) + actor, _, _, chat = client.bootstrap() + confirmed = set() + + for target in replicas: + snapshot(project, "before", target.instance_id) + stop = Event() + lock = Lock() + successes = [] + errors = [] + + def worker(): + local = Client(client.base, args.ca_file, timeout=2) + key = uuid4().hex + while not stop.is_set(): + started = time.monotonic() + try: + result = local.message(actor, chat, "failover-" + key, key=key) + with lock: + successes.append((started, time.monotonic(), result["json"]["id"])) + key = uuid4().hex + except Failure as error: + with lock: + errors.append(failure_kind(error)) + time.sleep(0.1) + + started = time.monotonic() + with ThreadPoolExecutor(max_workers=args.concurrency) as pool: + jobs = [pool.submit(worker) for _ in range(args.concurrency)] + try: + time.sleep(2) + stop_started = time.monotonic() + subprocess.run( + [str(ROOT / "scripts/stop-one.sh")], cwd=ROOT, + env={**os.environ, "TARGET_INSTANCE_ID": target.instance_id}, + check=True, timeout=10, capture_output=True, + ) + stop_finished = time.monotonic() + stopped = snapshot(project, "stopped", target.instance_id) + check(any(item.id == target.id and not item.running for item in stopped), "target API was not stopped") + check(any(item.id != target.id and item.running and item.health == "healthy" for item in stopped), "no healthy surviving API") + time.sleep(args.duration) + finally: + stop.set() + try: + for job in jobs: + job.result(timeout=5) + finally: + project.docker("start", target.id) + project.wait_healthy({item.id for item in replicas}) + project.wait_routed(target.instance_id, client.base, args.ca_file) + snapshot(project, "restored", target.instance_id) + + elapsed = max(end for _, end, _ in successes) - started if successes else 0 + recovered = [end for begin, end, _ in successes if begin >= stop_finished] + check(bool(recovered), "no confirmed writes after failure") + recovery = min(recovered) - stop_started + check(recovery <= 10, "writes did not recover within 10 seconds") + confirmed.update(id for _, _, id in successes) + items = history(client, actor, chat) + check(confirmed <= {item["id"] for item in items}, "confirmed messages were lost") + texts = [item["text"] for item in items] + check(len(texts) == len(set(texts)), "uncertain retry created duplicates") + print(json.dumps({ + "instance": target.instance_id, + "successful_writes": len(successes), + "failed_attempts": len(errors), + "errors_by_kind": dict(Counter(errors)), + "elapsed_seconds": round(elapsed, 3), + "successful_rps": round(len(successes) / elapsed, 3) if elapsed else 0, + "first_recovery_seconds": round(recovery, 3), + }), flush=True) + + +def main() -> None: + """Готовит параметры эксперимента отказа реплик.""" + def configure(parser): + parser.add_argument("--duration", type=float, default=15) + parser.add_argument("--concurrency", type=int, default=2) + + args = arguments("Fail each API replica under write load", configure) + check(1 <= args.duration <= 120 and 1 <= args.concurrency <= 8, "invalid workload") + project = ComposeProject() + with deployment_lock(project): + exercise(project, args) + + +if __name__ == "__main__": + run(main) diff --git a/scripts/prepare_secrets.py b/scripts/prepare_secrets.py new file mode 100644 index 00000000..f84f7a17 --- /dev/null +++ b/scripts/prepare_secrets.py @@ -0,0 +1,46 @@ +"""Подготавливает локальные файлы Docker secrets.""" + +import os +from pathlib import Path +import secrets + +from pydantic import SecretStr +from pydantic_settings import BaseSettings, SettingsConfigDict + +ROOT = Path(__file__).resolve().parents[1] + + +class ExistingSecrets(BaseSettings): + """Читает прежние пароли без вывода значений.""" + + db_password: SecretStr | None = None + redis_password: SecretStr | None = None + model_config = SettingsConfigDict(env_file=ROOT / ".env", extra="ignore") + + +def main() -> None: + """Создаёт отсутствующие файлы, сохраняя существующие значения.""" + directory = ROOT / "secrets" + directory.mkdir(mode=0o700, exist_ok=True) + directory.chmod(0o700) + existing = ExistingSecrets() + for name in ("db_password", "redis_password"): + path = directory / name + if path.is_symlink(): + raise RuntimeError(f"Секрет {name} не должен быть символьной ссылкой") + if path.exists() and not path.is_file(): + raise RuntimeError(f"Секрет {name} должен быть обычным файлом") + if not path.exists(): + previous = getattr(existing, name) + value = previous.get_secret_value() if previous else secrets.token_urlsafe(32) + if not value or value.strip() != value or "\n" in value or "\r" in value: + raise ValueError(f"Секрет {name} должен занимать одну строку без крайних пробелов") + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + with os.fdopen(descriptor, "w") as file: + file.write(value + "\n") + path.chmod(0o444) + print(f"Готов файл secrets/{name}") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh index d9ab44b3..aa48ba71 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,6 +1,4 @@ #!/bin/sh -# Перезапуск API и всех хранилищ с сохранением volumes (make test-persistence). -# У api несколько реплик, перед ними nginx. set -eu cd "$(dirname "$0")/.." @@ -8,7 +6,6 @@ compose() { docker compose --env-file .env "$@" } -# Ждёт, пока ВСЕ контейнеры service станут healthy (у api их несколько). wait_healthy() { for service in "$@"; do attempts=0 @@ -29,7 +26,5 @@ compose restart postgres redis wait_healthy postgres redis compose restart api wait_healthy api -# TODO(3.3): если nginx перерезолвит DNS сам, рестарт LB не обязателен — -# но перезапуск «всего стенда» в защите всё равно его включает. compose restart nginx wait_healthy nginx diff --git a/scripts/rolling_update.py b/scripts/rolling_update.py new file mode 100644 index 00000000..20aebda8 --- /dev/null +++ b/scripts/rolling_update.py @@ -0,0 +1,92 @@ +"""Поочерёдно заменяет API с одной дополнительной репликой.""" + +import argparse +import sys + +from scripts.deployment import ComposeProject, deployment_lock + + +def update(project: ComposeProject, base_url: str, ca_file=None, revision: str | None = None) -> None: + """Собирает образ, применяет миграции и заменяет реплики.""" + original = project.replicas() + if len(original) < 2 or any(not item.running or item.health != "healthy" for item in original): + raise RuntimeError("До обновления нужны минимум две здоровые API-реплики") + old_images = {item.image for item in original} + if len(old_images) != 1: + raise RuntimeError("Сначала восстановите единый образ работающих реплик") + old_image = old_images.pop() + profile = project.docker( + "image", "inspect", old_image, + "--format", '{{index .Config.Labels "io.mtusi.messenger.secrets"}}', + ) + if profile != "file-v1": + raise RuntimeError("Сначала выполните первоначальный переход на файловые секреты через make up") + count = len(original) + print("Сборка нового образа API", flush=True) + build_args = ("--build-arg", f"API_BUILD_REVISION={revision}") if revision else () + project.run("build", *build_args, "api", timeout=300) + tag = project.config["services"]["api"]["image"] + new_image = project.docker("image", "inspect", tag, "--format", "{{.Id}}") + print("Однократное применение совместимых миграций", flush=True) + project.run("run", "--rm", "--no-deps", "--pull", "never", "migrate") + if old_image == new_image: + print("Образ не изменился; замена контейнеров не требуется") + return + + try: + for old in original: + project.run( + "up", "-d", "--no-deps", "--no-build", "--pull", "never", + "--no-recreate", "--scale", f"api={count + 1}", "api", + ) + current = project.replicas() + additions = [item for item in current if item.id not in {replica.id for replica in original} and item.image == new_image] + if not additions: + raise RuntimeError("Новая реплика не создана") + project.wait_healthy({item.id for item in additions}) + for added in additions: + project.wait_routed(added.instance_id, base_url, ca_file) + survivors = {item.id for item in project.replicas() if item.id != old.id} + project.wait_healthy(survivors) + project.docker("stop", old.id) + project.docker("rm", old.id) + print(f"Заменена реплика {old.instance_id}", flush=True) + final = project.replicas() + if len(final) != count or any(item.image != new_image for item in final): + raise RuntimeError("Состав реплик после обновления не соответствует плану") + project.wait_healthy({item.id for item in final}) + except Exception: + print("Обновление прервано; восстанавливается прежний образ без отката БД", file=sys.stderr) + project.run( + "up", "-d", "--no-deps", "--no-build", "--pull", "never", + "--force-recreate", "--scale", f"api={count}", "api", + env={"API_IMAGE": old_image}, + ) + project.wait_healthy({item.id for item in project.replicas()}) + raise + + dangling = project.docker("image", "ls", "--quiet", "--no-trunc", "--filter", "dangling=true").splitlines() + if old_image in dangling: + references = project.docker("ps", "--all", "--quiet", "--filter", f"ancestor={old_image}") + if not references: + try: + project.docker("image", "rm", old_image) + except RuntimeError: + print("Прежний образ не удалён: состояние Docker изменилось", file=sys.stderr) + print(f"Готово: {count} здоровых реплик нового образа") + + +def main() -> None: + """Запускает обновление с блокировкой проекта.""" + parser = argparse.ArgumentParser(description="Rolling update of API replicas") + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--ca-file", default=None) + parser.add_argument("--revision", default=None) + args = parser.parse_args() + project = ComposeProject() + with deployment_lock(project): + update(project, args.base_url or "http://localhost:8080", args.ca_file, args.revision) + + +if __name__ == "__main__": + main() diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh index 34437faf..0dcd4da0 100755 --- a/scripts/stop-one.sh +++ b/scripts/stop-one.sh @@ -1,21 +1,30 @@ #!/bin/sh -# Останавливает одну API-реплику по TARGET_INSTANCE_ID (сценарий отказа, make test-failover). -# TODO(3.5): реализовать — см. docs/LAB3_TASKS.md, задача 3.5. set -eu cd "$(dirname "$0")/.." : "${TARGET_INSTANCE_ID:?test provides target API instance alias}" -# Что нужно сделать: -# 1. Сопоставить TARGET_INSTANCE_ID (значение X-Instance-Id) с контейнером. -# Проще всего, если X-Instance-Id = короткий id контейнера (HOSTNAME): -# docker compose --env-file .env ps -q api -> полные id реплик api -# и найти тот, что начинается с TARGET_INSTANCE_ID. -# 2. Убедиться, что это контейнер service `api` ЭТОГО compose-проекта, -# а не postgres/nginx/чужой контейнер. Не нашли -> exit 1. -# 3. Остановить его (docker stop [-t N]) и оставить остановленным. -# Не трогать БД/LB/volumes. Уложиться в 10 секунд. -# 4. Напечатать (в stderr), что именно остановлено — пригодится для отчёта. -# Восстановление — отдельно: make restore. +case "$TARGET_INSTANCE_ID" in + *[!a-zA-Z0-9_.:-]*|'') exit 1 ;; +esac -echo 'TODO: implement stop-one.sh' >&2 -exit 2 +target="" +for container in $(docker compose --env-file .env ps -q api); do + hostname=$(docker inspect --format '{{.Config.Hostname}}' "$container") + configured=$(docker inspect --format '{{range .Config.Env}}{{if eq (index (split . "=") 0) "INSTANCE_ID"}}{{println .}}{{end}}{{end}}' "$container" \ + | sed -n 's/^INSTANCE_ID=//p' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//') + if [ "$TARGET_INSTANCE_ID" = "$hostname" ] || [ "$TARGET_INSTANCE_ID" = "$configured" ]; then + if [ -n "$target" ]; then + echo 'Instance id matches multiple API containers' >&2 + exit 1 + fi + target="$container" + fi +done + +if [ -z "$target" ]; then + echo 'Target API instance not found in this Compose project' >&2 + exit 1 +fi + +echo "Stopping API container $target" >&2 +docker stop --timeout 8 "$target" >/dev/null diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py index 9417866e..66860669 100644 --- a/student-tests/test_concurrency.py +++ b/student-tests/test_concurrency.py @@ -8,7 +8,7 @@ from sqlalchemy import text from app.main import create_app from conftest import close_app, make_client -from helpers import PASSWORD, basic_header, bearer, create_user, register +from helpers import PASSWORD, basic_header, bearer, create_user, idempotency_header, register async def test_parallel_registration_of_same_username_creates_exactly_one_user( @@ -62,7 +62,7 @@ async def test_100_messages_from_10_clients(make_settings): *( client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=bearer(user), + headers={**bearer(user), **idempotency_header()}, json={"text": f"client-{index}-message-{n}"}, ) for n in range(10) @@ -207,7 +207,7 @@ async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine *( client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=bearer(user), + headers={**bearer(user), **idempotency_header()}, json={"text": f"m{i}"}, ) for i in range(20) diff --git a/student-tests/test_idempotency.py b/student-tests/test_idempotency.py new file mode 100644 index 00000000..9455e3d4 --- /dev/null +++ b/student-tests/test_idempotency.py @@ -0,0 +1,156 @@ +"""Повторы сообщений через приложения с общими хранилищами.""" + +import asyncio +from contextlib import AsyncExitStack + +import pytest +from sqlalchemy import text + +from app.errors.exceptions import unavailable +from app.main import create_app +from app.storage import idempotency as key_storage +from conftest import close_app, make_client +from helpers import bearer, create_chat, create_user, idempotency_header, send_message + + +@pytest.fixture +async def replicas(request, make_settings): + overrides = getattr(request, "param", {}) + apps = [create_app(make_settings(instance_id=name, **overrides)) for name in ("api-a", "api-b")] + try: + async with AsyncExitStack() as stack: + clients = [await stack.enter_async_context(make_client(app)) for app in apps] + yield clients + finally: + for app in apps: + await close_app(app) + + +@pytest.mark.parametrize("key", [None, "", "a b", "a/b", "x" * 129]) +async def test_invalid_key_returns_400(client, key): + user = await create_user(client) + chat = await create_chat(client, user) + headers = bearer(user) + if key is not None: + headers["Idempotency-Key"] = key + response = await client.post( + f"/api/v1/chats/{chat['id']}/messages", headers=headers, json={"text": "hello"} + ) + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.parametrize("key", ["a", "x" * 128, "key_1.2:3-4"]) +async def test_valid_key_boundaries(client, key): + user = await create_user(client) + chat = await create_chat(client, user) + assert (await send_message(client, user, chat, "hello", key)).status_code == 201 + + +async def test_replay_and_conflict_across_replicas(replicas, db_engine): + first, second = replicas + user = await create_user(first) + chat = await create_chat(first, user) + original = await send_message(first, user, chat, "Привет", "same-key") + repeated = await second.post( + f"/api/v1/chats/{chat['id']}/messages", + headers={**bearer(user), **idempotency_header("same-key"), "Content-Type": "application/json"}, + content='{ "text" : "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442" }', + ) + conflict = await send_message(second, user, chat, "другой текст", "same-key") + assert original.status_code == repeated.status_code == 201 + assert original.json() == repeated.json() + assert original.headers["X-Instance-Id"] != repeated.headers["X-Instance-Id"] + assert conflict.status_code == 409 + async with db_engine.connect() as connection: + assert (await connection.execute(text("SELECT count(*) FROM messages"))).scalar_one() == 1 + assert (await connection.execute(text("SELECT value FROM counters WHERE name='messages'"))).scalar_one() == 1 + + +async def test_parallel_replays_create_one_message(replicas, db_engine): + user = await create_user(replicas[0]) + chat = await create_chat(replicas[0], user) + responses = await asyncio.gather(*( + send_message(replicas[index % 2], user, chat, "parallel", "one-key") + for index in range(24) + )) + assert all(response.status_code == 201 for response in responses) + assert len({response.json()["id"] for response in responses}) == 1 + assert {response.headers["X-Instance-Id"] for response in responses} == {"api-a", "api-b"} + async with db_engine.connect() as connection: + assert (await connection.execute(text("SELECT count(*) FROM messages"))).scalar_one() == 1 + assert (await connection.execute(text("SELECT count(*) FROM idempotency_keys"))).scalar_one() == 1 + + +async def test_key_scope_separates_users_and_chats(client): + alice = await create_user(client) + bob = await create_user(client) + shared = await create_chat(client, alice, bob) + other = await create_chat(client, alice) + responses = [ + await send_message(client, alice, shared, "a", "shared-key"), + await send_message(client, bob, shared, "b", "shared-key"), + await send_message(client, alice, other, "c", "shared-key"), + ] + assert all(response.status_code == 201 for response in responses) + assert len({response.json()["id"] for response in responses}) == 3 + + +async def test_expired_key_can_be_reused_without_removing_message(client, db_engine): + user = await create_user(client) + chat = await create_chat(client, user) + first = await send_message(client, user, chat, "old", "expiring-key") + async with db_engine.begin() as connection: + await connection.execute(text( + "UPDATE idempotency_keys SET created_at = clock_timestamp() - interval '25 hours'" + )) + second = await send_message(client, user, chat, "new", "expiring-key") + assert first.status_code == second.status_code == 201 + assert first.json()["id"] != second.json()["id"] + history = await client.get( + f"/api/v1/chats/{chat['id']}/messages", headers=bearer(user) + ) + assert [item["text"] for item in history.json()["items"]] == ["old", "new"] + + +async def test_failed_transaction_does_not_poison_key(client, db_engine, monkeypatch): + user = await create_user(client) + chat = await create_chat(client, user) + original = key_storage.save_result + + async def fail_after_insert(*args): + await original(*args) + raise unavailable() + + monkeypatch.setattr(key_storage, "save_result", fail_after_insert) + failed = await send_message(client, user, chat, "retry", "retry-key") + assert failed.status_code == 503 + async with db_engine.connect() as connection: + for table in ("messages", "idempotency_keys", "counters"): + assert (await connection.execute(text(f"SELECT count(*) FROM {table}"))).scalar_one() == 0 + monkeypatch.setattr(key_storage, "save_result", original) + recovered = await send_message(client, user, chat, "retry", "retry-key") + assert recovered.status_code == 201 + + +@pytest.mark.parametrize("replicas", [{"max_messages": 1}], indirect=True) +async def test_replay_works_when_message_limit_is_full(replicas): + user = await create_user(replicas[0]) + chat = await create_chat(replicas[0], user) + first = await send_message(replicas[0], user, chat, "last", "last-key") + replay = await send_message(replicas[1], user, chat, "last", "last-key") + rejected = await send_message(replicas[1], user, chat, "extra", "other-key") + assert first.status_code == replay.status_code == 201 + assert first.json() == replay.json() + assert rejected.status_code == 503 + + +async def test_replay_checks_session_and_membership(client, db_engine): + user = await create_user(client) + chat = await create_chat(client, user) + assert (await send_message(client, user, chat, "private", "private-key")).status_code == 201 + async with db_engine.begin() as connection: + await connection.execute(text("DELETE FROM chat_members")) + assert (await send_message(client, user, chat, "private", "private-key")).status_code == 404 + await client.delete("/api/v1/auth/sessions/current", headers=bearer(user)) + assert (await send_message(client, user, chat, "private", "private-key")).status_code == 401 diff --git a/student-tests/test_instance.py b/student-tests/test_instance.py new file mode 100644 index 00000000..8b0d932b --- /dev/null +++ b/student-tests/test_instance.py @@ -0,0 +1,106 @@ +"""Идентификатор реплики и заголовки ответов без PostgreSQL, Redis и Docker.""" + +from uuid import UUID + +import pytest +from fastapi import Request + +from app.core.instance import resolve_instance_id +from app.errors.exceptions import unavailable +from app.main import create_app +from conftest import close_app, make_client + + +@pytest.fixture(autouse=True) +def clean_db() -> None: + """Заменяет очистку БД из conftest: эти тесты не обращаются к хранилищам.""" + + +@pytest.mark.parametrize( + ("configured", "expected"), + [ + ("api-explicit", "api-explicit"), + (" api-explicit ", "api-explicit"), + (None, "container-123"), + ("", "container-123"), + (" ", "container-123"), + ], +) +def test_resolve_prefers_configured_id_then_hostname(monkeypatch, configured, expected): + monkeypatch.setenv("HOSTNAME", " container-123 ") + + assert resolve_instance_id(configured) == expected + + +@pytest.mark.parametrize("hostname", [None, "", " "]) +def test_resolve_without_config_or_hostname_returns_uuid(monkeypatch, hostname): + if hostname is None: + monkeypatch.delenv("HOSTNAME", raising=False) + else: + monkeypatch.setenv("HOSTNAME", hostname) + + assert UUID(resolve_instance_id(None)).version == 4 + + +@pytest.fixture +async def instance_client(make_settings): + app = create_app( + make_settings( + instance_id="api-test", + database_url="postgresql+asyncpg://unused@127.0.0.1:1/unused", + redis_port=1, + ) + ) + + @app.get("/__test__/request-id", include_in_schema=False) + async def request_id(request: Request) -> dict[str, str]: + return {"request_id": request.state.request_id} + + @app.get("/__test__/explode", include_in_schema=False) + async def explode() -> None: + raise RuntimeError("test error") + + @app.get("/__test__/unavailable", include_in_schema=False) + async def dependency_failure() -> None: + raise unavailable() + + try: + async with make_client(app, raise_app_exceptions=False) as client: + yield client + finally: + await close_app(app) + + +@pytest.mark.parametrize( + ("method", "path", "status"), + [ + ("GET", "/health/live", 200), + ("POST", "/api/v1/users", 400), + ("GET", "/api/v1/users/me", 401), + ("GET", "/no-such-path", 404), + ("DELETE", "/health/live", 405), + ("GET", "/__test__/explode", 500), + ("GET", "/__test__/unavailable", 503), + ], +) +async def test_instance_header_is_present_on_success_and_errors( + instance_client, method, path, status +): + response = await instance_client.request(method, path) + + assert response.status_code == status + assert response.headers["X-Instance-Id"] == "api-test" + assert response.headers["X-Request-Id"] + if status >= 400: + assert response.json()["error"]["request_id"] == response.headers["X-Request-Id"] + + +async def test_instance_id_is_stable_while_request_ids_are_distinct(instance_client): + first = await instance_client.get("/__test__/request-id") + second = await instance_client.get("/__test__/request-id") + + assert first.status_code == second.status_code == 200 + assert first.headers["X-Instance-Id"] == second.headers["X-Instance-Id"] == "api-test" + assert first.headers["X-Request-Id"] != second.headers["X-Request-Id"] + for response in (first, second): + assert response.json()["request_id"] == response.headers["X-Request-Id"] diff --git a/student-tests/test_lifecycle.py b/student-tests/test_lifecycle.py new file mode 100644 index 00000000..95ce5997 --- /dev/null +++ b/student-tests/test_lifecycle.py @@ -0,0 +1,50 @@ +"""Готовность при завершении и ограничение времени проверки зависимостей.""" + +import asyncio +import time + +import pytest + +from app.endpoints import health +from app.main import create_app +from conftest import close_app, make_client + + +@pytest.fixture(autouse=True) +def clean_db() -> None: + """Эти проверки не обращаются к хранилищам.""" + + +async def test_draining_keeps_liveness_but_rejects_new_work(make_settings): + app = create_app(make_settings()) + app.state.lifecycle.start_draining() + try: + async with make_client(app) as client: + assert (await client.get('/health/live')).status_code == 200 + assert (await client.get('/health/ready')).status_code == 503 + assert (await client.get('/api/v1/users/me')).status_code == 503 + finally: + await close_app(app) + + +async def test_readiness_timeout_cancels_dependency_checks(make_settings, monkeypatch): + cancelled = [] + + async def stalled(_): + try: + await asyncio.sleep(30) + finally: + cancelled.append(True) + + monkeypatch.setattr(health, 'check_database', stalled) + monkeypatch.setattr(health, 'check_redis', stalled) + app = create_app(make_settings(readiness_timeout_seconds=0.03)) + try: + async with make_client(app) as client: + started = time.monotonic() + response = await client.get('/health/ready') + assert response.status_code == 503 + assert time.monotonic() - started < 1 + assert len(cancelled) == 2 + finally: + await close_app(app) diff --git a/student-tests/test_limits.py b/student-tests/test_limits.py index 86d53ed6..3bd68c0d 100644 --- a/student-tests/test_limits.py +++ b/student-tests/test_limits.py @@ -6,7 +6,7 @@ import httpx from app.main import create_app from conftest import close_app, make_client -from helpers import assert_request_id, bearer, create_chat, create_user +from helpers import assert_request_id, bearer, create_chat, create_user, idempotency_header def _assert_error(response: httpx.Response, status: int, code: str) -> None: @@ -25,12 +25,12 @@ async def test_message_limit_rejects_without_deleting_confirmed_messages(make_se for index in range(2): ok = await client.post( - url, headers=bearer(user), json={"text": f"confirmed-{index}"} + url, headers={**bearer(user), **idempotency_header()}, json={"text": f"confirmed-{index}"} ) assert ok.status_code == 201 rejected = await client.post( - url, headers=bearer(user), json={"text": "rejected"} + url, headers={**bearer(user), **idempotency_header()}, json={"text": "rejected"} ) _assert_error(rejected, 503, "unavailable") @@ -48,7 +48,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat app = create_app(make_settings(max_in_flight=2)) - original_send_message = message_endpoint.send_message + original_send_message = message_endpoint.send_message_idempotent accepted_count = 0 all_slots_taken = asyncio.Event() release = asyncio.Event() @@ -65,12 +65,12 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat user = await create_user(client) chat = await create_chat(client, user) - monkeypatch.setattr(message_endpoint, "send_message", blocking_send_message) + monkeypatch.setattr(message_endpoint, "send_message_idempotent", blocking_send_message) url = f"/api/v1/chats/{chat['id']}/messages" held = [ asyncio.create_task( - client.post(url, headers=bearer(user), json={"text": f"held-{i}"}) + client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"held-{i}"}) ) for i in range(2) ] @@ -79,7 +79,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat rejected = await asyncio.gather( *( - client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"}) + client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"rejected-{i}"}) for i in range(4) ) ) @@ -92,7 +92,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat release.set() assert all(r.status_code == 201 for r in await asyncio.gather(*held)) - recovered = await client.post(url, headers=bearer(user), json={"text": "after"}) + recovered = await client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": "after"}) assert recovered.status_code == 201 assert_request_id(recovered) await close_app(app) diff --git a/student-tests/test_messages.py b/student-tests/test_messages.py index 2a47923e..07fdc08f 100644 --- a/student-tests/test_messages.py +++ b/student-tests/test_messages.py @@ -8,6 +8,7 @@ from helpers import ( bearer, create_chat, create_user, + idempotency_header, send_message, ) @@ -58,7 +59,7 @@ async def test_extra_message_field_is_rejected(client: AsyncClient): response = await client.post( f"/api/v1/chats/{chat['id']}/messages", - headers=bearer(alice), + headers={**bearer(alice), **idempotency_header()}, json={"text": "hello", "sender_id": alice["id"]}, ) diff --git a/student-tests/test_migrations.py b/student-tests/test_migrations.py index b41c8830..3890fd92 100644 --- a/student-tests/test_migrations.py +++ b/student-tests/test_migrations.py @@ -8,7 +8,7 @@ from sqlalchemy import inspect, text from app.models import Base from conftest import reset_schema, upgrade_head -EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters"} +EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters", "idempotency_keys"} @pytest.fixture diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..f0077358 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1 @@ +"""Публичный HTTP-клиент и проверки контракта."""