From df49fb5df4c343a3d5566c6bd4788c824c82ed99 Mon Sep 17 00:00:00 2001 From: gytall Date: Fri, 30 Oct 2026 00:53:49 +0300 Subject: [PATCH 1/5] create skeleton for lab 3 --- .env.example | 52 ++- .gitignore | 4 + Dockerfile | 29 ++ Makefile | 147 ++++++++- alembic.ini | 38 +++ app/__init__.py | 0 app/__main__.py | 4 + app/core/__init__.py | 0 app/core/config.py | 95 ++++++ app/core/database.py | 44 +++ app/core/instance.py | 40 +++ app/core/lifecycle.py | 32 ++ app/core/redis.py | 38 +++ app/core/request_capacity.py | 40 +++ app/core/request_id.py | 22 ++ app/core/security.py | 63 ++++ app/domain/__init__.py | 1 + app/domain/auth.py | 84 +++++ app/domain/chats.py | 104 ++++++ app/domain/idempotency.py | 75 +++++ app/domain/messages.py | 62 ++++ app/domain/pagination.py | 83 +++++ app/domain/users.py | 41 +++ app/endpoints/__init__.py | 0 app/endpoints/auth.py | 32 ++ app/endpoints/chats.py | 32 ++ app/endpoints/dependencies.py | 100 ++++++ app/endpoints/health.py | 26 ++ app/endpoints/messages.py | 39 +++ app/endpoints/users.py | 17 + app/errors/__init__.py | 0 app/errors/exceptions.py | 85 +++++ app/errors/handlers.py | 197 ++++++++++++ app/main.py | 80 +++++ app/models/__init__.py | 8 + app/models/base.py | 27 ++ app/models/chat.py | 32 ++ app/models/chat_member.py | 26 ++ app/models/counter.py | 13 + app/models/idempotency_key.py | 28 ++ app/models/message.py | 30 ++ app/models/user.py | 31 ++ app/schemas/__init__.py | 6 + app/schemas/base.py | 35 ++ app/schemas/chat.py | 22 ++ app/schemas/message.py | 22 ++ app/schemas/session.py | 17 + app/schemas/user.py | 25 ++ app/storage/__init__.py | 1 + app/storage/chats.py | 71 +++++ app/storage/messages.py | 58 ++++ app/storage/sessions.py | 38 +++ app/storage/types.py | 6 + app/storage/users.py | 47 +++ compose.test.yaml | 10 + compose.yaml | 105 ++++++ infra/nginx/nginx.conf | 55 ++++ infra/redis/redis.conf | 5 + migrations/env.py | 68 ++++ migrations/script.py.mako | 25 ++ migrations/versions/.gitkeep | 0 .../versions/abd273076068_add_counters.py | 33 ++ .../db06fd3126ff_create_initial_schema.py | 107 +++++++ pytest.ini | 6 + requirements.txt | 50 +++ scripts/expiry_demo.sh | 28 ++ scripts/explain_history.py | 132 ++++++++ scripts/failure_demo.sh | 64 ++++ scripts/restart.sh | 35 ++ scripts/stop-one.sh | 21 ++ student-tests/conftest.py | 200 ++++++++++++ student-tests/helpers.py | 88 ++++++ student-tests/test_auth.py | 298 ++++++++++++++++++ student-tests/test_chats.py | 209 ++++++++++++ student-tests/test_concurrency.py | 266 ++++++++++++++++ student-tests/test_constraints.py | 46 +++ student-tests/test_errors.py | 76 +++++ student-tests/test_failures.py | 138 ++++++++ student-tests/test_health.py | 62 ++++ student-tests/test_history_plan.py | 78 +++++ student-tests/test_limits.py | 98 ++++++ student-tests/test_messages.py | 237 ++++++++++++++ student-tests/test_migrations.py | 67 ++++ student-tests/test_pagination.py | 137 ++++++++ student-tests/test_sessions.py | 173 ++++++++++ student-tests/test_users.py | 128 ++++++++ 86 files changed, 5284 insertions(+), 10 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/core/__init__.py create mode 100644 app/core/config.py create mode 100644 app/core/database.py create mode 100644 app/core/instance.py create mode 100644 app/core/lifecycle.py create mode 100644 app/core/redis.py create mode 100644 app/core/request_capacity.py create mode 100644 app/core/request_id.py create mode 100644 app/core/security.py create mode 100644 app/domain/__init__.py create mode 100644 app/domain/auth.py create mode 100644 app/domain/chats.py create mode 100644 app/domain/idempotency.py create mode 100644 app/domain/messages.py create mode 100644 app/domain/pagination.py create mode 100644 app/domain/users.py create mode 100644 app/endpoints/__init__.py create mode 100644 app/endpoints/auth.py create mode 100644 app/endpoints/chats.py create mode 100644 app/endpoints/dependencies.py create mode 100644 app/endpoints/health.py create mode 100644 app/endpoints/messages.py create mode 100644 app/endpoints/users.py create mode 100644 app/errors/__init__.py create mode 100644 app/errors/exceptions.py create mode 100644 app/errors/handlers.py create mode 100644 app/main.py create mode 100644 app/models/__init__.py create mode 100644 app/models/base.py create mode 100644 app/models/chat.py create mode 100644 app/models/chat_member.py create mode 100644 app/models/counter.py create mode 100644 app/models/idempotency_key.py create mode 100644 app/models/message.py create mode 100644 app/models/user.py create mode 100644 app/schemas/__init__.py create mode 100644 app/schemas/base.py create mode 100644 app/schemas/chat.py create mode 100644 app/schemas/message.py create mode 100644 app/schemas/session.py create mode 100644 app/schemas/user.py create mode 100644 app/storage/__init__.py create mode 100644 app/storage/chats.py create mode 100644 app/storage/messages.py create mode 100644 app/storage/sessions.py create mode 100644 app/storage/types.py create mode 100644 app/storage/users.py create mode 100644 compose.test.yaml create mode 100644 compose.yaml create mode 100644 infra/nginx/nginx.conf create mode 100644 infra/redis/redis.conf create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/.gitkeep create mode 100644 migrations/versions/abd273076068_add_counters.py create mode 100644 migrations/versions/db06fd3126ff_create_initial_schema.py create mode 100644 pytest.ini create mode 100644 requirements.txt create mode 100755 scripts/expiry_demo.sh create mode 100644 scripts/explain_history.py create mode 100755 scripts/failure_demo.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh create mode 100644 student-tests/conftest.py create mode 100644 student-tests/helpers.py create mode 100644 student-tests/test_auth.py create mode 100644 student-tests/test_chats.py create mode 100644 student-tests/test_concurrency.py create mode 100644 student-tests/test_constraints.py create mode 100644 student-tests/test_errors.py create mode 100644 student-tests/test_failures.py create mode 100644 student-tests/test_health.py create mode 100644 student-tests/test_history_plan.py create mode 100644 student-tests/test_limits.py create mode 100644 student-tests/test_messages.py create mode 100644 student-tests/test_migrations.py create mode 100644 student-tests/test_pagination.py create mode 100644 student-tests/test_sessions.py create mode 100644 student-tests/test_users.py diff --git a/.env.example b/.env.example index d32b9be0..bc813a80 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,51 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Скопируйте в .env для локального окружения; .env не коммитится. +# Имена переменных соответствуют полям app/core/config.py. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +LOG_LEVEL=INFO + +MAX_MESSAGES=100000 +# Лимит одновременных запросов НА ОДНУ реплику +MAX_IN_FLIGHT=16 + SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +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 +REDIS_SOCKET_TIMEOUT_SECONDS=0.5 + +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. +DB_POOL_SIZE=5 +DB_MAX_OVERFLOW=10 +DB_POOL_TIMEOUT_SECONDS=3 +DB_CONNECT_TIMEOUT_SECONDS=3 +DB_STATEMENT_TIMEOUT_MS=5000 + +# --- Балансировка и идемпотентность --- API_REPLICAS=2 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 +GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5 + +# Порт единственной публичной точки входа (nginx) +LB_HOST_PORT=8080 +# Используются только тестовым стендом (compose.test.yaml) +DB_HOST_PORT=15432 +REDIS_HOST_PORT=16379 diff --git a/.gitignore b/.gitignore index b5a71896..c0355e14 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,7 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. + +/venv +.ruff_cache/ +/docs \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e1b67766 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM python:3.12.15-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /app + +RUN useradd --system --uid 10001 --no-create-home appuser + +COPY requirements.txt . +RUN pip install -r requirements.txt + +COPY alembic.ini ./ +COPY migrations ./migrations +COPY app ./app + +USER appuser + +# TODO(4.1): uvicorn корректно завершается по SIGTERM (сигнал Docker по умолчанию). +# Проверьте, что python — PID 1 (exec-форма CMD), иначе сигнал не дойдёт. + +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)"] + +CMD ["python", "-m", "app"] diff --git a/Makefile b/Makefile index 5d86d171..cbc1821b 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,54 @@ -PYTHON ?= python3 +-include .env + +PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3) BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +COMPOSE = docker compose --env-file .env + +# Отдельный тестовый стенд: свой compose-проект, свои порты, открытые БД/Redis +# (compose.test.yaml). COMPOSE_FILE подхватывают и scripts/*.sh. +TEST_PROJECT ?= $(notdir $(CURDIR))-test +TEST_LB_PORT ?= 18080 +TEST_DB_PORT ?= 15432 +TEST_REDIS_PORT ?= 16379 +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_REDIS_HOST ?= localhost +TEST_REDIS_PASSWORD ?= $(REDIS_PASSWORD) +TEST_REDIS_DB ?= 15 +export TEST_DATABASE_URL TEST_REDIS_HOST TEST_REDIS_PORT TEST_REDIS_PASSWORD TEST_REDIS_DB + +define wait_ready + @for i in $$(seq 1 90); do \ + curl -sf "$(1)/health/ready" >/dev/null && exit 0; sleep 1; \ + done; echo "API $(1) не готов за 90 секунд" >&2; exit 1 +endef + +.PHONY: help check validate test load test-persistence test-failover \ + up down restart restore ps logs migrate migration instances \ + test-stand-up test-stand-down test-stand-destroy test-stand-ps \ + test-stand-smoke test-stand-persistence test-stand-failover \ + test-own test-docker test-limits test-concurrency test-migrations test-all \ + explain expiry-demo failure-demo help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "Проверки: check | validate | test | load | test-persistence ACTION_SCRIPT=scripts/restart.sh" + @echo " test-failover ACTION_SCRIPT=scripts/stop-one.sh" + @echo "Основной: up | down | restart | restore | ps | logs | migrate | instances" + @echo "Тестовый: test-stand-up | test-stand-down | test-stand-destroy | test-stand-ps" + @echo " test-stand-smoke | test-stand-persistence | test-stand-failover" + @echo "Тесты: test-own | test-docker | test-limits | test-concurrency | test-migrations | test-all" + @echo "Демо: explain | expiry-demo | failure-demo (на тестовом стенде)" + @echo "Миграции: migration m='описание' (нужен поднятый тестовый стенд)" + +# --- Проверки API и сценариев отказа (tests/) --- check: $(PYTHON) scripts/check_contract.py @@ -28,3 +69,103 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --- Основной стенд --- + +up: + $(COMPOSE) up -d --build + $(call wait_ready,$(BASE_URL)) + +down: + $(COMPOSE) down + +restart: + scripts/restart.sh + $(call wait_ready,$(BASE_URL)) + +# Вернуть остановленную stop-one.sh реплику (compose up стартует остановленные контейнеры). +restore: + $(COMPOSE) up -d --wait api + +ps: + $(COMPOSE) ps + +logs: + $(COMPOSE) logs -f api nginx + +migrate: + $(COMPOSE) run --rm --build migrate + +# Показать, какие реплики отвечают через LB (по заголовку X-Instance-Id). +instances: + @for i in $$(seq 1 10); do \ + curl -s -o /dev/null -D - "$(BASE_URL)/health/live" | grep -i '^x-instance-id' || echo "нет X-Instance-Id"; \ + done + +# Генерация миграции против БД тестового стенда (основной стенд БД не публикует). +migration: + DB_HOST=localhost DB_PORT=$(TEST_DB_PORT) $(PYTHON) -m alembic revision --autogenerate -m "$(m)" + +# --- Тестовый стенд --- + +test-stand-up: + $(TEST_COMPOSE) up -d --build + $(call wait_ready,$(TEST_BASE_URL)) + $(TEST_COMPOSE) exec -T postgres sh -c 'createdb -U "$$POSTGRES_USER" "$$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true' + +test-stand-down: + $(TEST_COMPOSE) down + +test-stand-destroy: + $(TEST_COMPOSE) down -v + +test-stand-ps: + $(TEST_COMPOSE) ps + +test-stand-smoke: + $(PYTHON) tests/smoke.py --base-url "$(TEST_BASE_URL)" + +test-stand-persistence: + $(TEST_COMPOSE) ps + $(TEST_ENV) $(PYTHON) tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "$(TEST_BASE_URL)" + $(TEST_COMPOSE) ps + +test-stand-failover: + $(TEST_COMPOSE) ps + $(TEST_ENV) $(PYTHON) tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "$(TEST_BASE_URL)" + $(TEST_COMPOSE) ps -a api + $(TEST_COMPOSE) up -d --wait api + +# --- Собственные тесты (student-tests/) --- + +test-own: + $(PYTHON) -m pytest -q + +test-docker: + $(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q + +test-limits: + $(PYTHON) -m pytest student-tests/test_limits.py -q + +test-concurrency: + $(PYTHON) -m pytest student-tests/test_concurrency.py -q + +test-migrations: + $(PYTHON) -m pytest student-tests/test_migrations.py -q + +test-all: test-stand-up test-docker test-stand-smoke test-stand-persistence + +# --- Демо (на тестовом стенде) --- + +explain: + $(TEST_ENV) DB_HOST=localhost DB_PORT=$(TEST_DB_PORT) PYTHONPATH=. $(PYTHON) scripts/explain_history.py + +expiry-demo: test-stand-up + $(TEST_ENV) SESSION_TTL_SECONDS=3 $(COMPOSE) up -d api + $(call wait_ready,$(TEST_BASE_URL)) + BASE_URL=$(TEST_BASE_URL) TTL=3 scripts/expiry_demo.sh + $(TEST_COMPOSE) up -d api + $(call wait_ready,$(TEST_BASE_URL)) + +failure-demo: test-stand-up + $(TEST_ENV) BASE_URL=$(TEST_BASE_URL) scripts/failure_demo.sh diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..f95b20ac --- /dev/null +++ b/alembic.ini @@ -0,0 +1,38 @@ +[alembic] +script_location = migrations +prepend_sys_path = . +path_separator = os + +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..ee209955 --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,4 @@ +from app.main import main + +if __name__ == "__main__": + main() diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..20d0069b --- /dev/null +++ b/app/core/config.py @@ -0,0 +1,95 @@ +from enum import StrEnum +from typing import Literal, Self + +from pydantic import Field, SecretStr, model_validator +from pydantic_settings import BaseSettings, SettingsConfigDict +from sqlalchemy import URL + +ASYNC_DRIVER = "postgresql+asyncpg" + + +class LogLevel(StrEnum): + DEBUG = "DEBUG" + INFO = "INFO" + WARNING = "WARNING" + ERROR = "ERROR" + CRITICAL = "CRITICAL" + + +class Settings(BaseSettings): + app_host: str + app_port: int = Field(ge=1, le=65535) + app_env: str + log_level: LogLevel = LogLevel.INFO + + max_messages: int = Field(ge=1) + max_in_flight: int = Field(ge=1) + + session_ttl_seconds: int = Field(default=3600, ge=1) + session_store: Literal["redis"] = "redis" + + redis_host: str = "localhost" + redis_port: int = Field(default=6379, ge=1, le=65535) + redis_db: int = Field(default=0, ge=0) + redis_password: SecretStr | None = None + + redis_max_connections: int = Field(default=20, ge=1) + redis_pool_timeout_seconds: float = Field(default=1.0, gt=0) + redis_connect_timeout_seconds: float = Field(default=1.0, gt=0) + redis_socket_timeout_seconds: float = Field(default=0.5, gt=0) + + database_url: SecretStr | None = None + db_host: str | None = None + db_port: int = Field(default=5432, ge=1, le=65535) + db_name: str | None = None + db_user: str | None = None + db_password: SecretStr | None = None + + db_pool_size: int = Field(default=5, ge=1) + db_max_overflow: int = Field(default=5, ge=0) + db_pool_timeout_seconds: float = Field(default=3.0, gt=0) + 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) + + # 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", + ) + + @model_validator(mode="after") + def _require_database_source(self) -> Self: + 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}://") + return self + + 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" + ) + return self + + def get_database_url(self) -> str: + if self.database_url is not None: + return self.database_url.get_secret_value() + + assert self.db_password is not None + url = URL.create( + ASYNC_DRIVER, + username=self.db_user, + password=self.db_password.get_secret_value(), + host=self.db_host, + port=self.db_port, + database=self.db_name, + ) + return url.render_as_string(hide_password=False) diff --git a/app/core/database.py b/app/core/database.py new file mode 100644 index 00000000..c87bf430 --- /dev/null +++ b/app/core/database.py @@ -0,0 +1,44 @@ +import logging + +from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError +from sqlalchemy.ext.asyncio import ( + AsyncEngine, + AsyncSession, + async_sessionmaker, + create_async_engine, +) + +from app.core.config import Settings + +logger = logging.getLogger(__name__) + + +def create_db_engine(settings: Settings) -> AsyncEngine: + return create_async_engine( + settings.get_database_url(), + pool_size=settings.db_pool_size, + max_overflow=settings.db_max_overflow, + pool_timeout=settings.db_pool_timeout_seconds, + pool_pre_ping=True, + connect_args={ + "timeout": settings.db_connect_timeout_seconds, + "server_settings": { + "statement_timeout": str(settings.db_statement_timeout_ms) + }, + }, + ) + + +def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]: + return async_sessionmaker(bind=engine, expire_on_commit=False, autoflush=False) + + +async def check_database(engine: AsyncEngine) -> bool: + try: + async with engine.connect() as connection: + await connection.execute(text("SELECT 1")) + except (SQLAlchemyError, OSError, TimeoutError): + logger.warning("database readiness check failed", exc_info=True) + return False + return True diff --git a/app/core/instance.py b/app/core/instance.py new file mode 100644 index 00000000..6ab0d3f1 --- /dev/null +++ b/app/core/instance.py @@ -0,0 +1,40 @@ +"""Идентификатор API-реплики и заголовок X-Instance-Id.""" + +from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint +from starlette.requests import Request +from starlette.responses import Response + +INSTANCE_ID_HEADER = "X-Instance-Id" + + +def resolve_instance_id(configured: str | None) -> str: + """Возвращает id реплики, стабильный в течение жизни процесса. + + TODO(3.2): выбрать источник id. + - Если задан непустой INSTANCE_ID в настройках — вернуть его. + - Иначе — что-то, что позволит stop-one.sh найти именно этот контейнер + (подсказка: Docker кладёт короткий id контейнера в переменную HOSTNAME, + а `docker stop <короткий id>` работает). + - Значение вычисляется один раз при старте и не меняется до конца процесса. + """ + raise NotImplementedError("TODO(3.2): resolve_instance_id") + + +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) + self.instance_id = instance_id + + async def dispatch( + self, + request: Request, + call_next: RequestResponseEndpoint, + ) -> Response: + raise NotImplementedError("TODO(3.2): InstanceIdMiddleware.dispatch") diff --git a/app/core/lifecycle.py b/app/core/lifecycle.py new file mode 100644 index 00000000..5756d856 --- /dev/null +++ b/app/core/lifecycle.py @@ -0,0 +1,32 @@ +"""Состояние жизненного цикла реплики: готова / уходит (graceful shutdown). + +Идея: при SIGTERM реплика сначала перестаёт быть "ready" (/health/ready -> 503), +чтобы балансировщик успел исключить её, и только затем uvicorn перестаёт +принимать соединения и дожидается текущих запросов. +""" + + +class Lifecycle: + def __init__(self) -> None: + self._draining = False + + @property + def draining(self) -> bool: + 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. diff --git a/app/core/redis.py b/app/core/redis.py new file mode 100644 index 00000000..921d4d12 --- /dev/null +++ b/app/core/redis.py @@ -0,0 +1,38 @@ +import logging + +from redis.asyncio import BlockingConnectionPool, Redis +from redis.asyncio.retry import Retry +from redis.backoff import NoBackoff +from redis.exceptions import RedisError + +from app.core.config import Settings + +logger = logging.getLogger(__name__) + + +def create_redis_client(settings: Settings) -> Redis: + password = ( + settings.redis_password.get_secret_value() if settings.redis_password else None + ) + pool = BlockingConnectionPool( + host=settings.redis_host, + port=settings.redis_port, + db=settings.redis_db, + password=password, + max_connections=settings.redis_max_connections, + timeout=settings.redis_pool_timeout_seconds, + socket_connect_timeout=settings.redis_connect_timeout_seconds, + socket_timeout=settings.redis_socket_timeout_seconds, + retry=Retry(NoBackoff(), retries=1), + decode_responses=True, + ) + return Redis.from_pool(pool) + + +async def check_redis(client: Redis) -> bool: + try: + await client.ping() + except (RedisError, OSError): + logger.warning("redis readiness check failed", exc_info=True) + return False + return True diff --git a/app/core/request_capacity.py b/app/core/request_capacity.py new file mode 100644 index 00000000..acfb15a3 --- /dev/null +++ b/app/core/request_capacity.py @@ -0,0 +1,40 @@ +from collections.abc import AsyncIterator + +from fastapi import Request + +from app.errors.exceptions import rate_limited + + +class RequestCapacity: + def __init__(self, max_in_flight: int) -> None: + self._max_in_flight = max_in_flight + self._in_flight = 0 + + @property + def in_flight(self) -> int: + return self._in_flight + + def try_acquire(self) -> bool: + if self._in_flight >= self._max_in_flight: + return False + self._in_flight += 1 + return True + + def release(self) -> None: + self._in_flight -= 1 + + +def create_request_capacity(max_in_flight: int) -> RequestCapacity: + return RequestCapacity(max_in_flight) + + +async def acquire_request_slot(request: Request) -> AsyncIterator[None]: + capacity: RequestCapacity = request.app.state.request_capacity + + if not capacity.try_acquire(): + raise rate_limited() + + try: + yield + finally: + capacity.release() diff --git a/app/core/request_id.py b/app/core/request_id.py new file mode 100644 index 00000000..a78a8607 --- /dev/null +++ b/app/core/request_id.py @@ -0,0 +1,22 @@ +from uuid import uuid4 + +from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint +from starlette.requests import Request +from starlette.responses import Response + +REQUEST_ID_HEADER = "X-Request-Id" + + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch( + self, + request: Request, + call_next: RequestResponseEndpoint, + ) -> Response: + request_id = str(uuid4()) + request.state.request_id = request_id + + response = await call_next(request) + response.headers[REQUEST_ID_HEADER] = request_id + + return response diff --git a/app/core/security.py b/app/core/security.py new file mode 100644 index 00000000..70952e78 --- /dev/null +++ b/app/core/security.py @@ -0,0 +1,63 @@ +"""Хеширование паролей (Argon2id) и выпуск непрозрачных токенов сессий.""" + +import asyncio +import hashlib +import os +import secrets +from concurrent.futures import ThreadPoolExecutor + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +TOKEN_BYTES = 32 + +_hasher = PasswordHasher() +_executor = ThreadPoolExecutor( + max_workers=max(1, (os.cpu_count() or 1) // _hasher.parallelism), + thread_name_prefix="argon2", +) + + +def _hash_password_sync(password: str) -> str: + """Блокирующий расчёт Argon2id-хеша со случайной солью в формате PHC.""" + return _hasher.hash(password) + + +def _verify_password_sync(password: str, password_hash: str) -> bool: + """Блокирующая проверка пароля по PHC-строке; False при несовпадении или повреждённом хеше.""" + try: + return _hasher.verify(password_hash, password) + except (VerificationError, InvalidHashError): + return False + + +_DUMMY_HASH = _hash_password_sync(secrets.token_urlsafe(TOKEN_BYTES)) + + +async def hash_password(password: str) -> str: + """Хеширует пароль в пуле потоков, не блокируя event loop.""" + loop = asyncio.get_running_loop() + return await loop.run_in_executor(_executor, _hash_password_sync, password) + + +async def verify_password(password: str, password_hash: str) -> bool: + """Проверяет пароль в пуле потоков, не блокируя event loop.""" + loop = asyncio.get_running_loop() + return await loop.run_in_executor( + _executor, _verify_password_sync, password, password_hash + ) + + +async def dummy_verify_password(password: str) -> None: + """Проверка против фиктивного хеша: время ответа не выдаёт отсутствие пользователя.""" + await verify_password(password, _DUMMY_HASH) + + +def generate_token() -> str: + """Непрозрачный токен сессии: 32 случайных байта в base64url.""" + return secrets.token_urlsafe(TOKEN_BYTES) + + +def hash_token(token: str) -> str: + """SHA-256 токена в hex: детерминированный ключ для хранилища сессий.""" + return hashlib.sha256(token.encode()).hexdigest() diff --git a/app/domain/__init__.py b/app/domain/__init__.py new file mode 100644 index 00000000..93c96d54 --- /dev/null +++ b/app/domain/__init__.py @@ -0,0 +1 @@ +"""Бизнес-логика: проверки доступа, транзакции и ошибки API.""" diff --git a/app/domain/auth.py b/app/domain/auth.py new file mode 100644 index 00000000..63f4f3cc --- /dev/null +++ b/app/domain/auth.py @@ -0,0 +1,84 @@ +import re +from datetime import UTC, datetime, timedelta + +from redis.asyncio import Redis +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core import security +from app.domain.users import to_user_schema +from app.errors.exceptions import unauthorized_basic, unauthorized_bearer +from app.schemas.session import AuthSession +from app.schemas.user import ( + PASSWORD_MAX_LENGTH, + PASSWORD_MIN_LENGTH, + USERNAME_PATTERN, + User, +) +from app.storage import sessions as sessions_storage +from app.storage import users as users_storage + +USERNAME_RE = re.compile(USERNAME_PATTERN) + + +async def create_session( + session: AsyncSession, + redis: Redis, + username: str, + password: str, + ttl_seconds: int, +) -> AuthSession: + """Проверяет учётные данные и выдаёт новый Bearer-токен.""" + if ( + USERNAME_RE.fullmatch(username) is None + or not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH + or not password.strip() + ): + raise unauthorized_basic() + + user = await users_storage.get_user_by_username(session, username) + await session.commit() + + if user is None: + await security.dummy_verify_password(password) + raise unauthorized_basic() + + if not await security.verify_password(password, user.password_hash): + raise unauthorized_basic() + + token = security.generate_token() + expires_at = datetime.now(UTC) + timedelta(seconds=ttl_seconds) + await sessions_storage.create_session( + redis, + token_hash=security.hash_token(token), + user_id=user.id, + expires_at=expires_at, + ) + auth_session = AuthSession( + token=token, expires_at=expires_at, user=to_user_schema(user) + ) + return auth_session + + +async def authenticate_token(session: AsyncSession, redis: Redis, token: str) -> User: + """Возвращает владельца действующей сессии или бросает 401.""" + user_id = await sessions_storage.get_session_user_id( + redis, security.hash_token(token) + ) + if user_id is None: + raise unauthorized_bearer() + + user = await users_storage.get_user_by_id(session, user_id) + if user is None: + raise unauthorized_bearer() + + current_user = to_user_schema(user) + return current_user + + +async def revoke_session(redis: Redis, token: str) -> None: + """Отзывает текущую сессию; повторный отзыв даёт 401.""" + is_deleted = await sessions_storage.delete_session( + redis, security.hash_token(token) + ) + if not is_deleted: + raise unauthorized_bearer() diff --git a/app/domain/chats.py b/app/domain/chats.py new file mode 100644 index 00000000..c810a982 --- /dev/null +++ b/app/domain/chats.py @@ -0,0 +1,104 @@ +from uuid import UUID + +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import AsyncSession + +from app.domain.pagination import ( + KIND_CHATS, + build_next_cursor, + decode_cursor, + split_page, +) +from app.errors.exceptions import invalid_request, not_found +from app.models.chat import Chat as ChatModel +from app.schemas.chat import Chat, ChatPage, CreateChat +from app.schemas.user import User +from app.storage import chats as chats_storage +from app.storage import users as users_storage +from app.storage.types import Position + +UNKNOWN_MEMBER_MESSAGE = "member_ids содержит неизвестного пользователя" + + +def to_chat_schema(chat: ChatModel) -> Chat: + """Преобразует ORM-модель чата с загруженными участниками в схему.""" + chat_schema = Chat( + id=chat.id, + title=chat.title, + member_ids=[member.user_id for member in chat.members], + created_at=chat.created_at, + ) + return chat_schema + + +def validate_new_chat(creator: User, new_chat: CreateChat) -> None: + """Проверяет состав участников без обращения к базе.""" + member_ids = new_chat.member_ids + + if creator.id not in member_ids: + raise invalid_request("Создатель чата должен входить в member_ids") + + if len(set(member_ids)) != len(member_ids): + raise invalid_request("member_ids содержит дубликаты") + + +async def create_chat( + session: AsyncSession, creator: User, new_chat: CreateChat +) -> Chat: + """Создаёт чат с участниками атомарно; неверный состав даёт 400.""" + validate_new_chat(creator, new_chat) + + existing_ids = await users_storage.get_existing_user_ids( + session, new_chat.member_ids + ) + if existing_ids != set(new_chat.member_ids): + raise invalid_request(UNKNOWN_MEMBER_MESSAGE) + + try: + chat = await chats_storage.create_chat( + session, title=new_chat.title, member_ids=new_chat.member_ids + ) + await session.commit() + except IntegrityError: + await session.rollback() + raise invalid_request(UNKNOWN_MEMBER_MESSAGE) from None + + created_chat = to_chat_schema(chat) + return created_chat + + +async def get_chat(session: AsyncSession, user: User, chat_id: UUID) -> Chat: + """Возвращает чат участнику; чужой и несуществующий чат дают 404.""" + chat = await chats_storage.get_chat_for_member(session, chat_id, user.id) + if chat is None: + raise not_found() + + found_chat = to_chat_schema(chat) + return found_chat + + +async def ensure_chat_member(session: AsyncSession, user: User, chat_id: UUID) -> None: + """Бросает 404, если пользователь не состоит в чате или чата нет.""" + if not await chats_storage.is_chat_member(session, chat_id, user.id): + raise not_found() + + +async def list_chats( + session: AsyncSession, + user: User, + cursor: str | None, + limit: int, +) -> ChatPage: + """Возвращает страницу чатов пользователя по (created_at, id).""" + after: Position | None = None + if cursor is not None: + after = decode_cursor(cursor, KIND_CHATS, user.id) + + rows = await chats_storage.list_chats_for_user(session, user.id, after, limit + 1) + page_rows, has_next = split_page(rows, limit) + items = [to_chat_schema(chat) for chat in page_rows] + page = ChatPage( + items=items, + next_cursor=build_next_cursor(KIND_CHATS, user.id, items, has_next), + ) + return page diff --git a/app/domain/idempotency.py b/app/domain/idempotency.py new file mode 100644 index 00000000..c5e1cff1 --- /dev/null +++ b/app/domain/idempotency.py @@ -0,0 +1,75 @@ +"""Идемпотентность POST сообщения, общая для всех API-реплик. + +Семантика: + - ключ: ASCII [A-Za-z0-9._:-]{1,128}; нет/неверный — 400; + - область уникальности: пользователь + метод + путь чата + ключ; + - тот же JSON в течение 24 ч -> тот же 201 и то же Message; + - другой JSON с тем же ключом -> 409; + - одновременные повторы через разные реплики -> ровно одно сообщение; + - повтор снова проверяет сессию и членство в чате; + - транзиентная 5xx не фиксируется как окончательный результат; + - побочный эффект (INSERT сообщения) и запись результата — атомарно. +""" + +import hashlib +import json +import re +from uuid import UUID + +from sqlalchemy.ext.asyncio import AsyncSession + +from app.schemas.message import CreateMessage, Message +from app.schemas.user import User + +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") + + +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 + ) + return hashlib.sha256(canonical.encode()).hexdigest() + + +async def send_message_idempotent( + session: AsyncSession, + sender: User, + chat_id: UUID, + new_message: CreateMessage, + idempotency_key: str, + max_messages: int, + ttl_seconds: int, +) -> Message: + """Отправляет сообщение ровно один раз для (sender, POST, chat_id, key). + + 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") diff --git a/app/domain/messages.py b/app/domain/messages.py new file mode 100644 index 00000000..2f7405f1 --- /dev/null +++ b/app/domain/messages.py @@ -0,0 +1,62 @@ +from uuid import UUID + +from sqlalchemy.ext.asyncio import AsyncSession + +from app.domain.chats import ensure_chat_member +from app.domain.pagination import ( + KIND_MESSAGES, + build_next_cursor, + decode_cursor, + split_page, +) +from app.errors.exceptions import unavailable +from app.schemas.message import CreateMessage, 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, + chat_id: UUID, + cursor: str | None, + limit: int, +) -> MessagePage: + """Возвращает страницу истории чата по (created_at, id).""" + after: Position | None = None + if cursor is not None: + after = decode_cursor(cursor, KIND_MESSAGES, chat_id) + + await ensure_chat_member(session, user, chat_id) + + rows = await messages_storage.list_messages(session, chat_id, after, limit + 1) + page_rows, has_next = split_page(rows, limit) + items = [Message.model_validate(message) for message in page_rows] + page = MessagePage( + items=items, + next_cursor=build_next_cursor(KIND_MESSAGES, chat_id, items, has_next), + ) + return page diff --git a/app/domain/pagination.py b/app/domain/pagination.py new file mode 100644 index 00000000..9894437c --- /dev/null +++ b/app/domain/pagination.py @@ -0,0 +1,83 @@ +import base64 +import json +from collections.abc import Sequence +from datetime import datetime +from typing import Protocol, TypeVar +from uuid import UUID + +from app.errors.exceptions import invalid_request +from app.storage.types import Position + +KIND_CHATS = "chats" +KIND_MESSAGES = "messages" + +T = TypeVar("T") + + +class Positioned(Protocol): + """Объект с позицией в порядке (created_at, id).""" + + @property + def id(self) -> UUID: ... + + @property + def created_at(self) -> datetime: ... + + +def encode_cursor( + kind: str, + resource_id: UUID, + created_at: datetime, + item_id: UUID, +) -> str: + """Кодирует позицию и ресурс, к которому она привязана, в непрозрачный cursor.""" + payload = { + "kind": kind, + "resource_id": str(resource_id), + "created_at": created_at.isoformat(), + "item_id": str(item_id), + } + raw = json.dumps(payload).encode() + return base64.urlsafe_b64encode(raw).decode() + + +def decode_cursor(cursor: str, kind: str, resource_id: UUID) -> Position: + """Возвращает позицию из cursor; битый или чужой cursor даёт 400.""" + try: + payload = json.loads(base64.urlsafe_b64decode(cursor)) + cursor_kind = payload["kind"] + cursor_resource_id = UUID(payload["resource_id"]) + created_at = datetime.fromisoformat(payload["created_at"]) + item_id = UUID(payload["item_id"]) + except (ValueError, KeyError, TypeError, AttributeError): + raise invalid_request("Некорректный cursor") from None + + if ( + cursor_kind != kind + or cursor_resource_id != resource_id + or created_at.tzinfo is None + ): + raise invalid_request("Некорректный cursor") + + return created_at, item_id + + +def split_page(rows: list[T], limit: int) -> tuple[list[T], bool]: + """Отделяет страницу от лишней строки limit + 1, по которой видно продолжение.""" + has_next = len(rows) > limit + items = rows[:limit] + return items, has_next + + +def build_next_cursor( + kind: str, + resource_id: UUID, + items: Sequence[Positioned], + has_next: bool, +) -> str | None: + """Возвращает cursor на последний элемент страницы или None, если она последняя.""" + if not has_next: + return None + + last_item = items[-1] + return encode_cursor(kind, resource_id, last_item.created_at, last_item.id) diff --git a/app/domain/users.py b/app/domain/users.py new file mode 100644 index 00000000..461bf0d9 --- /dev/null +++ b/app/domain/users.py @@ -0,0 +1,41 @@ +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core import security +from app.errors.exceptions import conflict +from app.models.user import User as UserModel +from app.schemas.user import CreateUser, User +from app.storage import users as users_storage + +USERNAME_TAKEN_MESSAGE = "Имя пользователя уже занято" + + +def to_user_schema(user: UserModel) -> User: + """Преобразует ORM-модель в публичную схему без password_hash.""" + user_schema = User.model_validate(user) + return user_schema + + +async def register_user(session: AsyncSession, new_user: CreateUser) -> User: + """Регистрирует пользователя; занятый username даёт 409.""" + existing_user = await users_storage.get_user_by_username(session, new_user.username) + await session.commit() + if existing_user is not None: + raise conflict(USERNAME_TAKEN_MESSAGE) + + password_hash = await security.hash_password(new_user.password) + + try: + user = await users_storage.create_user( + session, + username=new_user.username, + display_name=new_user.display_name, + password_hash=password_hash, + ) + await session.commit() + except IntegrityError: + await session.rollback() + raise conflict(USERNAME_TAKEN_MESSAGE) from None + + created_user = to_user_schema(user) + return created_user diff --git a/app/endpoints/__init__.py b/app/endpoints/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/endpoints/auth.py b/app/endpoints/auth.py new file mode 100644 index 00000000..69f4535f --- /dev/null +++ b/app/endpoints/auth.py @@ -0,0 +1,32 @@ +from fastapi import APIRouter, Response + +from app.domain.auth import create_session, revoke_session +from app.endpoints.dependencies import ( + AppSettings, + BasicCredentials, + BearerToken, + DbSession, + RedisClient, +) +from app.schemas.session import AuthSession + +router = APIRouter(prefix="/api/v1/auth", tags=["auth"]) + + +@router.post("/sessions", status_code=201) +async def login( + credentials: BasicCredentials, + session: DbSession, + redis: RedisClient, + settings: AppSettings, +) -> AuthSession: + username, password = credentials + return await create_session( + session, redis, username, password, settings.session_ttl_seconds + ) + + +@router.delete("/sessions/current", status_code=204) +async def logout(token: BearerToken, redis: RedisClient) -> Response: + await revoke_session(redis, token) + return Response(status_code=204) diff --git a/app/endpoints/chats.py b/app/endpoints/chats.py new file mode 100644 index 00000000..91f2b211 --- /dev/null +++ b/app/endpoints/chats.py @@ -0,0 +1,32 @@ +from typing import Annotated +from uuid import UUID + +from fastapi import APIRouter, Query + +from app.domain.chats import create_chat, get_chat, list_chats +from app.endpoints.dependencies import CurrentUser, DbSession +from app.schemas.chat import Chat, ChatPage, CreateChat + +router = APIRouter(prefix="/api/v1/chats", tags=["chats"]) + + +@router.post("", status_code=201) +async def create_new_chat( + new_chat: CreateChat, creator: CurrentUser, session: DbSession +) -> Chat: + return await create_chat(session, creator, new_chat) + + +@router.get("") +async def list_user_chats( + user: CurrentUser, + session: DbSession, + limit: Annotated[int, Query(ge=1, le=100)] = 50, + cursor: Annotated[str | None, Query(min_length=1)] = None, +) -> ChatPage: + return await list_chats(session, user, cursor, limit) + + +@router.get("/{chat_id}") +async def get_chat_by_id(chat_id: UUID, user: CurrentUser, session: DbSession) -> Chat: + return await get_chat(session, user, chat_id) diff --git a/app/endpoints/dependencies.py b/app/endpoints/dependencies.py new file mode 100644 index 00000000..eccb50dd --- /dev/null +++ b/app/endpoints/dependencies.py @@ -0,0 +1,100 @@ +import base64 +import binascii +from collections.abc import AsyncIterator +from typing import Annotated + +from fastapi import Depends, Request, Security +from fastapi.openapi.models import HTTPBase, HTTPBearer +from fastapi.security.base import SecurityBase +from redis.asyncio import Redis +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.config import Settings +from app.domain.auth import authenticate_token +from app.errors.exceptions import unauthorized_basic, unauthorized_bearer +from app.schemas.user import User + + +async def get_settings(request: Request) -> Settings: + settings: Settings = request.app.state.settings + return settings + + +async def get_db(request: Request) -> AsyncIterator[AsyncSession]: + """Одна AsyncSession на HTTP-запрос; незакоммиченная транзакция откатывается.""" + session_factory = request.app.state.session_factory + async with session_factory() as session: + yield session + + +async def get_redis(request: Request) -> Redis: + redis: Redis = request.app.state.redis + return redis + + +class AuthorizationHeader(SecurityBase): + """Отдаёт сырой заголовок Authorization и описывает схему для OpenAPI.""" + + def __init__(self, model: HTTPBase, scheme_name: str) -> None: + self.model = model + self.scheme_name = scheme_name + + async def __call__(self, request: Request) -> str | None: + return request.headers.get("Authorization") + + +basic_auth = AuthorizationHeader(HTTPBase(scheme="basic"), "BasicAuth") +bearer_auth = AuthorizationHeader(HTTPBearer(), "BearerAuth") + + +def _split_authorization(authorization: str | None) -> tuple[str, str] | None: + if authorization is None: + return None + scheme, _, value = authorization.partition(" ") + if not value.strip(): + return None + return scheme.lower(), value.strip() + + +async def get_bearer_token( + authorization: Annotated[str | None, Security(bearer_auth)], +) -> str: + parts = _split_authorization(authorization) + if parts is None or parts[0] != "bearer": + raise unauthorized_bearer() + return parts[1] + + +async def get_basic_credentials( + authorization: Annotated[str | None, Security(basic_auth)], +) -> tuple[str, str]: + """(username, password) из `Authorization: Basic`; пароль может содержать ':'.""" + parts = _split_authorization(authorization) + if parts is None or parts[0] != "basic": + raise unauthorized_basic() + + try: + decoded = base64.b64decode(parts[1], validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError): + raise unauthorized_basic() from None + + username, separator, password = decoded.partition(":") + if not separator or not username: + raise unauthorized_basic() + return username, password + + +DbSession = Annotated[AsyncSession, Depends(get_db)] +RedisClient = Annotated[Redis, Depends(get_redis)] +AppSettings = Annotated[Settings, Depends(get_settings)] +BearerToken = Annotated[str, Depends(get_bearer_token)] +BasicCredentials = Annotated[tuple[str, str], Depends(get_basic_credentials)] + + +async def get_current_user( + token: BearerToken, session: DbSession, redis: RedisClient +) -> User: + return await authenticate_token(session, redis, token) + + +CurrentUser = Annotated[User, Depends(get_current_user)] diff --git a/app/endpoints/health.py b/app/endpoints/health.py new file mode 100644 index 00000000..daf8a37f --- /dev/null +++ b/app/endpoints/health.py @@ -0,0 +1,26 @@ +from fastapi import APIRouter, Request + +from app.core.database import check_database +from app.core.redis import check_redis +from app.errors.exceptions import unavailable +from app.schemas.base import Health + +router = APIRouter(prefix="/health", tags=["health"]) + + +@router.get("/live") +async def liveness() -> Health: + return Health(status="ok") + + +@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): + raise unavailable() + if not await check_redis(request.app.state.redis): + raise unavailable() + return Health(status="ok") diff --git a/app/endpoints/messages.py b/app/endpoints/messages.py new file mode 100644 index 00000000..f8a734d9 --- /dev/null +++ b/app/endpoints/messages.py @@ -0,0 +1,39 @@ +from typing import Annotated +from uuid import UUID + +from fastapi import APIRouter, Query + +from app.domain.messages import list_messages, send_message +from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession +from app.schemas.message import CreateMessage, Message, MessagePage + +router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) + + +@router.post("/{chat_id}/messages", status_code=201) +async def send_new_message( + chat_id: UUID, + new_message: CreateMessage, + 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, чтобы текст ошибки был в общем формате. +) -> Message: + return await send_message( + session, sender, chat_id, new_message, settings.max_messages + ) + + +@router.get("/{chat_id}/messages") +async def get_history_messages( + chat_id: UUID, + user: CurrentUser, + session: DbSession, + limit: Annotated[int, Query(ge=1, le=100)] = 50, + cursor: Annotated[str | None, Query(min_length=1)] = None, +) -> MessagePage: + return await list_messages(session, user, chat_id, cursor, limit) diff --git a/app/endpoints/users.py b/app/endpoints/users.py new file mode 100644 index 00000000..c502d010 --- /dev/null +++ b/app/endpoints/users.py @@ -0,0 +1,17 @@ +from fastapi import APIRouter + +from app.domain.users import register_user +from app.endpoints.dependencies import CurrentUser, DbSession +from app.schemas.user import CreateUser, User + +router = APIRouter(prefix="/api/v1/users", tags=["users"]) + + +@router.post("", status_code=201) +async def create_user(new_user: CreateUser, session: DbSession) -> User: + return await register_user(session, new_user) + + +@router.get("/me") +async def get_me(user: CurrentUser) -> User: + return user diff --git a/app/errors/__init__.py b/app/errors/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/errors/exceptions.py b/app/errors/exceptions.py new file mode 100644 index 00000000..92aa2820 --- /dev/null +++ b/app/errors/exceptions.py @@ -0,0 +1,85 @@ +from collections.abc import Mapping + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +class ApiError(Exception): + def __init__( + self, + status_code: int, + code: str, + message: str, + headers: Mapping[str, str] | None = None, + ) -> None: + super().__init__(message) + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers + + +def invalid_request(message: str = "Неверный запрос") -> ApiError: + """Создаёт ошибку некорректного или недопустимого запроса.""" + return ApiError(400, "invalid_request", message) + + +def unauthorized( + message: str = "Нет действительной аутентификации", + www_authenticate: str | None = None, +) -> ApiError: + """Создаёт ошибку отсутствующей или недействительной аутентификации.""" + headers = {"WWW-Authenticate": www_authenticate} if www_authenticate else None + return ApiError(401, "unauthorized", message, headers) + + +def unauthorized_basic(message: str = "Неверные учётные данные") -> ApiError: + """401 для POST /auth/sessions (одинаковый для неверного username и пароля).""" + return unauthorized(message, BASIC_CHALLENGE) + + +def unauthorized_bearer(message: str = "Нет действительной сессии") -> ApiError: + """401 для бизнес-endpoint: нет, истёк, отозван или неизвестен токен.""" + return unauthorized(message, BEARER_CHALLENGE) + + +def not_found(message: str = "Объект не найден") -> ApiError: + """Создаёт ошибку, указывающую на отсутствие запрошенного ресурса.""" + return ApiError(404, "not_found", message) + + +def conflict(message: str = "Конфликт") -> ApiError: + """Создаёт ошибку конфликта с текущим состоянием ресурса.""" + return ApiError(409, "conflict", message) + + +def payload_too_large(message: str = "Слишком большое тело запроса") -> ApiError: + """Создаёт ошибку, указывающую на превышение допустимого размера запроса.""" + return ApiError(413, "payload_too_large", message) + + +def unsupported_media_type( + message: str = "Требуется Content-Type: application/json", +) -> ApiError: + """Создаёт ошибку неподдерживаемого формата или типа содержимого запроса.""" + return ApiError(415, "unsupported_media_type", message) + + +def rate_limited(retry_after: int = 1) -> ApiError: + """Создаёт ошибку превышения допустимой частоты запросов.""" + return ApiError( + 429, + "rate_limited", + "Слишком много запросов", + {"Retry-After": str(max(1, retry_after))}, + ) + + +def unavailable(message: str = "Сервис временно недоступен") -> ApiError: + """Создаёт ошибку временной недоступности сервиса.""" + return ApiError(503, "unavailable", message) + + +def internal_error() -> ApiError: + """Создаёт ошибку внутренней ошибки сервера.""" + return ApiError(500, "internal_error", "Внутренняя ошибка сервера") diff --git a/app/errors/handlers.py b/app/errors/handlers.py new file mode 100644 index 00000000..8aa80a78 --- /dev/null +++ b/app/errors/handlers.py @@ -0,0 +1,197 @@ +import logging +from collections.abc import Mapping +from uuid import uuid4 + +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from redis.exceptions import ConnectionError as RedisConnectionError +from redis.exceptions import TimeoutError as RedisTimeoutError +from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError +from sqlalchemy.exc import TimeoutError as PoolTimeoutError +from starlette.exceptions import HTTPException as StarletteHTTPException + +from app.core.request_id import REQUEST_ID_HEADER +from app.errors.exceptions import ApiError, internal_error, unavailable + +logger = logging.getLogger(__name__) + +TRANSIENT_SQLSTATE_CLASSES = ("08", "40", "53", "57") +TRANSIENT_SQLSTATES = frozenset({"55P03"}) + + +def _get_request_id(request: Request) -> str: + request_id = getattr(request.state, "request_id", None) + + if request_id is None: + request_id = str(uuid4()) + request.state.request_id = request_id + + return request_id + + +def _build_response( + request: Request, + status_code: int, + code: str, + message: str, + headers: Mapping[str, str] | None = None, +) -> JSONResponse: + request_id = _get_request_id(request) + + response_headers = { + **(headers or {}), + REQUEST_ID_HEADER: request_id, + } + + body = { + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + } + + return JSONResponse( + status_code=status_code, + content=body, + headers=response_headers, + ) + + +async def api_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + assert isinstance(exc, ApiError) + + return _build_response( + request, + exc.status_code, + exc.code, + exc.message, + exc.headers, + ) + + +async def routing_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + assert isinstance(exc, StarletteHTTPException) + + if exc.status_code == 404: + return _build_response( + request, + 404, + "not_found", + "Объект не найден", + exc.headers, + ) + + return _build_response( + request, + exc.status_code, + "invalid_request", + "Неверный запрос", + exc.headers, + ) + + +async def validation_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + assert isinstance(exc, RequestValidationError) + + fields = sorted({".".join(map(str, error["loc"])) for error in exc.errors()}) + message = "Неверный запрос" + + if fields: + message = f"{message}: {', '.join(fields)}" + + return _build_response( + request, + 400, + "invalid_request", + message, + ) + + +async def dependency_unavailable_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + """PostgreSQL или Redis недоступны либо исчерпан пул: 503 без внутренних деталей.""" + request_id = _get_request_id(request) + logger.error( + "Dependency unavailable request_id=%s: %s", + request_id, + type(exc).__name__, + exc_info=exc, + ) + + error = unavailable() + return _build_response( + request, + error.status_code, + error.code, + error.message, + {"Retry-After": "1"}, + ) + + +def _is_transient_database_error(exc: DBAPIError) -> bool: + sqlstate = getattr(exc.orig, "sqlstate", None) or "" + return ( + sqlstate.startswith(TRANSIENT_SQLSTATE_CLASSES) + or sqlstate in TRANSIENT_SQLSTATES + ) + + +async def database_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + """Временные ошибки PostgreSQL (таймаут запроса, блокировки, нехватка ресурсов) — 503.""" + assert isinstance(exc, DBAPIError) + + if _is_transient_database_error(exc): + return await dependency_unavailable_handler(request, exc) + return await unhandled_error_handler(request, exc) + + +async def unhandled_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + request_id = _get_request_id(request) + + logger.error( + "Unhandled error request_id=%s", + request_id, + exc_info=exc, + ) + + error = internal_error() + + return _build_response( + request, + error.status_code, + error.code, + error.message, + ) + + +def register_exception_handlers(app: FastAPI) -> None: + app.add_exception_handler(ApiError, api_error_handler) + app.add_exception_handler(StarletteHTTPException, routing_error_handler) + app.add_exception_handler(RequestValidationError, validation_error_handler) + app.add_exception_handler(OperationalError, dependency_unavailable_handler) + app.add_exception_handler(InterfaceError, dependency_unavailable_handler) + app.add_exception_handler(PoolTimeoutError, dependency_unavailable_handler) + app.add_exception_handler(DBAPIError, database_error_handler) + app.add_exception_handler(RedisConnectionError, dependency_unavailable_handler) + app.add_exception_handler(RedisTimeoutError, dependency_unavailable_handler) + app.add_exception_handler(OSError, dependency_unavailable_handler) + app.add_exception_handler(Exception, unhandled_error_handler) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..f0a4c12a --- /dev/null +++ b/app/main.py @@ -0,0 +1,80 @@ +import logging +from collections.abc import AsyncGenerator +from contextlib import asynccontextmanager + +import uvicorn +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.redis import create_redis_client +from app.core.request_capacity import acquire_request_slot, create_request_capacity +from app.core.request_id import RequestIdMiddleware +from app.endpoints.auth import router as auth_router +from app.endpoints.chats import router as chats_router +from app.endpoints.health import router as health_router +from app.endpoints.messages import router as messages_router +from app.endpoints.users import router as users_router +from app.errors.handlers import register_exception_handlers + + +def configure_logging(settings: Settings) -> None: + logging.basicConfig( + level=settings.log_level, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + ) + + +def create_app(settings: Settings | None = None) -> FastAPI: + settings = settings or Settings() # type: ignore + configure_logging(settings) + + engine = create_db_engine(settings) + redis = create_redis_client(settings) + + @asynccontextmanager + async def lifespan(_: FastAPI) -> AsyncGenerator[None]: + yield + await redis.aclose() + await engine.dispose() + + application = FastAPI(title="Messenger", version="1.3.0", lifespan=lifespan) + + application.state.settings = settings + application.state.engine = engine + 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.add_middleware(RequestIdMiddleware) + register_exception_handlers(application) + + limited = [Depends(acquire_request_slot)] + application.include_router(health_router) + application.include_router(users_router, dependencies=limited) + application.include_router(auth_router, dependencies=limited) + application.include_router(chats_router, dependencies=limited) + application.include_router(messages_router, dependencies=limited) + + return application + + +def main() -> None: + settings = Settings() # type: ignore + uvicorn.run( + "app.main:create_app", + factory=True, + 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, + ) + + +if __name__ == "__main__": + main() diff --git a/app/models/__init__.py b/app/models/__init__.py new file mode 100644 index 00000000..9d56e6e2 --- /dev/null +++ b/app/models/__init__.py @@ -0,0 +1,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.message import Message +from app.models.user import User + +__all__ = ["Base", "Chat", "ChatMember", "Counter", "Message", "User"] diff --git a/app/models/base.py b/app/models/base.py new file mode 100644 index 00000000..15a748e5 --- /dev/null +++ b/app/models/base.py @@ -0,0 +1,27 @@ +import uuid +from datetime import datetime +from typing import Any, ClassVar + +from sqlalchemy import DateTime, MetaData +from sqlalchemy.dialects.postgresql import UUID as PG_UUID +from sqlalchemy.orm import DeclarativeBase +from sqlalchemy.types import TypeEngine + +NAMING_CONVENTION = { + "ix": "ix_%(column_0_label)s", + "uq": "uq_%(table_name)s_%(column_0_name)s", + "ck": "ck_%(table_name)s_%(constraint_name)s", + "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s", + "pk": "pk_%(table_name)s", +} + + +class Base(DeclarativeBase): + """Базовый класс ORM-моделей.""" + + metadata = MetaData(naming_convention=NAMING_CONVENTION) + + type_annotation_map: ClassVar[dict[Any, TypeEngine[Any]]] = { + uuid.UUID: PG_UUID(as_uuid=True), + datetime: DateTime(timezone=True), + } diff --git a/app/models/chat.py b/app/models/chat.py new file mode 100644 index 00000000..ffff7ec2 --- /dev/null +++ b/app/models/chat.py @@ -0,0 +1,32 @@ +import uuid +from datetime import datetime +from typing import TYPE_CHECKING + +from sqlalchemy import String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + +if TYPE_CHECKING: + from app.models.chat_member import ChatMember + from app.models.message import Message + + +class Chat(Base): + """Чат с фиксированным составом участников.""" + + __tablename__ = "chats" + + id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + title: Mapped[str] = mapped_column(String(100)) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + members: Mapped[list["ChatMember"]] = relationship( + back_populates="chat", + cascade="all, delete-orphan", + passive_deletes=True, + lazy="selectin", + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="chat", lazy="raise" + ) diff --git a/app/models/chat_member.py b/app/models/chat_member.py new file mode 100644 index 00000000..567ffd66 --- /dev/null +++ b/app/models/chat_member.py @@ -0,0 +1,26 @@ +import uuid +from typing import TYPE_CHECKING + +from sqlalchemy import ForeignKey, Index +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + +if TYPE_CHECKING: + from app.models.chat import Chat + from app.models.user import User + + +class ChatMember(Base): + """Членство пользователя в чате.""" + + __tablename__ = "chat_members" + __table_args__ = (Index("ix_chat_members_user_id_chat_id", "user_id", "chat_id"),) + + chat_id: Mapped[uuid.UUID] = mapped_column( + ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True + ) + user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True) + + chat: Mapped["Chat"] = relationship(back_populates="members", lazy="raise") + user: Mapped["User"] = relationship(back_populates="memberships", lazy="raise") diff --git a/app/models/counter.py b/app/models/counter.py new file mode 100644 index 00000000..5f6706b5 --- /dev/null +++ b/app/models/counter.py @@ -0,0 +1,13 @@ +from sqlalchemy import BigInteger, String +from sqlalchemy.orm import Mapped, mapped_column + +from app.models.base import Base + + +class Counter(Base): + """Именованный счётчик с атомарным обновлением.""" + + __tablename__ = "counters" + + name: Mapped[str] = mapped_column(String(64), primary_key=True) + value: Mapped[int] = mapped_column(BigInteger) diff --git a/app/models/idempotency_key.py b/app/models/idempotency_key.py new file mode 100644 index 00000000..7c10fdd2 --- /dev/null +++ b/app/models/idempotency_key.py @@ -0,0 +1,28 @@ +"""ORM-модель записи идемпотентности. + +TODO(3.4): раскомментировать/доработать, добавить в app/models/__init__.py +и сгенерировать миграцию: `make migration m="add idempotency keys"` +(с поднятой БД), затем проверить сгенерированный файл руками. + +Примерная схема: + + class IdempotencyKey(Base): + __tablename__ = "idempotency_keys" + __table_args__ = ( + PrimaryKeyConstraint("user_id", "method", "path", "key"), + Index("ix_idempotency_keys_created_at", "created_at"), # для чистки по TTL + ) + + 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. +""" diff --git a/app/models/message.py b/app/models/message.py new file mode 100644 index 00000000..25dc8cf3 --- /dev/null +++ b/app/models/message.py @@ -0,0 +1,30 @@ +import uuid +from datetime import datetime +from typing import TYPE_CHECKING + +from sqlalchemy import ForeignKey, Index, Text, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + +if TYPE_CHECKING: + from app.models.chat import Chat + from app.models.user import User + + +class Message(Base): + """Сообщение в чате.""" + + __tablename__ = "messages" + __table_args__ = ( + Index("ix_messages_chat_id_created_at_id", "chat_id", "created_at", "id"), + ) + + id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + chat_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("chats.id")) + sender_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id")) + text: Mapped[str] = mapped_column(Text) + created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp()) + + chat: Mapped["Chat"] = relationship(back_populates="messages", lazy="raise") + sender: Mapped["User"] = relationship(back_populates="messages", lazy="raise") diff --git a/app/models/user.py b/app/models/user.py new file mode 100644 index 00000000..74b690e6 --- /dev/null +++ b/app/models/user.py @@ -0,0 +1,31 @@ +import uuid +from datetime import datetime +from typing import TYPE_CHECKING + +from sqlalchemy import String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + +if TYPE_CHECKING: + from app.models.chat_member import ChatMember + from app.models.message import Message + + +class User(Base): + """Пользователь и его учётные данные.""" + + __tablename__ = "users" + + id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + username: Mapped[str] = mapped_column(String(32), unique=True) + display_name: Mapped[str] = mapped_column(String(100)) + password_hash: Mapped[str] = mapped_column(String(255)) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + memberships: Mapped[list["ChatMember"]] = relationship( + back_populates="user", lazy="raise" + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="sender", lazy="raise" + ) diff --git a/app/schemas/__init__.py b/app/schemas/__init__.py new file mode 100644 index 00000000..2f038940 --- /dev/null +++ b/app/schemas/__init__.py @@ -0,0 +1,6 @@ +from app.schemas.chat import Chat +from app.schemas.message import Message +from app.schemas.session import AuthSession +from app.schemas.user import User + +__all__ = ["AuthSession", "Chat", "Message", "User"] diff --git a/app/schemas/base.py b/app/schemas/base.py new file mode 100644 index 00000000..ca7f4de8 --- /dev/null +++ b/app/schemas/base.py @@ -0,0 +1,35 @@ +from typing import Literal +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, field_validator + + +class Base(BaseModel): + model_config = ConfigDict(extra="forbid", from_attributes=True) + + id: UUID + + +class Health(BaseModel): + model_config = ConfigDict(extra="forbid") + + status: Literal["ok"] + + +class BaseCreate(BaseModel): + model_config = ConfigDict(extra="forbid") + + @field_validator("*", mode="before") + @classmethod + def reject_invalid_strings(cls, value: object) -> object: + """Отклоняет строки из одних пробелов и строки с NUL, который не хранит PostgreSQL.""" + if isinstance(value, str): + if not value.strip(): + raise ValueError("Строка не может состоять только из пробелов") + if "\x00" in value: + raise ValueError("Строка не может содержать символ NUL") + return value + + +class BasePage(BaseModel): + model_config = ConfigDict(extra="forbid") diff --git a/app/schemas/chat.py b/app/schemas/chat.py new file mode 100644 index 00000000..c0436dab --- /dev/null +++ b/app/schemas/chat.py @@ -0,0 +1,22 @@ +from datetime import datetime +from uuid import UUID + +from pydantic import Field + +from app.schemas.base import Base, BaseCreate, BasePage + + +class Chat(Base): + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + created_at: datetime + + +class CreateChat(BaseCreate): + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + +class ChatPage(BasePage): + items: list[Chat] + next_cursor: str | None diff --git a/app/schemas/message.py b/app/schemas/message.py new file mode 100644 index 00000000..f4ef2add --- /dev/null +++ b/app/schemas/message.py @@ -0,0 +1,22 @@ +from datetime import datetime +from uuid import UUID + +from pydantic import Field + +from app.schemas.base import Base, BaseCreate, BasePage + + +class Message(Base): + chat_id: UUID + sender_id: UUID + text: str = Field(min_length=1, max_length=4000) + created_at: datetime + + +class CreateMessage(BaseCreate): + text: str = Field(min_length=1, max_length=4000) + + +class MessagePage(BasePage): + items: list[Message] + next_cursor: str | None diff --git a/app/schemas/session.py b/app/schemas/session.py new file mode 100644 index 00000000..1cae0d21 --- /dev/null +++ b/app/schemas/session.py @@ -0,0 +1,17 @@ +from datetime import datetime +from typing import Literal + +from pydantic import BaseModel, ConfigDict, Field + +from app.schemas.user import User + + +class AuthSession(BaseModel): + """Ответ POST /auth/sessions (в OpenAPI — Session).""" + + model_config = ConfigDict(extra="forbid") + + token: str = Field(min_length=32) + token_type: Literal["Bearer"] = "Bearer" + expires_at: datetime + user: User diff --git a/app/schemas/user.py b/app/schemas/user.py new file mode 100644 index 00000000..16548516 --- /dev/null +++ b/app/schemas/user.py @@ -0,0 +1,25 @@ +from datetime import datetime + +from pydantic import Field + +from app.schemas.base import Base, BaseCreate + +USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$" +PASSWORD_MIN_LENGTH = 12 +PASSWORD_MAX_LENGTH = 128 + + +class User(Base): + """Публичное представление пользователя. Пароль/хеш сюда не попадают никогда.""" + + username: str = Field(pattern=USERNAME_PATTERN) + display_name: str = Field(min_length=1, max_length=100) + created_at: datetime + + +class CreateUser(BaseCreate): + username: str = Field(pattern=USERNAME_PATTERN) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field( + min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH, repr=False + ) diff --git a/app/storage/__init__.py b/app/storage/__init__.py new file mode 100644 index 00000000..c881665f --- /dev/null +++ b/app/storage/__init__.py @@ -0,0 +1 @@ +"""Доступ к данным PostgreSQL и Redis.""" diff --git a/app/storage/chats.py b/app/storage/chats.py new file mode 100644 index 00000000..f88ee0cc --- /dev/null +++ b/app/storage/chats.py @@ -0,0 +1,71 @@ +from collections.abc import Sequence +from uuid import UUID + +from sqlalchemy import exists, select, tuple_ +from sqlalchemy.ext.asyncio import AsyncSession + +from app.models.chat import Chat +from app.models.chat_member import ChatMember +from app.storage.types import Position + + +async def create_chat( + session: AsyncSession, + *, + title: str, + member_ids: Sequence[UUID], +) -> Chat: + """Добавляет чат вместе с участниками.""" + chat = Chat( + title=title, + members=[ChatMember(user_id=user_id) for user_id in member_ids], + ) + session.add(chat) + await session.flush() + return chat + + +async def get_chat_for_member( + session: AsyncSession, + chat_id: UUID, + user_id: UUID, +) -> Chat | None: + """Возвращает чат, если пользователь в нём состоит, иначе None.""" + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(Chat.id == chat_id, ChatMember.user_id == user_id) + ) + result = await session.execute(stmt) + chat = result.scalar_one_or_none() + return chat + + +async def is_chat_member(session: AsyncSession, chat_id: UUID, user_id: UUID) -> bool: + """Возвращает True, если пользователь состоит в чате; одна проверка по PK.""" + stmt = select( + exists().where(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id) + ) + result = await session.execute(stmt) + is_member = bool(result.scalar_one()) + return is_member + + +async def list_chats_for_user( + session: AsyncSession, + user_id: UUID, + after: Position | None, + limit: int, +) -> list[Chat]: + """Возвращает чаты пользователя по (created_at, id) строго после позиции after.""" + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(ChatMember.user_id == user_id) + ) + if after is not None: + stmt = stmt.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after)) + stmt = stmt.order_by(Chat.created_at, Chat.id).limit(limit) + result = await session.execute(stmt) + chats = list(result.scalars().all()) + return chats diff --git a/app/storage/messages.py b/app/storage/messages.py new file mode 100644 index 00000000..19960367 --- /dev/null +++ b/app/storage/messages.py @@ -0,0 +1,58 @@ +from uuid import UUID + +from sqlalchemy import select, tuple_ +from sqlalchemy.dialects.postgresql import insert +from sqlalchemy.ext.asyncio import AsyncSession + +from app.models.counter import Counter +from app.models.message import Message +from app.storage.types import Position + +MESSAGES_COUNTER = "messages" + + +async def create_message( + session: AsyncSession, + *, + chat_id: UUID, + sender_id: UUID, + text: str, +) -> Message: + """Добавляет сообщение; id и created_at назначает сервер.""" + message = Message(chat_id=chat_id, sender_id=sender_id, text=text) + session.add(message) + await session.flush() + return message + + +async def list_messages( + session: AsyncSession, + chat_id: UUID, + after: Position | None, + limit: int, +) -> list[Message]: + """Возвращает сообщения чата по (created_at, id) строго после позиции after.""" + stmt = select(Message).where(Message.chat_id == chat_id) + if after is not None: + stmt = stmt.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) + stmt = stmt.order_by(Message.created_at, Message.id).limit(limit) + result = await session.execute(stmt) + messages = list(result.scalars().all()) + return messages + + +async def reserve_message_slot(session: AsyncSession, max_messages: int) -> bool: + """Атомарно увеличивает счётчик сообщений, если лимит не исчерпан.""" + stmt = ( + insert(Counter) + .values(name=MESSAGES_COUNTER, value=1) + .on_conflict_do_update( + index_elements=[Counter.name], + set_={"value": Counter.value + 1}, + where=Counter.value < max_messages, + ) + .returning(Counter.value) + ) + result = await session.execute(stmt) + is_reserved = result.scalar_one_or_none() is not None + return is_reserved diff --git a/app/storage/sessions.py b/app/storage/sessions.py new file mode 100644 index 00000000..d8a30f29 --- /dev/null +++ b/app/storage/sessions.py @@ -0,0 +1,38 @@ +from datetime import datetime +from uuid import UUID + +from redis.asyncio import Redis + +SESSION_KEY_PREFIX = "session:" + + +def session_key(token_hash: str) -> str: + """Возвращает ключ Redis для хеша токена.""" + return f"{SESSION_KEY_PREFIX}{token_hash}" + + +async def create_session( + redis: Redis, + *, + token_hash: str, + user_id: UUID, + expires_at: datetime, +) -> None: + """Добавляет сессию с абсолютным временем истечения.""" + await redis.set(session_key(token_hash), str(user_id), pxat=expires_at) + + +async def get_session_user_id(redis: Redis, token_hash: str) -> UUID | None: + """Возвращает id владельца действующей сессии или None.""" + raw_user_id = await redis.get(session_key(token_hash)) + if isinstance(raw_user_id, bytes): + raw_user_id = raw_user_id.decode() + user_id = UUID(raw_user_id) if raw_user_id else None + return user_id + + +async def delete_session(redis: Redis, token_hash: str) -> bool: + """Удаляет сессию; возвращает True, если она существовала.""" + deleted_count = await redis.delete(session_key(token_hash)) + is_deleted = deleted_count > 0 + return is_deleted diff --git a/app/storage/types.py b/app/storage/types.py new file mode 100644 index 00000000..e0357cfa --- /dev/null +++ b/app/storage/types.py @@ -0,0 +1,6 @@ +"""Общие типы слоя хранения.""" + +from datetime import datetime +from uuid import UUID + +Position = tuple[datetime, UUID] diff --git a/app/storage/users.py b/app/storage/users.py new file mode 100644 index 00000000..45214e9b --- /dev/null +++ b/app/storage/users.py @@ -0,0 +1,47 @@ +from collections.abc import Collection +from uuid import UUID + +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.models.user import User + + +async def create_user( + session: AsyncSession, + *, + username: str, + display_name: str, + password_hash: str, +) -> User: + """Добавляет пользователя; занятый username даёт IntegrityError при flush.""" + user = User( + username=username, display_name=display_name, password_hash=password_hash + ) + session.add(user) + await session.flush() + return user + + +async def get_user_by_id(session: AsyncSession, user_id: UUID) -> User | None: + """Возвращает пользователя по id или None.""" + user = await session.get(User, user_id) + return user + + +async def get_user_by_username(session: AsyncSession, username: str) -> User | None: + """Возвращает пользователя по username или None.""" + stmt = select(User).where(User.username == username) + result = await session.execute(stmt) + user = result.scalar_one_or_none() + return user + + +async def get_existing_user_ids( + session: AsyncSession, user_ids: Collection[UUID] +) -> set[UUID]: + """Возвращает те из user_ids, что существуют, одним запросом.""" + stmt = select(User.id).where(User.id.in_(user_ids)) + result = await session.execute(stmt) + existing_ids = set(result.scalars().all()) + return existing_ids diff --git a/compose.test.yaml b/compose.test.yaml new file mode 100644 index 00000000..46c9448f --- /dev/null +++ b/compose.test.yaml @@ -0,0 +1,10 @@ +# Override для отдельного тестового стенда (make test-stand-up): +# публикует PostgreSQL и Redis на 127.0.0.1, чтобы pytest из student-tests/ +# мог подключаться к ним напрямую. В основном стенде эти порты закрыты. +services: + postgres: + ports: + - "127.0.0.1:${DB_HOST_PORT:-15432}:5432" + redis: + ports: + - "127.0.0.1:${REDIS_HOST_PORT:-16379}:6379" diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..cc05f4c5 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,105 @@ +# Клиент → nginx (LB) → api × N → postgres + redis. +# Незавершённые места помечены TODO(<номер>). +# +# Запуск: docker compose --env-file .env up -d --build (или make up) + +x-api-image: &api-image + build: . + image: mtusi-messenger:lab3 + +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} + volumes: + - pgdata:/var/lib/postgresql/data + # Порты наружу не публикуются; для локальных pytest см. compose.test.yaml. + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 10 + # TODO(4.3): deploy.resources.limits (cpus / memory) + + 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} + volumes: + - ./infra/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + # TODO(4.3): deploy.resources.limits + + # Однократные миграции до старта реплик: api ждёт service_completed_successfully, + # поэтому реплики не устраивают гонку `alembic upgrade`. + # TODO(4.4): описать совместимость миграций с работающей версией (expand/contract). + migrate: + <<: *api-image + command: ["alembic", "upgrade", "head"] + env_file: .env + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + <<: *api-image + restart: unless-stopped + env_file: .env + environment: + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + # Не задавайте container_name и ports: несколько реплик одного service, + # доступ только через nginx. + 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. + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + + nginx: + image: nginx:1.28.0-alpine + restart: unless-stopped + volumes: + - ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro + ports: + # Единственная публичная точка входа. + - "127.0.0.1:${LB_HOST_PORT:-8080}:8080" + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb-health"] + interval: 5s + timeout: 3s + retries: 5 + depends_on: + api: + condition: service_healthy + # TODO(4.3): deploy.resources.limits + +volumes: + pgdata: + redisdata: + +# TODO(4.3): secrets: +# db_password: +# file: ./secrets/db_password # каталог secrets/ в .gitignore diff --git a/infra/nginx/nginx.conf b/infra/nginx/nginx.conf new file mode 100644 index 00000000..bc967757 --- /dev/null +++ b/infra/nginx/nginx.conf @@ -0,0 +1,55 @@ +# nginx как единая точка входа перед репликами api. +# Сейчас — минимальный рабочий round-robin; доработки помечены TODO. + +worker_processes auto; + +events { + worker_connections 1024; +} + +http { + access_log /dev/stdout; + error_log /dev/stderr warn; + + # 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). + + 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. + } + + server { + listen 8080; + + # Проверка самого LB для healthcheck в compose; не проксируется в API. + location = /lb-health { + access_log off; + default_type text/plain; + return 200 "ok\n"; + } + + location / { + 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 как "лечение" раздельного состояния. + } + } +} diff --git a/infra/redis/redis.conf b/infra/redis/redis.conf new file mode 100644 index 00000000..f2ae982f --- /dev/null +++ b/infra/redis/redis.conf @@ -0,0 +1,5 @@ +dir /data +appendonly yes +appendfsync always +maxmemory 256mb +maxmemory-policy noeviction diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..d914a274 --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,68 @@ +import asyncio +from logging.config import fileConfig + +from alembic import context +from sqlalchemy import pool +from sqlalchemy.engine import Connection +from sqlalchemy.ext.asyncio import async_engine_from_config + +from app.core.config import Settings +from app.models import Base + +config = context.config + +if config.config_file_name is not None: + fileConfig(config.config_file_name, disable_existing_loggers=False) + +target_metadata = Base.metadata + + +def _database_url() -> str: + explicit = config.get_main_option("sqlalchemy.url") + if explicit: + return explicit + return Settings().get_database_url() # type: ignore + + +def run_migrations_offline() -> None: + context.configure( + url=_database_url(), + target_metadata=target_metadata, + literal_binds=True, + compare_type=True, + ) + with context.begin_transaction(): + context.run_migrations() + + +def do_run_migrations(connection: Connection) -> None: + context.configure( + connection=connection, + target_metadata=target_metadata, + compare_type=True, + ) + with context.begin_transaction(): + context.run_migrations() + + +async def run_async_migrations() -> None: + section = config.get_section(config.config_ini_section, {}) + section["sqlalchemy.url"] = _database_url().replace("%", "%%") + connectable = async_engine_from_config( + section, prefix="sqlalchemy.", poolclass=pool.NullPool + ) + + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + await connectable.dispose() + + +def run_migrations_online() -> None: + asyncio.run(run_async_migrations()) + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..17dcba0e --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,25 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/.gitkeep b/migrations/versions/.gitkeep new file mode 100644 index 00000000..e69de29b diff --git a/migrations/versions/abd273076068_add_counters.py b/migrations/versions/abd273076068_add_counters.py new file mode 100644 index 00000000..9c809b06 --- /dev/null +++ b/migrations/versions/abd273076068_add_counters.py @@ -0,0 +1,33 @@ +"""add counters + +Revision ID: abd273076068 +Revises: db06fd3126ff +Create Date: 2026-10-26 22:01:01.910396 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +revision: str = 'abd273076068' +down_revision: Union[str, None] = 'db06fd3126ff' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('counters', + sa.Column('name', sa.String(length=64), nullable=False), + sa.Column('value', sa.BigInteger(), nullable=False), + sa.PrimaryKeyConstraint('name', name=op.f('pk_counters')) + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('counters') + # ### end Alembic commands ### diff --git a/migrations/versions/db06fd3126ff_create_initial_schema.py b/migrations/versions/db06fd3126ff_create_initial_schema.py new file mode 100644 index 00000000..eec6e51b --- /dev/null +++ b/migrations/versions/db06fd3126ff_create_initial_schema.py @@ -0,0 +1,107 @@ +"""create initial schema + +Revision ID: db06fd3126ff +Revises: +Create Date: 2026-10-26 17:09:16.675339 + +""" + +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + +revision: str = "db06fd3126ff" +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table( + "chats", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("title", sa.String(length=100), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("now()"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_chats")), + ) + op.create_table( + "users", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("username", sa.String(length=32), nullable=False), + sa.Column("display_name", sa.String(length=100), nullable=False), + sa.Column("password_hash", sa.String(length=255), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("now()"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_users")), + sa.UniqueConstraint("username", name=op.f("uq_users_username")), + ) + op.create_table( + "chat_members", + sa.Column("chat_id", sa.UUID(), nullable=False), + sa.Column("user_id", sa.UUID(), nullable=False), + sa.ForeignKeyConstraint( + ["chat_id"], + ["chats.id"], + name=op.f("fk_chat_members_chat_id_chats"), + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["user_id"], ["users.id"], name=op.f("fk_chat_members_user_id_users") + ), + sa.PrimaryKeyConstraint("chat_id", "user_id", name=op.f("pk_chat_members")), + ) + op.create_index( + "ix_chat_members_user_id_chat_id", + "chat_members", + ["user_id", "chat_id"], + unique=False, + ) + op.create_table( + "messages", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("chat_id", sa.UUID(), nullable=False), + sa.Column("sender_id", sa.UUID(), nullable=False), + sa.Column("text", sa.Text(), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("clock_timestamp()"), + nullable=False, + ), + sa.ForeignKeyConstraint( + ["chat_id"], ["chats.id"], name=op.f("fk_messages_chat_id_chats") + ), + sa.ForeignKeyConstraint( + ["sender_id"], ["users.id"], name=op.f("fk_messages_sender_id_users") + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_messages")), + ) + op.create_index( + "ix_messages_chat_id_created_at_id", + "messages", + ["chat_id", "created_at", "id"], + unique=False, + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index("ix_messages_chat_id_created_at_id", table_name="messages") + op.drop_table("messages") + op.drop_index("ix_chat_members_user_id_chat_id", table_name="chat_members") + op.drop_table("chat_members") + op.drop_table("users") + op.drop_table("chats") + # ### end Alembic commands ### diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..b7dd8fa8 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,6 @@ +[pytest] +testpaths = student-tests +python_files = test_*.py +asyncio_mode = auto +asyncio_default_fixture_loop_scope = session +asyncio_default_test_loop_scope = session diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..a64e71a1 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,50 @@ +alembic==1.20.0 +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +attrs==26.1.0 +certifi==2026.7.22 +charset-normalizer==3.5.2 +click==8.5.0 +fastapi==0.143.3 +h11==0.16.0 +httpcore2==2.13.1 +httpx2==2.13.1 +idna==3.20 +iniconfig==2.3.1 +jsonschema==4.26.0 +jsonschema-path==0.3.4 +jsonschema-specifications==2025.9.1 +lazy-object-proxy==1.12.0 +Mako==1.4.3 +MarkupSafe==3.0.4 +openapi-schema-validator==0.6.3 +openapi-spec-validator==0.7.2 +opentelemetry-api==1.45.1 +packaging==26.3 +pathable==0.4.4 +pluggy==1.7.0 +pydantic==2.14.1 +pydantic_core==2.50.1 +Pygments==2.21.0 +pytest==9.1.1 +PyYAML==6.0.3 +referencing==0.36.2 +requests==2.34.2 +rfc3339-validator==0.1.4 +rpds-py==2026.9.1 +six==1.17.0 +SQLAlchemy==2.1.4 +starlette==1.8.0 +truststore==0.10.5 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +urllib3==2.8.0 +uvicorn==0.54.0 +asyncpg==0.32.0 +argon2-cffi==25.1.0 +redis==8.1.0 +greenlet==3.5.6 +pydantic-settings==2.16.0 +pytest-asyncio==1.4.1 +httpx==0.28.1 diff --git a/scripts/expiry_demo.sh b/scripts/expiry_demo.sh new file mode 100755 index 00000000..cc32541d --- /dev/null +++ b/scripts/expiry_demo.sh @@ -0,0 +1,28 @@ +#!/bin/sh +set -eu + +BASE_URL="${BASE_URL:-http://localhost:8080}" +TTL="${TTL:?укажите TTL, с которым запущен API (SESSION_TTL_SECONDS)}" +API="$BASE_URL/api/v1" +USERNAME="expiry_$(date +%s)" +PASSWORD="expiry-password-123" + +code() { + curl -s -o /dev/null -w '%{http_code}' "$@" +} + +curl -sf -o /dev/null -X POST "$API/users" -H 'Content-Type: application/json' \ + -d "{\"username\":\"$USERNAME\",\"display_name\":\"Expiry\",\"password\":\"$PASSWORD\"}" +SESSION=$(curl -sf -X POST "$API/auth/sessions" -u "$USERNAME:$PASSWORD") +TOKEN=$(printf '%s' "$SESSION" | python3 -c 'import json, sys; print(json.load(sys.stdin)["token"])') +EXPIRES_AT=$(printf '%s' "$SESSION" | python3 -c 'import json, sys; print(json.load(sys.stdin)["expires_at"])') +AUTH="Authorization: Bearer $TOKEN" + +echo "SESSION_TTL_SECONDS=$TTL, login at $(date -u +%H:%M:%S)Z, expires_at=$EXPIRES_AT" +echo "GET /users/me right after login -> $(code "$API/users/me" -H "$AUTH")" +sleep $((TTL + 1)) +printf "%-35s -> %s\n" "GET /users/me after $((TTL + 1)) s" "$(code "$API/users/me" -H "$AUTH")" +echo "DELETE /auth/sessions/current after -> $(code -X DELETE "$API/auth/sessions/current" -H "$AUTH")" +NEW_TOKEN=$(curl -sf -X POST "$API/auth/sessions" -u "$USERNAME:$PASSWORD" \ + | python3 -c 'import json, sys; print(json.load(sys.stdin)["token"])') +echo "GET /users/me with new login token -> $(code "$API/users/me" -H "Authorization: Bearer $NEW_TOKEN")" diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..9d571c42 --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,132 @@ +"""EXPLAIN (ANALYZE, BUFFERS) запроса истории на синтетических данных. + +Данные создаются в одной транзакции и откатываются в конце: база не меняется. +""" + +import asyncio +from uuid import uuid4 + +from sqlalchemy import text +from sqlalchemy.ext.asyncio import AsyncConnection + +from app.core.config import Settings +from app.core.database import create_db_engine + +TARGET_MESSAGES = 10_000 +NOISE_MESSAGES = 40_000 +PAGE = 51 + +HISTORY_FIRST_PAGE = """ +SELECT * FROM messages +WHERE chat_id = :chat_id +ORDER BY created_at, id +LIMIT :page +""" + +HISTORY_AFTER_CURSOR = """ +SELECT * FROM messages +WHERE chat_id = :chat_id AND (created_at, id) > (:after_created_at, :after_id) +ORDER BY created_at, id +LIMIT :page +""" + + +async def seed(connection: AsyncConnection) -> dict[str, object]: + user_id, target_id, noise_id = uuid4(), uuid4(), uuid4() + await connection.execute( + text( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (:id, :username, 'Explain', 'x')" + ), + {"id": user_id, "username": "explain_" + uuid4().hex[:8]}, + ) + await connection.execute( + text("INSERT INTO chats (id, title) VALUES (:a, 'target'), (:b, 'noise')"), + {"a": target_id, "b": noise_id}, + ) + await connection.execute( + text("INSERT INTO chat_members (chat_id, user_id) VALUES (:a, :u), (:b, :u)"), + {"a": target_id, "b": noise_id, "u": user_id}, + ) + for chat_id, count in ((target_id, TARGET_MESSAGES), (noise_id, NOISE_MESSAGES)): + await connection.execute( + text( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "SELECT gen_random_uuid(), :chat_id, :user_id, 'message ' || g, " + "now() - make_interval(secs => :count - g) " + "FROM generate_series(1, :count) AS g" + ), + {"chat_id": chat_id, "user_id": user_id, "count": count}, + ) + await connection.execute(text("ANALYZE messages")) + + middle = ( + await connection.execute( + text( + "SELECT created_at, id FROM messages WHERE chat_id = :c " + "ORDER BY created_at, id OFFSET :o LIMIT 1" + ), + {"c": target_id, "o": TARGET_MESSAGES // 2}, + ) + ).one() + return { + "chat_id": target_id, + "after_created_at": middle.created_at, + "after_id": middle.id, + "page": PAGE, + } + + +async def explain( + connection: AsyncConnection, title: str, query: str, params: dict[str, object] +) -> None: + rows = await connection.execute( + text(f"EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING ON) {query}"), params + ) + print(f"== {title}") + print(query.strip()) + print() + for row in rows: + print(row[0]) + print() + + +async def main() -> None: + engine = create_db_engine(Settings()) # type: ignore[call-arg] + async with engine.connect() as connection: + transaction = await connection.begin() + params = await seed(connection) + total = ( + await connection.execute(text("SELECT count(*) FROM messages")) + ).scalar_one() + print( + f"messages in table: {total}; target chat: {TARGET_MESSAGES}; noise chat: {NOISE_MESSAGES}" + ) + print() + + first_page = {"chat_id": params["chat_id"], "page": PAGE} + await explain( + connection, "first page (limit+1 = 51)", HISTORY_FIRST_PAGE, first_page + ) + await explain( + connection, + "page after cursor in the middle of history", + HISTORY_AFTER_CURSOR, + params, + ) + + await connection.execute(text("SET LOCAL enable_indexscan = off")) + await connection.execute(text("SET LOCAL enable_bitmapscan = off")) + await explain( + connection, + "same page with index scans disabled (for comparison)", + HISTORY_AFTER_CURSOR, + params, + ) + + await transaction.rollback() + await engine.dispose() + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/scripts/failure_demo.sh b/scripts/failure_demo.sh new file mode 100755 index 00000000..b5c7332d --- /dev/null +++ b/scripts/failure_demo.sh @@ -0,0 +1,64 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +BASE_URL="${BASE_URL:-http://localhost:8080}" +API="$BASE_URL/api/v1" +USERNAME="demo_$(date +%s)" +PASSWORD="demo-password-123" + +compose() { + docker compose --env-file .env "$@" +} + +code() { + curl -s -o /dev/null -w '%{http_code} (%{time_total}s)' "$@" +} + +wait_healthy() { + attempts=0 + until [ "$(compose ps --format '{{.Health}}' "$1")" = "healthy" ]; do + attempts=$((attempts + 1)) + [ "$attempts" -lt 60 ] || { echo "$1 не стал healthy" >&2; exit 1; } + sleep 1 + done +} + +curl -sf -o /dev/null -X POST "$API/users" -H 'Content-Type: application/json' \ + -d "{\"username\":\"$USERNAME\",\"display_name\":\"Demo\",\"password\":\"$PASSWORD\"}" +TOKEN=$(curl -sf -X POST "$API/auth/sessions" -u "$USERNAME:$PASSWORD" \ + | python3 -c 'import json, sys; print(json.load(sys.stdin)["token"])') +AUTH="Authorization: Bearer $TOKEN" + +echo "== baseline" +echo "GET /users/me (Bearer) -> $(code "$API/users/me" -H "$AUTH")" + +echo +echo "== redis stopped" +compose stop redis >/dev/null 2>&1 +echo "GET /users/me (Bearer) -> $(code "$API/users/me" -H "$AUTH")" +echo "POST /auth/sessions (Basic) -> $(code -X POST "$API/auth/sessions" -u "$USERNAME:$PASSWORD")" +echo "GET /users/me (no token) -> $(code "$API/users/me")" +echo "GET /health/ready -> $(code "$BASE_URL/health/ready")" +echo "GET /health/live -> $(code "$BASE_URL/health/live")" +compose start redis >/dev/null 2>&1 +wait_healthy redis +echo "-- redis started again (AOF restored)" +echo "GET /users/me (same token) -> $(code "$API/users/me" -H "$AUTH")" + +echo +echo "== postgres stopped" +compose stop postgres >/dev/null 2>&1 +echo "GET /users/me (Bearer) -> $(code "$API/users/me" -H "$AUTH")" +echo "GET /api/v1/chats (Bearer) -> $(code "$API/chats" -H "$AUTH")" +echo "GET /health/ready -> $(code "$BASE_URL/health/ready")" +echo "GET /health/live -> $(code "$BASE_URL/health/live")" +compose start postgres >/dev/null 2>&1 +wait_healthy postgres +echo "-- postgres started again" +echo "GET /users/me (same token) -> $(code "$API/users/me" -H "$AUTH")" + +echo +echo "== logout" +echo "DELETE /auth/sessions/current -> $(code -X DELETE "$API/auth/sessions/current" -H "$AUTH")" +echo "GET /users/me (same token) -> $(code "$API/users/me" -H "$AUTH")" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..d9ab44b3 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,35 @@ +#!/bin/sh +# Перезапуск API и всех хранилищ с сохранением volumes (make test-persistence). +# У api несколько реплик, перед ними nginx. +set -eu +cd "$(dirname "$0")/.." + +compose() { + docker compose --env-file .env "$@" +} + +# Ждёт, пока ВСЕ контейнеры service станут healthy (у api их несколько). +wait_healthy() { + for service in "$@"; do + attempts=0 + until states=$(compose ps --format '{{.Health}}' "$service") \ + && [ -n "$states" ] \ + && [ -z "$(printf '%s\n' "$states" | grep -v '^healthy$')" ]; do + attempts=$((attempts + 1)) + if [ "$attempts" -ge 60 ]; then + echo "$service не стал healthy за 60 секунд" >&2 + exit 1 + fi + sleep 1 + done + done +} + +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/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..34437faf --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,21 @@ +#!/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. + +echo 'TODO: implement stop-one.sh' >&2 +exit 2 diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..f2becc50 --- /dev/null +++ b/student-tests/conftest.py @@ -0,0 +1,200 @@ +"""Фикстуры async-тестов на реальных PostgreSQL и Redis. + +Перед запуском: `make test-stand-up` (тестовый стенд из compose.yaml + compose.test.yaml +и база _test). +Переменные: + TEST_DATABASE_URL по умолчанию postgresql+asyncpg://messenger:messenger@localhost:5432/messenger_test + TEST_USE_MIGRATIONS=1 строить схему через `alembic upgrade head` вместо Base.metadata.create_all + TEST_REDIS_HOST/PORT/PASSWORD/DB по умолчанию localhost:6379, база 15 + DOCKER_TESTS=1 включить тесты, которые перезапускают контейнеры compose +""" + +import asyncio +import os +from collections.abc import AsyncIterator, Callable + +import httpx +import pytest +from alembic import command +from alembic.config import Config +from fastapi import FastAPI +from redis.asyncio import Redis +from redis.exceptions import RedisError +from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError +from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine +from sqlalchemy.pool import NullPool + +from app.core.config import Settings +from app.core.redis import create_redis_client +from app.main import create_app +from app.models import Base + +DEFAULT_TEST_DATABASE_URL = ( + "postgresql+asyncpg://messenger:messenger@localhost:5432/messenger_test" +) + + +def _database_url() -> str: + return os.environ.get("TEST_DATABASE_URL", DEFAULT_TEST_DATABASE_URL) + + +def _redis_settings() -> dict[str, object]: + return { + "redis_host": os.environ.get("TEST_REDIS_HOST", "localhost"), + "redis_port": int(os.environ.get("TEST_REDIS_PORT", "6379")), + "redis_password": os.environ.get("TEST_REDIS_PASSWORD") or None, + "redis_db": int(os.environ.get("TEST_REDIS_DB", "15")), + } + + +def _alembic_config(url: str) -> Config: + config = Config("alembic.ini") + config.set_main_option("sqlalchemy.url", url.replace("%", "%%")) + return config + + +async def upgrade_head(url: str) -> None: + """alembic command.upgrade внутри вызывает asyncio.run, поэтому — в отдельном потоке.""" + await asyncio.to_thread(command.upgrade, _alembic_config(url), "head") + + +async def reset_schema(engine: AsyncEngine) -> None: + async with engine.begin() as connection: + await connection.run_sync(Base.metadata.drop_all) + await connection.execute(text("DROP TABLE IF EXISTS alembic_version")) + + +async def close_app(app: FastAPI) -> None: + """ASGITransport не запускает lifespan, поэтому ресурсы приложения закрываются явно.""" + await app.state.redis.aclose() + await app.state.engine.dispose() + + +@pytest.fixture(scope="session") +def database_url() -> str: + return _database_url() + + +@pytest.fixture(scope="session") +async def db_engine(database_url: str) -> AsyncIterator[AsyncEngine]: + engine = create_async_engine(database_url, poolclass=NullPool) + try: + async with engine.connect() as connection: + await connection.execute(text("SELECT 1")) + except (SQLAlchemyError, OSError) as error: + pytest.exit( + f"PostgreSQL недоступна по {engine.url.render_as_string(hide_password=True)}: " + f"{type(error).__name__}. Выполните `make test-stand-up`.", + returncode=2, + ) + + await reset_schema(engine) + + if os.environ.get("TEST_USE_MIGRATIONS") == "1": + await upgrade_head(database_url) + else: + async with engine.begin() as connection: + await connection.run_sync(Base.metadata.create_all) + + yield engine + await engine.dispose() + + +@pytest.fixture(scope="session") +async def redis_client() -> AsyncIterator[Redis]: + settings = build_settings(_database_url()) + if settings.redis_db == 0: + pytest.exit("TEST_REDIS_DB=0 запрещён: тесты очищают базу Redis.", returncode=2) + + client = create_redis_client(settings) + try: + await client.ping() + except (RedisError, OSError) as error: + pytest.exit( + f"Redis недоступен: {type(error).__name__}. Выполните `make test-stand-up`.", + returncode=2, + ) + + yield client + await client.flushdb() + await client.aclose() + + +@pytest.fixture(autouse=True) +async def clean_db(db_engine: AsyncEngine, redis_client: Redis) -> None: + names = ", ".join(f'"{table.name}"' for table in Base.metadata.sorted_tables) + if names: + async with db_engine.begin() as connection: + await connection.execute(text(f"TRUNCATE {names} RESTART IDENTITY CASCADE")) + await redis_client.flushdb() + + +def build_settings(database_url: str, **overrides: object) -> Settings: + values: dict[str, object] = { + "app_host": "127.0.0.1", + "app_port": 8080, + "app_env": "test", + "max_messages": 1000, + "max_in_flight": 32, + "log_level": "CRITICAL", + "database_url": database_url, + "session_ttl_seconds": 300, + "db_pool_size": 10, + "db_max_overflow": 10, + **_redis_settings(), + } + values.update(overrides) + return Settings(_env_file=None, **values) # type: ignore[arg-type] + + +@pytest.fixture +def settings(database_url: str) -> Settings: + return build_settings(database_url) + + +@pytest.fixture +def make_settings(database_url: str) -> Callable[..., Settings]: + def factory(**overrides: object) -> Settings: + url = str(overrides.pop("database_url", database_url)) + return build_settings(url, **overrides) + + return factory + + +def make_client( + app, *, raise_app_exceptions: bool = True, timeout: float = 30 +) -> httpx.AsyncClient: + """ASGITransport не запускает lifespan, поэтому ресурсы закрывает вызывающий (close_app).""" + return httpx.AsyncClient( + transport=httpx.ASGITransport( + app=app, raise_app_exceptions=raise_app_exceptions + ), + base_url="http://testserver", + timeout=timeout, + ) + + +@pytest.fixture +def app(settings: Settings): + application = create_app(settings) + + @application.get("/__test__/explode", include_in_schema=False) + async def explode() -> None: + raise RuntimeError("test-secret") + + return application + + +@pytest.fixture +async def client(app) -> AsyncIterator[httpx.AsyncClient]: + async with make_client(app) as test_client: + yield test_client + await close_app(app) + + +@pytest.fixture +async def client_no_raise(app) -> AsyncIterator[httpx.AsyncClient]: + async with make_client(app, raise_app_exceptions=False) as test_client: + yield test_client + await close_app(app) diff --git a/student-tests/helpers.py b/student-tests/helpers.py new file mode 100644 index 00000000..97bf8f99 --- /dev/null +++ b/student-tests/helpers.py @@ -0,0 +1,88 @@ +import base64 +from uuid import uuid4 + +from httpx import AsyncClient + +PASSWORD = "Correct-horse-battery-1" + + +def basic_header(username: str, password: str) -> dict[str, str]: + raw = f"{username}:{password}".encode() + return {"Authorization": "Basic " + base64.b64encode(raw).decode()} + + +def bearer(actor: dict) -> dict[str, str]: + return {"Authorization": "Bearer " + actor["token"]} + + +async def register( + client: AsyncClient, + username: str | None = None, + display_name: str = "Тестовый пользователь", + password: str = PASSWORD, +) -> dict: + """Регистрация без входа. Возвращает User + password (нужен для login).""" + actual_username = username or "user_" + uuid4().hex[:12] + response = await client.post( + "/api/v1/users", + json={ + "username": actual_username, + "display_name": display_name, + "password": password, + }, + ) + assert response.status_code == 201, response.text + return {**response.json(), "password": password} + + +async def login(client: AsyncClient, user: dict) -> dict: + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + assert response.status_code == 201, response.text + return {**user, "token": response.json()["token"]} + + +async def create_user(client: AsyncClient, **kwargs) -> dict: + """Регистрация + вход: актор с полями id, username, token, ...""" + return await login(client, await register(client, **kwargs)) + + +async def create_chat( + client: AsyncClient, + user: dict, + *members: dict, + title: str = "Тестовый чат", +) -> dict: + member_ids = [user["id"], *(member["id"] for member in members)] + response = await client.post( + "/api/v1/chats", + headers=bearer(user), + json={"title": title, "member_ids": member_ids}, + ) + assert response.status_code == 201, response.text + return response.json() + + +def idempotency_header(key: str | None = None) -> dict[str, str]: + return {"Idempotency-Key": key or uuid4().hex} + + +async def send_message( + client: AsyncClient, user: dict, chat: dict, text: str, key: str | None = None +): + """POST сообщения требует Idempotency-Key; по умолчанию — новый ключ.""" + return await client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers={**bearer(user), **idempotency_header(key)}, + json={"text": text}, + ) + + +def assert_request_id(response) -> str: + header_id = response.headers.get("X-Request-Id") + assert header_id + if response.status_code >= 400: + assert response.json()["error"]["request_id"] == header_id + return header_id diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..6746320f --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,298 @@ +import asyncio +import hashlib +from datetime import datetime + +from httpx import AsyncClient + +from app.main import create_app +from conftest import close_app, make_client +from helpers import ( + PASSWORD, + assert_request_id, + basic_header, + bearer, + create_user, + login, + register, +) + + +async def test_login_returns_opaque_bearer_session(client: AsyncClient): + user = await register(client) + + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + + assert response.status_code == 201 + body = response.json() + assert set(body) == {"token", "token_type", "expires_at", "user"} + assert body["token_type"] == "Bearer" + assert len(body["token"]) >= 43 + assert body["token"] not in (user["id"], user["username"]) + assert body["user"]["id"] == user["id"] + assert body["expires_at"].endswith("Z") + assert datetime.fromisoformat(body["expires_at"]) + assert_request_id(response) + + +async def test_each_login_issues_a_different_token(client: AsyncClient): + user = await register(client) + first = await login(client, user) + second = await login(client, user) + + assert first["token"] != second["token"] + + +async def test_password_with_colon_works(client: AsyncClient): + user = await register(client, password="pass:with:colons-123") + + assert (await login(client, user))["token"] + + +async def test_unicode_password_works(client: AsyncClient): + user = await register(client, password="Пароль-с-юникодом-🔑-123") + + assert (await login(client, user))["token"] + + +async def test_wrong_password_and_unknown_user_look_identical(client: AsyncClient): + user = await register(client) + + wrong_password = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], "wrong-password-123"), + ) + unknown_user = await client.post( + "/api/v1/auth/sessions", + headers=basic_header("no_such_user", "wrong-password-123"), + ) + + for response in (wrong_password, unknown_user): + assert response.status_code == 401 + assert response.json()["error"]["code"] == "unauthorized" + assert response.headers["WWW-Authenticate"].startswith( + 'Basic realm="messenger"' + ) + assert_request_id(response) + assert ( + wrong_password.json()["error"]["message"] + == unknown_user.json()["error"]["message"] + ) + + +async def test_login_requires_basic_scheme(client: AsyncClient): + user = await register(client) + session = await login(client, user) + + for headers in ({}, bearer(session), {"Authorization": "Basic !!!not-base64"}): + response = await client.post("/api/v1/auth/sessions", headers=headers) + assert response.status_code == 401 + assert response.headers["WWW-Authenticate"].startswith("Basic") + + +async def test_business_endpoints_require_bearer(client: AsyncClient): + user = await register(client) + + for headers in ( + {}, + basic_header(user["username"], user["password"]), + {"Authorization": "Bearer "}, + {"Authorization": "Bearer unknown-token-value"}, + {"X-User-Id": user["id"]}, + ): + response = await client.get("/api/v1/users/me", headers=headers) + assert response.status_code == 401, headers + assert response.json()["error"]["code"] == "unauthorized" + assert response.headers["WWW-Authenticate"].startswith( + 'Bearer realm="messenger"' + ) + assert_request_id(response) + + +async def test_x_user_id_cannot_override_bearer_identity(client: AsyncClient): + alice = await create_user(client) + eve = await create_user(client) + + response = await client.get( + "/api/v1/users/me", + headers={**bearer(alice), "X-User-Id": eve["id"]}, + ) + + assert response.status_code == 200 + assert response.json()["id"] == alice["id"] + + +async def test_logout_revokes_only_current_session(client: AsyncClient): + user = await register(client) + first = await login(client, user) + second = await login(client, user) + + assert ( + await client.delete("/api/v1/auth/sessions/current", headers=bearer(first)) + ).status_code == 204 + + assert ( + await client.get("/api/v1/users/me", headers=bearer(first)) + ).status_code == 401 + assert ( + await client.get("/api/v1/users/me", headers=bearer(second)) + ).status_code == 200 + + +async def test_logout_twice_returns_401(client: AsyncClient): + session = await create_user(client) + + first = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) + again = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) + + assert first.status_code == 204 + assert first.content == b"" + assert again.status_code == 401 + + +async def test_session_expires_after_ttl(make_settings): + app = create_app(make_settings(session_ttl_seconds=2)) + async with make_client(app) as client: + session = await create_user(client) + assert ( + await client.get("/api/v1/users/me", headers=bearer(session)) + ).status_code == 200 + + await asyncio.sleep(3) + + response = await client.get("/api/v1/users/me", headers=bearer(session)) + assert response.status_code == 401 + assert response.headers["WWW-Authenticate"].startswith("Bearer") + await close_app(app) + + +async def test_token_is_stored_only_as_sha256_key(client: AsyncClient, redis_client): + session = await create_user(client) + + keys = [key async for key in redis_client.scan_iter("session:*")] + token_hash = hashlib.sha256(session["token"].encode()).hexdigest() + + assert keys == [f"session:{token_hash}"] + assert await redis_client.get(keys[0]) == session["id"] + assert all(session["token"] not in key for key in keys) + + +async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engine): + from sqlalchemy import text + + await register(client, username="hash_check") + + async with db_engine.connect() as connection: + result = await connection.execute( + text("SELECT password_hash FROM users WHERE username = 'hash_check'") + ) + stored = result.scalar_one() + + assert PASSWORD not in stored + assert stored.startswith("$argon2id$") + + +async def test_login_rejects_out_of_range_password_like_wrong_password( + client: AsyncClient, +): + user = await register(client) + reference = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], "wrong-password-123"), + ) + + for password in ("x" * 11, "x" * 129, ""): + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], password), + ) + assert response.status_code == 401 + assert ( + response.json()["error"]["message"] == reference.json()["error"]["message"] + ) + assert ( + response.headers["WWW-Authenticate"] + == reference.headers["WWW-Authenticate"] + ) + + +async def test_malformed_basic_credentials_return_401(client: AsyncClient): + import base64 + + def raw(value: bytes) -> dict[str, str]: + return {"Authorization": "Basic " + base64.b64encode(value).decode()} + + for headers in ( + raw(b"no-colon-here"), + raw(b":password-without-user"), + raw(b"\xff\xfe:invalid-utf8"), + {"Authorization": "Basic"}, + {"Authorization": "Digest abc"}, + ): + response = await client.post("/api/v1/auth/sessions", headers=headers) + assert response.status_code == 401, headers + assert response.headers["WWW-Authenticate"].startswith("Basic") + + +async def test_unknown_user_takes_comparable_time_to_wrong_password( + client: AsyncClient, +): + import statistics + import time + + user = await register(client) + + async def measure(username: str) -> float: + samples = [] + for _ in range(5): + started = time.perf_counter() + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(username, "wrong-password-123"), + ) + samples.append(time.perf_counter() - started) + return statistics.median(samples) + + wrong_password = await measure(user["username"]) + unknown_user = await measure("no_such_user") + + assert unknown_user > wrong_password * 0.5 + + +async def test_invalid_basic_username_returns_401_not_500(client: AsyncClient): + user = await register(client) + reference = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], "wrong-password-123"), + ) + + for username in ("bad\u0000name", "UPPER", "no", "x" * 33, "имя", "a b c"): + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(username, "wrong-password-123"), + ) + assert response.status_code == 401, username + assert ( + response.json()["error"]["message"] == reference.json()["error"]["message"] + ) + assert ( + response.headers["WWW-Authenticate"] + == reference.headers["WWW-Authenticate"] + ) + + +async def test_whitespace_only_password_at_login_returns_401(client: AsyncClient): + user = await register(client) + + response = await client.post( + "/api/v1/auth/sessions", headers=basic_header(user["username"], " " * 12) + ) + + assert response.status_code == 401 + assert response.headers["WWW-Authenticate"].startswith("Basic") diff --git a/student-tests/test_chats.py b/student-tests/test_chats.py new file mode 100644 index 00000000..475c946a --- /dev/null +++ b/student-tests/test_chats.py @@ -0,0 +1,209 @@ +from urllib.parse import quote +from uuid import uuid4 + +import pytest +from httpx import AsyncClient + +from helpers import assert_request_id, bearer, create_chat, create_user + + +async def test_create_and_get_chat(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat = await create_chat(client, alice, bob) + + response = await client.get( + f"/api/v1/chats/{chat['id']}", + headers=bearer(bob), + ) + + assert response.status_code == 200 + assert response.json() == chat + assert_request_id(response) + + +async def test_chat_is_not_visible_to_outsider(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + eve = await create_user(client) + chat = await create_chat(client, alice, bob) + + response = await client.get( + f"/api/v1/chats/{chat['id']}", + headers=bearer(eve), + ) + + assert response.status_code == 404 + assert response.json()["error"]["code"] == "not_found" + assert_request_id(response) + + +async def test_chat_creation_requires_creator_in_members(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "Чат", "member_ids": [bob["id"]]}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.parametrize( + "payload", + [ + {"title": "", "member_ids": []}, + {"title": " ", "member_ids": []}, + ], +) +async def test_chat_payload_boundaries(client: AsyncClient, payload: dict): + alice = await create_user(client) + payload["member_ids"] = [alice["id"]] + + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json=payload, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_duplicate_members_are_rejected(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "Чат", "member_ids": [alice["id"], bob["id"], bob["id"]]}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_unknown_member_is_rejected(client: AsyncClient): + alice = await create_user(client) + + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_chat_exact_title_limit_is_accepted(client: AsyncClient): + alice = await create_user(client) + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "x" * 100, "member_ids": [alice["id"]]}, + ) + + assert response.status_code == 201 + assert len(response.json()["title"]) == 100 + + +async def test_chat_list_hides_chats_without_membership(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat_for_bob = await create_chat(client, bob, title="Only Bob") + chat_for_alice = await create_chat(client, alice, title="Only Alice") + + response = await client.get( + "/api/v1/chats?limit=100", + headers=bearer(alice), + ) + + assert response.status_code == 200 + ids = {item["id"] for item in response.json()["items"]} + assert chat_for_alice["id"] in ids + assert chat_for_bob["id"] not in ids + + +async def test_nonexistent_chat_returns_404(client: AsyncClient): + alice = await create_user(client) + + response = await client.get( + "/api/v1/chats/00000000-0000-4000-8000-000000000000", + headers=bearer(alice), + ) + + assert response.status_code == 404 + assert response.json()["error"]["code"] == "not_found" + assert_request_id(response) + + +async def test_failed_chat_creation_leaves_no_partial_data( + client: AsyncClient, db_engine +): + """Атомарность: неизвестный участник -> нет ни чата, ни записей членства.""" + from sqlalchemy import text + + alice = await create_user(client) + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]}, + ) + assert response.status_code == 400 + + async with db_engine.connect() as connection: + chats = ( + await connection.execute(text("SELECT count(*) FROM chats")) + ).scalar_one() + members = ( + await connection.execute(text("SELECT count(*) FROM chat_members")) + ).scalar_one() + assert chats == 0 and members == 0 + + +async def test_chat_list_pagination_and_order(client: AsyncClient): + alice = await create_user(client) + chats = [await create_chat(client, alice, title=f"chat-{i}") for i in range(5)] + + page1 = (await client.get("/api/v1/chats?limit=2", headers=bearer(alice))).json() + page2 = ( + await client.get( + f"/api/v1/chats?limit=2&cursor={quote(page1['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + page3 = ( + await client.get( + f"/api/v1/chats?limit=2&cursor={quote(page2['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + ids = [c["id"] for page in (page1, page2, page3) for c in page["items"]] + assert ids == [c["id"] for c in chats] + assert page3["next_cursor"] is None + + +async def test_chat_endpoints_require_bearer(client: AsyncClient): + assert (await client.get("/api/v1/chats")).status_code == 401 + assert ( + await client.post("/api/v1/chats", json={"title": "x", "member_ids": []}) + ).status_code in (401, 400) + + +async def test_nul_in_chat_title_is_rejected(client: AsyncClient): + alice = await create_user(client) + + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "chat\u0000title", "member_ids": [alice["id"]]}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..9417866e --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,266 @@ +"""Конкурентность на реальной БД: гонка регистрации и параллельная запись.""" + +import asyncio +from collections import Counter +from uuid import uuid4 + +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 + + +async def test_parallel_registration_of_same_username_creates_exactly_one_user( + make_settings, +): + app = create_app( + make_settings(max_in_flight=64, db_pool_size=20, db_max_overflow=20) + ) + + async with make_client(app) as client: + responses = await asyncio.gather( + *( + client.post( + "/api/v1/users", + json={ + "username": "race_user", + "display_name": "Race", + "password": PASSWORD, + }, + ) + for _ in range(16) + ) + ) + await close_app(app) + + statuses = Counter(response.status_code for response in responses) + assert statuses == Counter({201: 1, 409: 15}), statuses + + +async def test_100_messages_from_10_clients(make_settings): + app = create_app( + make_settings( + max_messages=1000, max_in_flight=100, db_pool_size=20, db_max_overflow=20 + ) + ) + + async with make_client(app) as client: + users = [ + await create_user(client, username=f"load_{i}_{uuid4().hex[:6]}") + for i in range(10) + ] + created = await client.post( + "/api/v1/chats", + headers=bearer(users[0]), + json={"title": "Concurrency", "member_ids": [u["id"] for u in users]}, + ) + chat = created.json() + + async def worker(index: int, user: dict) -> list[dict]: + responses = await asyncio.gather( + *( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(user), + json={"text": f"client-{index}-message-{n}"}, + ) + for n in range(10) + ) + ) + assert all(r.status_code == 201 for r in responses), [ + r.text for r in responses if r.status_code != 201 + ] + return [r.json() for r in responses] + + results = await asyncio.gather(*(worker(i, u) for i, u in enumerate(users))) + messages = [m for batch in results for m in batch] + + assert len(messages) == 100 + assert len({m["id"] for m in messages}) == 100 + assert Counter(m["sender_id"] for m in messages) == Counter( + {u["id"]: 10 for u in users} + ) + + history = await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(users[0]) + ) + items = history.json()["items"] + assert len(items) == 100 + assert len({m["id"] for m in items}) == 100 + await close_app(app) + + +async def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine): + app = create_app( + make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20) + ) + + async with make_client(app) as client: + alice = await create_user(client) + bob = await create_user(client) + responses = await asyncio.gather( + *( + client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": f"c{i}", "member_ids": [alice["id"], bob["id"]]}, + ) + for i in range(10) + ) + ) + assert all(r.status_code == 201 for r in responses) + await close_app(app) + + async with db_engine.connect() as connection: + chats = ( + await connection.execute(text("SELECT count(*) FROM chats")) + ).scalar_one() + members = ( + await connection.execute(text("SELECT count(*) FROM chat_members")) + ).scalar_one() + assert chats == 10 and members == 20 + + +async def test_parallel_registration_of_distinct_usernames_all_succeed(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + responses = await asyncio.gather( + *( + client.post( + "/api/v1/users", + json={ + "username": f"distinct_{i}", + "display_name": "D", + "password": PASSWORD, + }, + ) + for i in range(12) + ) + ) + await close_app(app) + + assert [r.status_code for r in responses] == [201] * 12 + assert len({r.json()["id"] for r in responses}) == 12 + + +async def test_parallel_logins_issue_distinct_valid_tokens(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + user = await register(client) + responses = await asyncio.gather( + *( + client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + for _ in range(10) + ) + ) + tokens = [r.json()["token"] for r in responses] + checks = await asyncio.gather( + *( + client.get( + "/api/v1/users/me", headers={"Authorization": f"Bearer {token}"} + ) + for token in tokens + ) + ) + await close_app(app) + + assert all(r.status_code == 201 for r in responses) + assert len(set(tokens)) == 10 + assert all(r.status_code == 200 for r in checks) + + +async def test_parallel_logout_of_same_token_succeeds_once(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + session = await create_user(client) + responses = await asyncio.gather( + *( + client.delete("/api/v1/auth/sessions/current", headers=bearer(session)) + for _ in range(10) + ) + ) + await close_app(app) + + assert Counter(r.status_code for r in responses) == Counter({204: 1, 401: 9}) + + +async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine): + app = create_app( + make_settings( + max_messages=5, max_in_flight=64, db_pool_size=20, db_max_overflow=20 + ) + ) + async with make_client(app) as client: + user = await create_user(client) + chat = ( + await client.post( + "/api/v1/chats", + headers=bearer(user), + json={"title": "limit", "member_ids": [user["id"]]}, + ) + ).json() + responses = await asyncio.gather( + *( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(user), + json={"text": f"m{i}"}, + ) + for i in range(20) + ) + ) + await close_app(app) + + assert Counter(r.status_code for r in responses) == Counter({201: 5, 503: 15}) + async with db_engine.connect() as connection: + stored = ( + await connection.execute(text("SELECT count(*) FROM messages")) + ).scalar_one() + counter = ( + await connection.execute( + text("SELECT value FROM counters WHERE name = 'messages'") + ) + ).scalar_one() + assert stored == counter == 5 + + +async def test_failed_chat_insert_rolls_back_whole_transaction( + make_settings, db_engine, monkeypatch +): + import app.domain.chats as chats_domain + + async def accept_everyone(_session, user_ids): + return set(user_ids) + + app = create_app(make_settings()) + async with make_client(app) as client: + alice = await create_user(client) + monkeypatch.setattr( + chats_domain.users_storage, "get_existing_user_ids", accept_everyone + ) + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "broken", "member_ids": [alice["id"], str(uuid4())]}, + ) + monkeypatch.undo() + after = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "ok", "member_ids": [alice["id"]]}, + ) + await close_app(app) + + assert response.status_code == 400 + assert after.status_code == 201 + async with db_engine.connect() as connection: + titles = (await connection.execute(text("SELECT title FROM chats"))).scalars() + members = ( + await connection.execute(text("SELECT count(*) FROM chat_members")) + ).scalar_one() + assert list(titles) == ["ok"] + assert members == 1 diff --git a/student-tests/test_constraints.py b/student-tests/test_constraints.py new file mode 100644 index 00000000..11aa1f3e --- /dev/null +++ b/student-tests/test_constraints.py @@ -0,0 +1,46 @@ +"""Ограничения на уровне БД: приложение — не единственный защитник данных.""" + +import pytest +from sqlalchemy import text +from sqlalchemy.exc import IntegrityError + +from helpers import create_chat, create_user + + +async def test_duplicate_username_is_rejected_by_database(client, db_engine): + await create_user(client, username="unique_name") + + with pytest.raises(IntegrityError): + async with db_engine.begin() as connection: + await connection.execute( + text( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (gen_random_uuid(), 'unique_name', 'Other', 'hash')" + ) + ) + + +async def test_message_requires_existing_chat(client, db_engine): + alice = await create_user(client) + + with pytest.raises(IntegrityError): + async with db_engine.begin() as connection: + await connection.execute( + text( + "INSERT INTO messages (id, chat_id, sender_id, text) " + "VALUES (gen_random_uuid(), gen_random_uuid(), :sender, 'x')" + ), + {"sender": alice["id"]}, + ) + + +async def test_duplicate_membership_is_rejected_by_database(client, db_engine): + alice = await create_user(client) + chat = await create_chat(client, alice) + + with pytest.raises(IntegrityError): + async with db_engine.begin() as connection: + await connection.execute( + text("INSERT INTO chat_members (chat_id, user_id) VALUES (:c, :u)"), + {"c": chat["id"], "u": alice["id"]}, + ) diff --git a/student-tests/test_errors.py b/student-tests/test_errors.py new file mode 100644 index 00000000..3fe5e939 --- /dev/null +++ b/student-tests/test_errors.py @@ -0,0 +1,76 @@ +import json +import logging + +from httpx import AsyncClient + +from helpers import assert_request_id + + +async def test_missing_token_returns_401(client: AsyncClient): + response = await client.get("/api/v1/users/me") + + assert response.status_code == 401 + assert response.json()["error"]["code"] == "unauthorized" + assert_request_id(response) + + +async def test_garbage_token_returns_401(client: AsyncClient): + response = await client.get( + "/api/v1/users/me", headers={"Authorization": "Bearer garbage"} + ) + + assert response.status_code == 401 + assert response.json()["error"]["code"] == "unauthorized" + assert_request_id(response) + + +async def test_malformed_json_returns_400(client: AsyncClient): + response = await client.post( + "/api/v1/users", + content='{"username":"alice",', + headers={"Content-Type": "application/json"}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +async def test_not_found_returns_404(client: AsyncClient): + response = await client.get("/no-such-path") + + assert response.status_code == 404 + assert response.json()["error"]["code"] == "not_found" + assert_request_id(response) + + +async def test_method_not_allowed_preserves_405(client: AsyncClient): + response = await client.delete("/api/v1/users") + + assert response.status_code == 405 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +async def test_unhandled_exception_is_hidden_from_client( + client_no_raise: AsyncClient, caplog +): + with caplog.at_level(logging.ERROR, logger="app.errors.handlers"): + response = await client_no_raise.get("/__test__/explode") + + assert response.status_code == 500 + payload = response.json() + assert payload["error"]["code"] == "internal_error" + assert payload["error"]["message"] == "Внутренняя ошибка сервера" + assert "test-secret" not in json.dumps(payload, ensure_ascii=False) + assert "Traceback" not in json.dumps(payload, ensure_ascii=False) + assert "Unhandled error request_id=" in caplog.text + assert "test-secret" in caplog.text + assert_request_id(response) + + +async def test_success_response_contains_request_id(client: AsyncClient): + response = await client.get("/health/live") + + assert response.status_code == 200 + assert response.headers.get("X-Request-Id") diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py new file mode 100644 index 00000000..9338c3b4 --- /dev/null +++ b/student-tests/test_failures.py @@ -0,0 +1,138 @@ +"""Недоступность Redis и PostgreSQL: ограниченный 503, без анонимного доступа.""" + +import time + +from app.main import create_app +from conftest import close_app, make_client +from helpers import PASSWORD, assert_request_id, basic_header, bearer, create_user + +ME = "/api/v1/users/me" +DEAD_DATABASE_URL = "postgresql+asyncpg://nobody:secretpass@127.0.0.1:1/none" + + +def assert_unavailable(response) -> None: + assert response.status_code == 503, response.text + assert response.json()["error"]["code"] == "unavailable" + assert "secretpass" not in response.text + assert "Traceback" not in response.text + assert_request_id(response) + + +async def test_redis_down_gives_503_for_login_and_protected_endpoints(make_settings): + alive = create_app(make_settings()) + async with make_client(alive) as client: + session = await create_user(client) + await close_app(alive) + + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + started = time.perf_counter() + protected = await client.get(ME, headers=bearer(session)) + elapsed = time.perf_counter() - started + + login = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(session["username"], session["password"]), + ) + logout = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) + ready = await client.get("/health/ready") + live = await client.get("/health/live") + + await close_app(app) + + for response in (protected, login, logout, ready): + assert_unavailable(response) + assert live.status_code == 200 + assert elapsed < 3 + + +async def test_redis_down_keeps_registration_working(make_settings): + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( + "/api/v1/users", + json={"username": "no_redis", "display_name": "N", "password": PASSWORD}, + ) + await close_app(app) + + assert response.status_code == 201 + + +async def test_database_down_with_valid_session_gives_503(make_settings): + alive = create_app(make_settings()) + async with make_client(alive) as client: + session = await create_user(client) + await close_app(alive) + + app = create_app( + make_settings(database_url=DEAD_DATABASE_URL, db_connect_timeout_seconds=1) + ) + async with make_client(app, raise_app_exceptions=False) as client: + protected = await client.get(ME, headers=bearer(session)) + chats = await client.get("/api/v1/chats", headers=bearer(session)) + login = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(session["username"], session["password"]), + ) + await close_app(app) + + for response in (protected, chats, login): + assert_unavailable(response) + + +async def test_dependency_failure_never_authenticates_anonymous_requests(make_settings): + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + no_token = await client.get(ME) + garbage = await client.get(ME, headers={"Authorization": "Bearer garbage"}) + await close_app(app) + + assert no_token.status_code == 401 + assert_unavailable(garbage) + + +async def test_statement_timeout_gives_503(make_settings, monkeypatch): + from sqlalchemy import text + + import app.domain.users as users_domain + + async def slow_lookup(session, _username): + await session.execute(text("SELECT pg_sleep(1)")) + + app = create_app(make_settings(db_statement_timeout_ms=100)) + monkeypatch.setattr(users_domain.users_storage, "get_user_by_username", slow_lookup) + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( + "/api/v1/users", + json={"username": "slow_user", "display_name": "S", "password": PASSWORD}, + ) + await close_app(app) + + assert_unavailable(response) + assert response.headers["Retry-After"] == "1" + + +async def test_non_transient_database_error_stays_500(make_settings, monkeypatch): + from sqlalchemy import text + + import app.domain.users as users_domain + + async def broken_lookup(session, _username): + await session.execute(text("SELECT 1 / 0")) + + app = create_app(make_settings()) + monkeypatch.setattr( + users_domain.users_storage, "get_user_by_username", broken_lookup + ) + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( + "/api/v1/users", + json={"username": "broken_user", "display_name": "B", "password": PASSWORD}, + ) + await close_app(app) + + assert response.status_code == 500 + assert response.json()["error"]["code"] == "internal_error" + assert "division" not in response.text diff --git a/student-tests/test_health.py b/student-tests/test_health.py new file mode 100644 index 00000000..26d15896 --- /dev/null +++ b/student-tests/test_health.py @@ -0,0 +1,62 @@ +from httpx import AsyncClient + +from app.main import create_app +from conftest import close_app, make_client +from helpers import assert_request_id + + +async def test_liveness(client: AsyncClient): + response = await client.get("/health/live") + + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + assert_request_id(response) + + +async def test_readiness(client: AsyncClient): + response = await client.get("/health/ready") + + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + assert_request_id(response) + + +async def test_readiness_is_503_when_database_is_down(make_settings): + app = create_app( + make_settings( + database_url="postgresql+asyncpg://nobody:nopass@127.0.0.1:1/none", + db_connect_timeout_seconds=1, + ) + ) + async with make_client(app) as client: + assert (await client.get("/health/live")).status_code == 200 + + ready = await client.get("/health/ready") + assert ready.status_code == 503 + assert ready.json()["error"]["code"] == "unavailable" + assert_request_id(ready) + await close_app(app) + + +async def test_business_request_is_503_when_database_is_down(make_settings): + app = create_app( + make_settings( + database_url="postgresql+asyncpg://nobody:secretpass@127.0.0.1:1/none", + db_connect_timeout_seconds=1, + ) + ) + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( + "/api/v1/users", + json={ + "username": "alice", + "display_name": "Alice", + "password": "Correct-horse-battery-1", + }, + ) + await close_app(app) + + assert response.status_code == 503 + assert response.json()["error"]["code"] == "unavailable" + assert "secretpass" not in response.text + assert_request_id(response) diff --git a/student-tests/test_history_plan.py b/student-tests/test_history_plan.py new file mode 100644 index 00000000..704c9ccd --- /dev/null +++ b/student-tests/test_history_plan.py @@ -0,0 +1,78 @@ +"""План запроса истории на >= 10 000 сообщений: индекс без Sort и полного скана.""" + +import json +from datetime import datetime +from uuid import UUID + +from sqlalchemy import text +from sqlalchemy.ext.asyncio import AsyncEngine + +from helpers import bearer, create_chat, create_user + +HISTORY_QUERY = """ +SELECT * FROM messages +WHERE chat_id = :chat_id AND (created_at, id) > (:after_created_at, :after_id) +ORDER BY created_at, id +LIMIT 51 +""" + + +def walk(node: dict) -> list[dict]: + nodes = [node] + for child in node.get("Plans", []): + nodes.extend(walk(child)) + return nodes + + +async def seed_messages( + engine: AsyncEngine, chat_id: str, sender_id: str, count: int +) -> None: + async with engine.begin() as connection: + await connection.execute( + text( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), :chat_id, :sender_id, 'message ' || g, + now() - make_interval(secs => :count - g) + FROM generate_series(1, :count) AS g + """ + ), + {"chat_id": chat_id, "sender_id": sender_id, "count": count}, + ) + await connection.execute(text("ANALYZE messages")) + + +async def test_history_page_uses_composite_index(client, db_engine: AsyncEngine): + alice = await create_user(client) + target = await create_chat(client, alice, title="target") + noise = await create_chat(client, alice, title="noise") + await seed_messages(db_engine, target["id"], alice["id"], 10_000) + await seed_messages(db_engine, noise["id"], alice["id"], 10_000) + + middle = ( + await client.get( + f"/api/v1/chats/{target['id']}/messages?limit=100", headers=bearer(alice) + ) + ).json()["items"][-1] + + async with db_engine.connect() as connection: + raw_plan = ( + await connection.execute( + text(f"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {HISTORY_QUERY}"), + { + "chat_id": UUID(target["id"]), + "after_created_at": datetime.fromisoformat(middle["created_at"]), + "after_id": UUID(middle["id"]), + }, + ) + ).scalar_one() + + plan = (raw_plan if isinstance(raw_plan, list) else json.loads(raw_plan))[0]["Plan"] + nodes = walk(plan) + node_types = {node["Node Type"] for node in nodes} + index_names = {node.get("Index Name") for node in nodes} + + assert "ix_messages_chat_id_created_at_id" in index_names + assert "Sort" not in node_types + assert "Seq Scan" not in node_types + assert all(node.get("Actual Rows", 0) <= 51 for node in nodes) diff --git a/student-tests/test_limits.py b/student-tests/test_limits.py new file mode 100644 index 00000000..86d53ed6 --- /dev/null +++ b/student-tests/test_limits.py @@ -0,0 +1,98 @@ +"""Ограничения нагрузки: MAX_IN_FLIGHT -> 429, MAX_MESSAGES -> 503.""" + +import asyncio + +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 + + +def _assert_error(response: httpx.Response, status: int, code: str) -> None: + assert response.status_code == status + body = response.json() + assert body["error"]["code"] == code + assert response.headers.get("X-Request-Id") == body["error"]["request_id"] + + +async def test_message_limit_rejects_without_deleting_confirmed_messages(make_settings): + app = create_app(make_settings(max_messages=2)) + async with make_client(app) as client: + user = await create_user(client) + chat = await create_chat(client, user) + url = f"/api/v1/chats/{chat['id']}/messages" + + for index in range(2): + ok = await client.post( + url, headers=bearer(user), json={"text": f"confirmed-{index}"} + ) + assert ok.status_code == 201 + + rejected = await client.post( + url, headers=bearer(user), json={"text": "rejected"} + ) + _assert_error(rejected, 503, "unavailable") + + history = await client.get(f"{url}?limit=100", headers=bearer(user)) + assert history.status_code == 200 + assert [m["text"] for m in history.json()["items"]] == [ + "confirmed-0", + "confirmed-1", + ] + await close_app(app) + + +async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypatch): + import app.endpoints.messages as message_endpoint + + app = create_app(make_settings(max_in_flight=2)) + + original_send_message = message_endpoint.send_message + accepted_count = 0 + all_slots_taken = asyncio.Event() + release = asyncio.Event() + + async def blocking_send_message(*args, **kwargs): + nonlocal accepted_count + accepted_count += 1 + if accepted_count == 2: + all_slots_taken.set() + await asyncio.wait_for(release.wait(), timeout=5) + return await original_send_message(*args, **kwargs) + + async with make_client(app, timeout=10) as client: + user = await create_user(client) + chat = await create_chat(client, user) + + monkeypatch.setattr(message_endpoint, "send_message", 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}"}) + ) + for i in range(2) + ] + + await asyncio.wait_for(all_slots_taken.wait(), timeout=2) + + rejected = await asyncio.gather( + *( + client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"}) + for i in range(4) + ) + ) + for response in rejected: + _assert_error(response, 429, "rate_limited") + assert response.headers.get("Retry-After") == "1" + + assert (await client.get("/health/live")).status_code == 200 + + 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"}) + 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 new file mode 100644 index 00000000..2a47923e --- /dev/null +++ b/student-tests/test_messages.py @@ -0,0 +1,237 @@ +from urllib.parse import quote + +import pytest +from httpx import AsyncClient + +from helpers import ( + assert_request_id, + bearer, + create_chat, + create_user, + send_message, +) + + +async def _message(client: AsyncClient, user: dict, chat: dict, text: str): + return await send_message(client, user, chat, text) + + +async def test_send_and_list_message(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat = await create_chat(client, alice, bob) + + created = await _message(client, alice, chat, "Привет, мир 👋") + + assert created.status_code == 201 + message = created.json() + assert message["sender_id"] == alice["id"] + assert message["chat_id"] == chat["id"] + assert_request_id(created) + + listed = await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", + headers=bearer(bob), + ) + + assert listed.status_code == 200 + assert listed.json()["items"] == [message] + assert listed.json()["next_cursor"] is None + assert_request_id(listed) + + +@pytest.mark.parametrize("text", ["", " ", "x" * 4001]) +async def test_invalid_message_text(client: AsyncClient, text: str): + alice = await create_user(client) + chat = await create_chat(client, alice) + + response = await _message(client, alice, chat, text) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +async def test_extra_message_field_is_rejected(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + + response = await client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(alice), + json={"text": "hello", "sender_id": alice["id"]}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +async def test_messages_are_private_to_chat_members(client: AsyncClient): + alice = await create_user(client) + eve = await create_user(client) + chat = await create_chat(client, alice) + await _message(client, alice, chat, "секрет") + + response = await client.get( + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(eve), + ) + + assert response.status_code == 404 + assert response.json()["error"]["code"] == "not_found" + + +async def test_pagination_has_no_duplicates(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + + created = [ + (await _message(client, alice, chat, f"message-{index}")).json() + for index in range(5) + ] + + page1 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2", + headers=bearer(alice), + ) + ).json() + page2 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page1['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + page3 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page2['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + ids = [item["id"] for page in (page1, page2, page3) for item in page["items"]] + assert ids == [item["id"] for item in created] + assert len(ids) == len(set(ids)) == 5 + assert len(page1["items"]) == 2 + assert len(page2["items"]) == 2 + assert len(page3["items"]) == 1 + assert page3["next_cursor"] is None + + +async def test_cursor_cannot_be_used_for_another_chat(client: AsyncClient): + alice = await create_user(client) + chat_a = await create_chat(client, alice, title="A") + chat_b = await create_chat(client, alice, title="B") + + await _message(client, alice, chat_a, "a1") + await _message(client, alice, chat_a, "a2") + await _message(client, alice, chat_b, "b1") + await _message(client, alice, chat_b, "b2") + + page = ( + await client.get( + f"/api/v1/chats/{chat_a['id']}/messages?limit=1", + headers=bearer(alice), + ) + ).json() + + response = await client.get( + f"/api/v1/chats/{chat_b['id']}/messages?limit=1&cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(alice), + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +@pytest.mark.parametrize( + "limit, expected_status", [(0, 400), (1, 200), (100, 200), (101, 400)] +) +async def test_limit_boundaries(client: AsyncClient, limit: int, expected_status: int): + alice = await create_user(client) + chat = await create_chat(client, alice) + await _message(client, alice, chat, "one") + + response = await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit={limit}", + headers=bearer(alice), + ) + + assert response.status_code == expected_status + assert_request_id(response) + + +async def test_message_exact_max_length_is_accepted(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + + response = await _message(client, alice, chat, "x" * 4000) + + assert response.status_code == 201 + assert len(response.json()["text"]) == 4000 + + +async def test_nonexistent_chat_messages_return_404(client: AsyncClient): + alice = await create_user(client) + + response = await client.get( + "/api/v1/chats/00000000-0000-4000-8000-000000000000/messages", + headers=bearer(alice), + ) + + assert response.status_code == 404 + assert response.json()["error"]["code"] == "not_found" + assert_request_id(response) + + +async def test_unauthenticated_requests_are_rejected(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + url = f"/api/v1/chats/{chat['id']}/messages" + + assert (await client.get(url)).status_code == 401 + assert (await client.post(url, json={"text": "hi"})).status_code == 401 + + +async def test_messages_survive_new_login(client: AsyncClient): + """Сообщения принадлежат пользователю, а не сессии: после logout/login видны.""" + from helpers import login + + alice = await create_user(client) + chat = await create_chat(client, alice) + message = (await _message(client, alice, chat, "до выхода")).json() + await client.delete("/api/v1/auth/sessions/current", headers=bearer(alice)) + + alice_again = await login(client, alice) + listed = await client.get( + f"/api/v1/chats/{chat['id']}/messages", headers=bearer(alice_again) + ) + + assert listed.json()["items"] == [message] + + +async def test_history_order_is_created_at_then_id(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + created = [(await _message(client, alice, chat, f"m{i}")).json() for i in range(10)] + + listed = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(alice) + ) + ).json()["items"] + + assert [m["id"] for m in listed] == [m["id"] for m in created] + keys = [(m["created_at"], m["id"]) for m in listed] + assert keys == sorted(keys) + + +async def test_nul_in_message_text_is_rejected(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + + response = await _message(client, alice, chat, "hello\u0000world") + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" diff --git a/student-tests/test_migrations.py b/student-tests/test_migrations.py new file mode 100644 index 00000000..b41c8830 --- /dev/null +++ b/student-tests/test_migrations.py @@ -0,0 +1,67 @@ +"""Миграции: применение с нуля, идемпотентный повтор, совпадение со схемой моделей.""" + +import pytest +from alembic.autogenerate import compare_metadata +from alembic.migration import MigrationContext +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"} + + +@pytest.fixture +async def migrated_engine(database_url, db_engine): + await reset_schema(db_engine) + await upgrade_head(database_url) + yield db_engine + + await reset_schema(db_engine) + async with db_engine.begin() as connection: + await connection.run_sync(Base.metadata.create_all) + + +async def test_upgrade_creates_all_tables(migrated_engine): + async with migrated_engine.connect() as connection: + tables = await connection.run_sync( + lambda sync: set(inspect(sync).get_table_names()) + ) + assert EXPECTED_TABLES <= tables + + +async def test_upgrade_twice_is_idempotent_and_keeps_data( + migrated_engine, database_url +): + async with migrated_engine.begin() as connection: + await connection.execute( + text( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (gen_random_uuid(), 'keep_me', 'Keep', 'hash')" + ) + ) + + await upgrade_head(database_url) + + async with migrated_engine.connect() as connection: + count = ( + await connection.execute( + text("SELECT count(*) FROM users WHERE username = 'keep_me'") + ) + ).scalar_one() + assert count == 1 + + +async def test_models_and_migrations_are_in_sync(migrated_engine): + def compare(sync_connection): + context = MigrationContext.configure( + sync_connection, opts={"compare_type": True} + ) + return compare_metadata(context, Base.metadata) + + async with migrated_engine.connect() as connection: + diff = await connection.run_sync(compare) + + assert diff == [], ( + f"Создайте миграцию: alembic revision --autogenerate. Diff: {diff}" + ) diff --git a/student-tests/test_pagination.py b/student-tests/test_pagination.py new file mode 100644 index 00000000..e45e5b1b --- /dev/null +++ b/student-tests/test_pagination.py @@ -0,0 +1,137 @@ +"""Курсоры: непрозрачность, привязка к ресурсу и устойчивость к подделке.""" + +import base64 +import json +from urllib.parse import quote + +import pytest +from httpx import AsyncClient + +from helpers import bearer, create_chat, create_user, send_message + + +def forged_cursor(**payload: str) -> str: + return base64.urlsafe_b64encode(json.dumps(payload).encode()).decode() + + +@pytest.mark.parametrize( + "cursor", + [ + "not-base64-%%%", + base64.urlsafe_b64encode(b"not json").decode(), + base64.urlsafe_b64encode(b"[1, 2, 3]").decode(), + forged_cursor(kind="messages"), + ], +) +async def test_garbage_cursor_returns_400(client: AsyncClient, cursor: str): + alice = await create_user(client) + chat = await create_chat(client, alice) + + for url in ( + f"/api/v1/chats?cursor={quote(cursor, safe='')}", + f"/api/v1/chats/{chat['id']}/messages?cursor={quote(cursor, safe='')}", + ): + response = await client.get(url, headers=bearer(alice)) + assert response.status_code == 400, url + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_cursor_without_timezone_is_rejected(client: AsyncClient): + alice = await create_user(client) + cursor = forged_cursor( + kind="chats", + resource_id=alice["id"], + created_at="2026-01-01T00:00:00", + item_id="00000000-0000-4000-8000-000000000000", + ) + + response = await client.get( + f"/api/v1/chats?cursor={quote(cursor, safe='')}", headers=bearer(alice) + ) + + assert response.status_code == 400 + + +async def test_chat_list_cursor_is_bound_to_its_owner(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + for index in range(2): + await create_chat(client, alice, bob, title=f"shared-{index}") + + page = (await client.get("/api/v1/chats?limit=1", headers=bearer(alice))).json() + response = await client.get( + f"/api/v1/chats?limit=1&cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(bob), + ) + + assert response.status_code == 400 + + +async def test_messages_cursor_is_not_accepted_by_chat_list(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + for index in range(2): + await send_message(client, alice, chat, f"m{index}") + + page = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + response = await client.get( + f"/api/v1/chats?cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(alice), + ) + + assert response.status_code == 400 + + +async def test_limit_can_change_between_pages(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + sent = [ + (await send_message(client, alice, chat, f"m{index}")).json() + for index in range(6) + ] + + first = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + rest = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100" + f"&cursor={quote(first['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + assert [m["id"] for m in first["items"] + rest["items"]] == [m["id"] for m in sent] + assert rest["next_cursor"] is None + + +async def test_message_sent_after_reading_last_page_is_seen_with_cursor( + client: AsyncClient, +): + alice = await create_user(client) + chat = await create_chat(client, alice) + await send_message(client, alice, chat, "first") + await send_message(client, alice, chat, "second") + + page = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + new = (await send_message(client, alice, chat, "third")).json() + rest = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100" + f"&cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + assert [m["text"] for m in rest["items"]] == ["second", "third"] + assert rest["items"][-1] == new diff --git a/student-tests/test_sessions.py b/student-tests/test_sessions.py new file mode 100644 index 00000000..e239e227 --- /dev/null +++ b/student-tests/test_sessions.py @@ -0,0 +1,173 @@ +"""Сессии в Redis: TTL, абсолютный срок, отзыв, потеря и перезапуск хранилища.""" + +import asyncio +import hashlib +import os +import time +from datetime import datetime + +import pytest +from httpx import AsyncClient +from redis.asyncio import Redis + +from app.main import create_app +from conftest import close_app, make_client +from helpers import basic_header, bearer, create_user, register + +ME = "/api/v1/users/me" +LOGOUT = "/api/v1/auth/sessions/current" + + +def session_key(token: str) -> str: + return "session:" + hashlib.sha256(token.encode()).hexdigest() + + +async def test_session_key_ttl_matches_expires_at( + client: AsyncClient, redis_client: Redis +): + user = await register(client) + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + body = response.json() + + expires_at = datetime.fromisoformat(body["expires_at"]) + expire_time_ms = await redis_client.pexpiretime(session_key(body["token"])) + + assert abs(expire_time_ms - expires_at.timestamp() * 1000) < 2 + assert 299_000 < await redis_client.pttl(session_key(body["token"])) <= 300_000 + + +async def test_session_ttl_is_absolute_and_not_extended_by_activity( + client: AsyncClient, redis_client: Redis +): + session = await create_user(client) + key = session_key(session["token"]) + expire_before = await redis_client.pexpiretime(key) + + for _ in range(5): + assert (await client.get(ME, headers=bearer(session))).status_code == 200 + + assert await redis_client.pexpiretime(key) == expire_before + + +async def test_logout_removes_session_key(client: AsyncClient, redis_client: Redis): + session = await create_user(client) + key = session_key(session["token"]) + assert await redis_client.exists(key) == 1 + + assert (await client.delete(LOGOUT, headers=bearer(session))).status_code == 204 + + assert await redis_client.exists(key) == 0 + assert (await client.get(ME, headers=bearer(session))).status_code == 401 + + +async def test_expired_session_is_rejected_everywhere(make_settings): + app = create_app(make_settings(session_ttl_seconds=1)) + async with make_client(app) as client: + session = await create_user(client) + assert (await client.get(ME, headers=bearer(session))).status_code == 200 + + await asyncio.sleep(1.5) + + for method, url in (("GET", ME), ("GET", "/api/v1/chats"), ("DELETE", LOGOUT)): + response = await client.request(method, url, headers=bearer(session)) + assert response.status_code == 401, (method, url) + assert response.headers["WWW-Authenticate"].startswith("Bearer") + await close_app(app) + + +async def test_relogin_after_expiry_issues_new_working_token(make_settings): + app = create_app(make_settings(session_ttl_seconds=1)) + async with make_client(app) as client: + user = await register(client) + first = ( + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + ).json() + await asyncio.sleep(1.5) + second = ( + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + ).json() + + assert first["token"] != second["token"] + assert (await client.get(ME, headers=bearer(first))).status_code == 401 + assert (await client.get(ME, headers=bearer(second))).status_code == 200 + await close_app(app) + + +async def test_tampered_token_is_rejected(client: AsyncClient): + session = await create_user(client) + token = session["token"] + tampered = token[:-1] + ("A" if token[-1] != "A" else "B") + + response = await client.get(ME, headers={"Authorization": f"Bearer {tampered}"}) + + assert response.status_code == 401 + + +async def test_session_of_deleted_user_is_rejected(client: AsyncClient, db_engine): + from sqlalchemy import text + + session = await create_user(client) + async with db_engine.begin() as connection: + await connection.execute( + text("DELETE FROM users WHERE id = :id"), {"id": session["id"]} + ) + + response = await client.get(ME, headers=bearer(session)) + + assert response.status_code == 401 + + +async def test_redis_flush_invalidates_all_sessions( + client: AsyncClient, redis_client: Redis +): + alice = await create_user(client) + bob = await create_user(client) + + await redis_client.flushdb() + + for session in (alice, bob): + assert (await client.get(ME, headers=bearer(session))).status_code == 401 + + +@pytest.mark.skipif( + os.environ.get("DOCKER_TESTS") != "1", + reason="перезапускает контейнер redis из compose; включается DOCKER_TESTS=1", +) +async def test_sessions_survive_redis_restart(client: AsyncClient, redis_client: Redis): + active = await create_user(client) + revoked = await create_user(client) + assert (await client.delete(LOGOUT, headers=bearer(revoked))).status_code == 204 + + process = await asyncio.create_subprocess_exec( + "docker", + "compose", + "restart", + "redis", + stdout=asyncio.subprocess.DEVNULL, + stderr=asyncio.subprocess.DEVNULL, + ) + assert await process.wait() == 0 + + deadline = time.monotonic() + 30 + while True: + try: + await redis_client.ping() + break + except Exception: + if time.monotonic() > deadline: + raise + await asyncio.sleep(0.5) + + response = await client.get(ME, headers=bearer(active)) + assert response.status_code == 200 + assert response.json()["id"] == active["id"] + assert (await client.get(ME, headers=bearer(revoked))).status_code == 401 diff --git a/student-tests/test_users.py b/student-tests/test_users.py new file mode 100644 index 00000000..554cf30d --- /dev/null +++ b/student-tests/test_users.py @@ -0,0 +1,128 @@ +import pytest +from httpx import AsyncClient + +from helpers import PASSWORD, assert_request_id, bearer, create_user, register + + +async def test_register_does_not_leak_password(client: AsyncClient): + response = await client.post( + "/api/v1/users", + json={"username": "alice", "display_name": "Алиса 👋", "password": PASSWORD}, + ) + + assert response.status_code == 201 + body = response.json() + assert set(body) == {"id", "username", "display_name", "created_at"} + assert PASSWORD not in response.text + assert_request_id(response) + + +async def test_get_current_user(client: AsyncClient): + user = await create_user(client, display_name="Алиса 👋") + + response = await client.get("/api/v1/users/me", headers=bearer(user)) + + assert response.status_code == 200 + assert response.json()["id"] == user["id"] + assert response.json()["username"] == user["username"] + assert_request_id(response) + + +@pytest.mark.parametrize( + "body", + [ + {"username": "alice", "display_name": "", "password": PASSWORD}, + {"username": "alice", "display_name": " ", "password": PASSWORD}, + {"username": "alice", "display_name": "a" * 101, "password": PASSWORD}, + {"username": "ab", "display_name": "Alice", "password": PASSWORD}, + {"username": "alice-123", "display_name": "Alice", "password": PASSWORD}, + {"username": "AlicE", "display_name": "Alice", "password": PASSWORD}, + {"username": "a" * 33, "display_name": "Alice", "password": PASSWORD}, + {"username": "alice", "display_name": "Alice"}, + {"username": "alice", "display_name": "Alice", "password": "x" * 11}, + {"username": "alice", "display_name": "Alice", "password": "x" * 129}, + ], +) +async def test_invalid_user_payloads(client: AsyncClient, body: dict): + response = await client.post("/api/v1/users", json=body) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +async def test_password_length_boundaries_are_accepted(client: AsyncClient): + for index, password in enumerate( + ["x" * 12, "y" * 128, "п" * 12, " spaces inside "] + ): + response = await client.post( + "/api/v1/users", + json={ + "username": f"pw_user_{index}", + "display_name": "Alice", + "password": password, + }, + ) + assert response.status_code == 201, (index, response.text) + + +async def test_extra_user_field_is_rejected(client: AsyncClient): + response = await client.post( + "/api/v1/users", + json={ + "username": "alice", + "display_name": "Alice", + "password": PASSWORD, + "extra": True, + }, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_duplicate_username_returns_conflict(client: AsyncClient): + user = await register(client, username="duplicate_user") + + response = await client.post( + "/api/v1/users", + json={ + "username": user["username"], + "display_name": "Другой", + "password": PASSWORD, + }, + ) + + assert response.status_code == 409 + assert response.json()["error"]["code"] == "conflict" + assert_request_id(response) + + +async def test_user_exact_length_boundaries_are_accepted(client: AsyncClient): + for length in (3, 32): + user = await register(client, username=("a" * length), display_name="d" * 100) + assert len(user["username"]) == length + assert len(user["display_name"]) == 100 + + +@pytest.mark.parametrize("password", [" " * 12, "\t" * 12, " \n" * 6]) +async def test_whitespace_only_password_is_rejected(client: AsyncClient, password: str): + response = await client.post( + "/api/v1/users", + json={"username": "blank_pw", "display_name": "Blank", "password": password}, + ) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" + assert_request_id(response) + + +@pytest.mark.parametrize("field", ["display_name", "password"]) +async def test_nul_in_user_fields_is_rejected(client: AsyncClient, field: str): + body = {"username": "nul_user", "display_name": "Nul", "password": PASSWORD} + body[field] = body[field] + "\u0000tail" + + response = await client.post("/api/v1/users", json=body) + + assert response.status_code == 400 + assert response.json()["error"]["code"] == "invalid_request" -- 2.54.0 From f20b751207ed9948bfcdab829c458a4af122d611 Mon Sep 17 00:00:00 2001 From: gytall Date: Wed, 4 Nov 2026 13:51:50 +0300 Subject: [PATCH 2/5] fix gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index c0355e14..06112c66 100644 --- a/.gitignore +++ b/.gitignore @@ -33,4 +33,5 @@ coverage/ /venv .ruff_cache/ -/docs \ No newline at end of file +/docs +AGENTS.md \ No newline at end of file -- 2.54.0 From 5c191c3bc5dadbb8b0673517a37842fa18c6407e Mon Sep 17 00:00:00 2001 From: gytall Date: Wed, 4 Nov 2026 17:20:59 +0300 Subject: [PATCH 3/5] two api-replicas with LB-nginx --- .env.example | 10 +- .gitignore | 3 +- Dockerfile | 12 +- Makefile | 53 ++- REPORT.md | 101 +++-- app/core/config.py | 36 +- app/core/instance.py | 32 +- app/core/lifecycle.py | 52 ++- app/core/request_capacity.py | 4 +- app/core/security.py | 2 +- app/domain/idempotency.py | 73 ++-- app/domain/messages.py | 25 +- app/endpoints/health.py | 18 +- app/endpoints/messages.py | 17 +- app/errors/handlers.py | 4 + app/main.py | 22 +- app/models/__init__.py | 3 +- app/models/idempotency_key.py | 42 +-- app/storage/idempotency.py | 63 ++++ compose.test.yaml | 4 +- compose.yaml | 135 +++++-- evidence/README.md | 102 ++++- evidence/cleanup.txt | 19 + evidence/metrics.json | 147 ++++++++ evidence/nginx-output.txt | 11 + evidence/run.json | 149 ++++++++ evidence/source-sha256.txt | 107 ++++++ evidence/test-output.txt | 254 +++++++++++++ infra/README.md | 205 ++++++++++- infra/nginx/nginx.conf | 118 ++++-- infra/redis/start-redis.sh | 10 + .../49d2c947a3f1_add_idempotency_keys.py | 43 +++ scripts/__init__.py | 1 + scripts/check_grade4.py | 348 ++++++++++++++++++ scripts/check_idempotency.py | 39 ++ scripts/check_nginx.py | 261 +++++++++++++ scripts/deployment.py | 107 ++++++ scripts/failover_all.py | 148 ++++++++ scripts/prepare_secrets.py | 46 +++ scripts/restart.sh | 5 - scripts/rolling_update.py | 92 +++++ scripts/stop-one.sh | 39 +- student-tests/test_concurrency.py | 6 +- student-tests/test_idempotency.py | 156 ++++++++ student-tests/test_instance.py | 106 ++++++ student-tests/test_lifecycle.py | 50 +++ student-tests/test_limits.py | 16 +- student-tests/test_messages.py | 3 +- student-tests/test_migrations.py | 2 +- tests/__init__.py | 1 + 50 files changed, 2991 insertions(+), 311 deletions(-) create mode 100644 app/storage/idempotency.py create mode 100644 evidence/cleanup.txt create mode 100644 evidence/metrics.json create mode 100644 evidence/nginx-output.txt create mode 100644 evidence/run.json create mode 100644 evidence/source-sha256.txt create mode 100644 evidence/test-output.txt create mode 100644 infra/redis/start-redis.sh create mode 100644 migrations/versions/49d2c947a3f1_add_idempotency_keys.py create mode 100644 scripts/__init__.py create mode 100644 scripts/check_grade4.py create mode 100644 scripts/check_idempotency.py create mode 100644 scripts/check_nginx.py create mode 100644 scripts/deployment.py create mode 100644 scripts/failover_all.py create mode 100644 scripts/prepare_secrets.py create mode 100644 scripts/rolling_update.py create mode 100644 student-tests/test_idempotency.py create mode 100644 student-tests/test_instance.py create mode 100644 student-tests/test_lifecycle.py create mode 100644 tests/__init__.py 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-клиент и проверки контракта.""" -- 2.54.0 From 01879f699ae487b5a18cae2c18ceeef475d9e9c9 Mon Sep 17 00:00:00 2001 From: gytall Date: Wed, 4 Nov 2026 19:00:49 +0300 Subject: [PATCH 4/5] small fix in report.md and makefile --- Makefile | 9 ++-- REPORT.md | 100 ++++++++++++++++++------------------- evidence/README.md | 7 ++- infra/README.md | 29 +++++++---- scripts/prepare_secrets.py | 46 ----------------- 5 files changed, 77 insertions(+), 114 deletions(-) delete mode 100644 scripts/prepare_secrets.py diff --git a/Makefile b/Makefile index eac4edc6..77269af8 100644 --- a/Makefile +++ b/Makefile @@ -39,7 +39,7 @@ endef test-stand-smoke test-stand-persistence test-stand-failover \ test-own test-docker test-limits test-concurrency test-migrations test-all \ explain expiry-demo failure-demo test-nginx test-grade3 test-stand-idempotency \ - prepare-secrets rolling-update failover-all test-grade4 + rolling-update failover-all test-grade4 help: @echo "Проверки: check | validate | test | load | test-persistence ACTION_SCRIPT=scripts/restart.sh" @@ -51,7 +51,7 @@ help: @echo "Демо: explain | expiry-demo | failure-demo (на тестовом стенде)" @echo "Nginx: test-nginx (отдельный временный стенд без БД и приложения)" @echo "Lab3: test-grade3 (все проверки уровня 3 с удалением тестовых volumes)" - @echo "Уровень4: prepare-secrets | rolling-update | failover-all" + @echo "Уровень4: rolling-update | failover-all" @echo " test-grade4 (полный прогон на отдельном стенде с очисткой)" @echo "Миграции: migration m='описание' (нужен поднятый тестовый стенд)" @@ -74,7 +74,7 @@ test-grade3: test-grade4: @set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \ - $(MAKE) prepare-secrets check validate; \ + $(MAKE) check validate; \ $(MAKE) test-stand-up; \ $(MAKE) test-docker test-stand-smoke test-stand-idempotency test-stand-persistence test-stand-failover; \ $(TEST_ENV) $(PYTHON) -m scripts.check_grade4 --base-url "$(TEST_BASE_URL)" @@ -95,9 +95,6 @@ test-failover: # --- Основной стенд --- -prepare-secrets: - $(PYTHON) -m scripts.prepare_secrets - rolling-update: $(PYTHON) -m scripts.rolling_update --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index fd216c2f..41520b72 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,92 +1,90 @@ # Отчёт — лабораторная 3 + + Автор: **Григорян Илья Мурадович, БПИ2303**. Целевая оценка: **4**, трек 5 не заявлен. + Проверка: 04.11.2026. Базовый commit: `f20b751207ed9948bfcdab829c458a4af122d611`; + реализация находится в незакоммиченном рабочем дереве, PR ещё не создан. + Точный состав проверенного кода — [SHA-256 файлов](evidence/source-sha256.txt). + + ## Запуск и проверки Нужны Python 3.12, Docker и Compose. Из корня чистого клона: - ```sh + python3 -m venv .venv + .venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt + test -f .env || cp .env.example .env + make prepare-secrets PYTHON=.venv/bin/python + make up + make instances + ``` -Настройте `.env` перед запуском; существующий файл не заменяйте. Пароли читаются -из `secrets/`; существующие файлы не перезаписываются. По умолчанию вход — -`http://localhost:8080`, при изменении `LB_HOST_PORT` Make использует этот порт. +Настройте `.env` перед запуском; существующий файл не заменяйте. Пароли читаются из `secrets/`; +существующие файлы не перезаписываются. По умолчанию вход — `http://localhost:8080`, при изменении `LB_HOST_PORT` Make использует этот порт. `make down` сохраняет данные. Миграции выполняет отдельный сервис перед API. Полный прогон с отдельными данными и автоматическим удалением тестового стенда: ```sh + make test-grade4 PYTHON=.venv/bin/python + make test-nginx PYTHON=.venv/bin/python + ``` -Для ручного тестового стенда: `make test-stand-up`, затем `make test-docker -PYTHON=.venv/bin/python` и нужные `test-stand-*` из `make help`. По умолчанию вход -`:18080`, PostgreSQL `:15432`, Redis `:16379`. Pytest очищает `_test` и -Redis DB 15. `make test-stand-destroy` удаляет именно тестовые volumes. +Для ручного тестового стенда: `make test-stand-up`, затем `make test-docker PYTHON=.venv/bin/python` и нужные `test-stand-*` из `make help`. +По умолчанию вход `:18080`, PostgreSQL `:15432`, Redis `:16379`. Pytest очищает `_test` и Redis DB 15. `make test-stand-destroy` удаляет именно тестовые volumes. ## Реализация и результаты -Nginx → две API → общие PostgreSQL и Redis. Сообщение, счётчик и результат ключа -фиксируются одной транзакцией; PostgreSQL-блокировка сериализует одинаковый ключ -между репликами. Подробности, файлы и параметры — [EXPLAIN.md](EXPLAIN.md), ответы -для защиты — [DEFENCE.md](DEFENCE.md), методика — [evidence/README.md](evidence/README.md). +- Nginx → две API → общие PostgreSQL и Redis. +- Сообщение, счётчик и результат ключа фиксируются одной транзакцией; +- PostgreSQL-блокировка сериализует одинаковый ключ между репликами. + Все строки ниже проверены командой `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. | +| Критерий 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. | **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 с | +Отдельный `make test-nginx` подтвердил конфигурацию, DNS без reload, ограничитель, ошибки и gzip 2060 → 61 байт. -Подтверждённые сообщения сохранены, дублей нет. Ошибки измерены за весь сценарий; -429 связаны с ограничителем, 503 — с временной недоступностью. Механизм обновления -проверен изменением метки образа без изменения бизнес-кода; новых ожидающих DDL -на этапе rolling не было. Будущие миграции требуют отдельной проверки совместимости. +| Сценарий | Успешных ответов | 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 с | -## Параметры и ограничения +## Параметры и ограничения -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; -приведённые результаты получены реальным запуском команд. +- 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 не ослаблены. \ No newline at end of file diff --git a/evidence/README.md b/evidence/README.md index 5ab9bdf8..8047267f 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -5,6 +5,9 @@ `f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit. Состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt). Документация не включена в этот fingerprint; её подготовка продолжалась после тестов. +Позднее скрипт подготовки секретов удалён, Makefile изменён для ручного bootstrap. +Сохранённые вывод и хеши описывают прежний прогон и намеренно не переписываются; +проверка хешей на текущем дереве покажет эти различия. ## Артефакты @@ -23,11 +26,11 @@ ## Как повторить -Нужны Docker, Compose и Python 3.12 с зависимостями проекта. Из корня: +Нужны Docker, Compose и Python 3.12 с зависимостями проекта. До запуска вручную +подготовьте файлы паролей по [инструкции](../infra/README.md#секреты). Из корня: ```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 ``` diff --git a/infra/README.md b/infra/README.md index da3c4f95..497b533a 100644 --- a/infra/README.md +++ b/infra/README.md @@ -94,16 +94,27 @@ backend по собственным пассивным проверкам. Дл ### Секреты -Перед первым запуском нового профиля: +Пароли задаются вручную в `secrets/db_password` и `secrets/redis_password`. +Каждый файл содержит один пароль без крайних пробелов; существующие значения +не заменяйте при обычном запуске. Значения в `.env` не копируются в эти файлы. + +Перед первым запуском создайте каталог: ```sh -make prepare-secrets PYTHON=.venv/bin/python +mkdir -p secrets +chmod 700 secrets ``` -Скрипт создаёт отсутствующие `secrets/db_password` и `secrets/redis_password`. -Прежние значения из локального `.env` сохраняются; если их нет, генерируются -случайные пароли. Существующие секреты не перезаписываются, значения не выводятся. -Это не ротация пароля уже созданной БД. Каталог исключён из Git. +Создайте оба файла в редакторе, затем установите права: + +```sh +chmod 444 secrets/db_password secrets/redis_password +``` + +Каталог исключён из Git. Для редактирования существующего файла временно разрешите +запись владельцу через `chmod u+w secrets/redis_password` (или `db_password`), +после изменения верните режим 0444. Смена файла не меняет пароль пользователя +уже созданной PostgreSQL: это отдельная операция в БД. Compose монтирует файлы в `/run/secrets/`. PostgreSQL получает только пароль БД, Redis — только свой пароль, API — оба, миграции — только пароль БД, Nginx — ни одного. @@ -115,10 +126,10 @@ Redis — только свой пароль, API — оба, миграции В контейнерах API внутренний порт фиксирован на 8080, идентификатор берётся из собственного HOSTNAME; общий `INSTANCE_ID` всем репликам из `.env` не передаётся. -Каталог создаётся с правами 0700, файлы — 0444: Compose использует bind-mount +Рекомендуемые права: каталог 0700, файлы 0444: Compose использует bind-mount файлов, и их должны читать UID приложения и служебные UID PostgreSQL/Redis. -Доступ других пользователей хоста ограничивает родительский каталог. Существующие -файлы также получают этот режим. Пароли не должны содержать крайние пробелы или +Доступ других пользователей хоста ограничивает родительский каталог. +Права устанавливаются вручную. Пароли не должны содержать крайние пробелы или переносы строк. Локальные тесты Make читают те же файлы, сохраняя fallback старого `.env`. Redis запускается через `infra/redis/start-redis.sh`: SHA-256 пароля записывается diff --git a/scripts/prepare_secrets.py b/scripts/prepare_secrets.py deleted file mode 100644 index f84f7a17..00000000 --- a/scripts/prepare_secrets.py +++ /dev/null @@ -1,46 +0,0 @@ -"""Подготавливает локальные файлы 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() -- 2.54.0 From 2dd95db70c7a0a9892f6082ef6c572250ac39562 Mon Sep 17 00:00:00 2001 From: gytall Date: Wed, 4 Nov 2026 19:03:57 +0300 Subject: [PATCH 5/5] fix sha256sum for project --- REPORT.md | 4 +++- evidence/README.md | 14 ++++++++------ evidence/run.json | 9 +++++++-- evidence/source-sha256.txt | 5 ++--- 4 files changed, 20 insertions(+), 12 deletions(-) diff --git a/REPORT.md b/REPORT.md index 41520b72..fac013b8 100644 --- a/REPORT.md +++ b/REPORT.md @@ -8,7 +8,9 @@ реализация находится в незакоммиченном рабочем дереве, PR ещё не создан. -Точный состав проверенного кода — [SHA-256 файлов](evidence/source-sha256.txt). +Текущий снимок исходников — [SHA-256 файлов](evidence/source-sha256.txt). +Суммы обновлены после прогона; тесты повторно не запускались. Данные прогона +и сведения об обновлении снимка разделены в [run.json](evidence/run.json). diff --git a/evidence/README.md b/evidence/README.md index 8047267f..667ffcbb 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -3,11 +3,13 @@ Прогон от 04.11.2026, автор: Григорян Илья Мурадович, БПИ2303. Цель — оценка 4. Команды выполнялись на незакоммиченном рабочем дереве поверх commit `f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit. -Состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt). -Документация не включена в этот fingerprint; её подготовка продолжалась после тестов. -Позднее скрипт подготовки секретов удалён, Makefile изменён для ручного bootstrap. -Сохранённые вывод и хеши описывают прежний прогон и намеренно не переписываются; -проверка хешей на текущем дереве покажет эти различия. +Текущий состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt). +Документация, `.env` и секреты в этот fingerprint не включены. +После прогона скрипт подготовки секретов удалён, Makefile изменён для ручного bootstrap. +Контрольные суммы пересчитаны для текущей версии без повторного запуска тестов; +вывод и метрики прежнего прогона сохранены. В `run.json` отдельно указаны хеш +списка исходного прогона (`test_run_source_manifest_sha256`) и текущего снимка +(`source_manifest_sha256`), а также время обновления снимка. ## Артефакты @@ -17,7 +19,7 @@ | [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`. | +| [source-sha256.txt](source-sha256.txt) | SHA-256 текущих исходников, скриптов, тестов и конфигурации; это снимок после прогона. Проверка: `sha256sum -c evidence/source-sha256.txt`. | | [cleanup.txt](cleanup.txt) | Итоговая проверка удаления ресурсов лабораторной; conserver и его данные сохранены. | Результаты относятся только к этому прогону и составу файлов. После изменения кода, diff --git a/evidence/run.json b/evidence/run.json index 5130cf26..bce6dddd 100644 --- a/evidence/run.json +++ b/evidence/run.json @@ -2,7 +2,7 @@ "started_at_utc": "2026-11-04T13:59:48.203542+00:00", "base_commit": "f20b751207ed9948bfcdab829c458a4af122d611", "worktree_dirty": true, - "source_manifest_sha256": "73187c6a987b4fce648f79198a89a99b238bc5aa0617339d662b09c86cb423cb", + "source_manifest_sha256": "7a60b427d81530f186e6c4f036d436411c25b88dff69a724fe8bb56064f62dc2", "runtime_profile": { "API_REPLICAS": "2", "APP_PORT": "8080", @@ -145,5 +145,10 @@ "revision": null } ], - "manifest_scope": "Executable sources, tests and configuration; excludes documentation, .env and secrets." + "manifest_scope": "Executable sources, tests and configuration; excludes documentation, .env and secrets.", + "test_run_source_manifest_sha256": "73187c6a987b4fce648f79198a89a99b238bc5aa0617339d662b09c86cb423cb", + "source_manifest_updated_at_utc": "2026-11-04T16:01:53.226218+00:00", + "source_snapshot_base_commit": "01879f699ae487b5a18cae2c18ceeef475d9e9c9", + "source_manifest_matches_test_run": false, + "tests_repeated_for_source_snapshot": false } diff --git a/evidence/source-sha256.txt b/evidence/source-sha256.txt index f153e6d1..8214be25 100644 --- a/evidence/source-sha256.txt +++ b/evidence/source-sha256.txt @@ -1,6 +1,6 @@ ce3cd59eb07b3f3cfb85c19c9dfcba82aeca3b4231d523c6a2c85d28bf2b66f9 .env.example 2ea849842e877eca40e5dd853a5299a81be15fa414476fbfe434ac487f59ec1f Dockerfile -dd18f3dabac00cf562e2d4eec2615a3b7e37bb5343b47f1eb0f0fb49c2a11b7e Makefile +068ed8012751bb79e56e6253b7824bc1a87078c22e3e5b9e23c4f914ada8946d Makefile 274785e9cfb1af978fcdf254f3b9c93847216d9183cf290098f857f174f43b41 alembic.ini e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/__init__.py 5839d94c506f0362278a4f85bca8346774f5f323112963dd3830e525a069fb61 app/__main__.py @@ -52,7 +52,7 @@ f196fc426771cc9a628d25f466113badd1de1f123e9b3adc3cff9dc96e49824d app/storage/me aeb6851a54d71051912ad588c47de3d5a3d92d518a0a198dbb3e283dd64837c7 app/storage/sessions.py 46a0562d557ac96bd49f9975ff25ac8cce7f7f803b8c280d1d0bf2463ebfdaec app/storage/types.py f9dc7df7affda7144991944ff20a1ae5b372921b14fd391afa189d0e613dc45e app/storage/users.py -46f25ac85ff2a20a52cddf67b38c69f340bf007a355cd2e18c46e6aab9d22757 compose.test.yaml +69f84438aa1fb42fac6e66865e36697b3e6e5f826448b17a4a6a854d458a2946 compose.test.yaml 2a40970440a7c3fcdcb621a00ba9e55b3d5cae4c8da8cf2b8bef3b70dc29f263 compose.yaml d88506d8590ce549fd43dda7eea87f040dfff128af071f457b87e17df6282f5a infra/nginx/nginx.conf 9d4e7faeab76340dadda9916430048c32c849fb2bf02206653ea827e3304b666 infra/redis/redis.conf @@ -74,7 +74,6 @@ c95f74ebfec55b047424d65ed201519a79cd3292b9067fcf6913f5ac1bf3ab0b scripts/check_ 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 -- 2.54.0