Author SHA1 Message Date
gytall 2dd95db70c fix sha256sum for project 2026-11-04 19:03:57 +03:00
gytall 01879f699a small fix in report.md and makefile 2026-11-04 19:00:49 +03:00
gytall 5c191c3bc5 two api-replicas with LB-nginx 2026-11-04 17:20:59 +03:00
gytall f20b751207 fix gitignore 2026-11-04 13:51:50 +03:00
gytall df49fb5df4 create skeleton for lab 3 2026-10-30 00:53:49 +03:00
109 changed files with 7967 additions and 41 deletions
+43 -7
View File
@@ -1,13 +1,49 @@
# 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_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
# Пул на одну реплику: суммарно 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
API_IMAGE=mtusi-messenger:lab3
API_BUILD_REVISION=development
IDEMPOTENCY_TTL_SECONDS=86400
SHUTDOWN_DRAIN_SECONDS=1
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5
READINESS_TIMEOUT_SECONDS=2
# Порт единственной публичной точки входа (nginx)
LB_HOST_PORT=8080
# Используются только тестовым стендом (compose.test.yaml)
DB_HOST_PORT=15432
REDIS_HOST_PORT=16379
+6
View File
@@ -30,3 +30,9 @@ 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
AGENTS.md
.pytest_cache
+31
View File
@@ -0,0 +1,31 @@
FROM python:3.12.15-slim-bookworm
LABEL io.mtusi.messenger.secrets="file-v1"
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
ARG API_BUILD_REVISION
LABEL io.mtusi.messenger.revision=$API_BUILD_REVISION
USER appuser
EXPOSE 8080
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"]
+177 -4
View File
@@ -1,13 +1,61 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
-include .env
PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3)
PYTEST_ARGS ?=
BASE_URL ?= http://localhost:$(LB_HOST_PORT)
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 ?= mtusi-messenger-lab3-test
TEST_LB_PORT ?= 18080
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_DB_PASSWORD = $(if $(wildcard secrets/db_password),$(file <secrets/db_password),$(DB_PASSWORD))
TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(TEST_DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test
TEST_REDIS_HOST ?= localhost
TEST_REDIS_PASSWORD ?= $(if $(wildcard secrets/redis_password),$(file <secrets/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 test-nginx test-grade3 test-stand-idempotency \
rolling-update failover-all test-grade4
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 "Nginx: test-nginx (отдельный временный стенд без БД и приложения)"
@echo "Lab3: test-grade3 (все проверки уровня 3 с удалением тестовых volumes)"
@echo "Уровень4: rolling-update | failover-all"
@echo " test-grade4 (полный прогон на отдельном стенде с очисткой)"
@echo "Миграции: migration m='описание' (нужен поднятый тестовый стенд)"
# --- Проверки API и сценариев отказа (tests/) ---
check:
$(PYTHON) scripts/check_contract.py
@@ -15,6 +63,22 @@ check:
validate:
$(PYTHON) scripts/validate_openapi.py
test-nginx:
$(PYTHON) scripts/check_nginx.py
test-grade3:
@set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \
$(MAKE) check validate; \
$(MAKE) test-stand-up; \
$(MAKE) test-docker test-stand-smoke test-stand-idempotency test-stand-persistence test-stand-failover
test-grade4:
@set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \
$(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)"
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
@@ -28,3 +92,112 @@ 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)
# --- Основной стенд ---
rolling-update:
$(PYTHON) -m scripts.rolling_update --base-url "$(BASE_URL)" $(TLS_ARGS)
failover-all:
$(PYTHON) -m scripts.failover_all --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-idempotency:
$(PYTHON) -m scripts.check_idempotency --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 $(PYTEST_ARGS)
test-docker:
$(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q $(PYTEST_ARGS)
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
+78 -23
View File
@@ -1,37 +1,92 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
Автор: **Григорян Илья Мурадович, БПИ2303**. Целевая оценка: **4**, трек 5 не заявлен.
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Проверка: 04.11.2026. Базовый commit: `f20b751207ed9948bfcdab829c458a4af122d611`;
## Архитектура и решения
реализация находится в незакоммиченном рабочем дереве, PR ещё не создан.
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Текущий снимок исходников — [SHA-256 файлов](evidence/source-sha256.txt).
Суммы обновлены после прогона; тесты повторно не запускались. Данные прогона
и сведения об обновлении снимка разделены в [run.json](evidence/run.json).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
## Запуск и проверки
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Нужны Python 3.12, Docker и Compose. Из корня чистого клона:
```sh
## Эксперименты и отказы
python3 -m venv .venv
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
test -f .env || cp .env.example .env
## Ограничения и следующие шаги
make prepare-secrets PYTHON=.venv/bin/python
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
make up
make instances
```
Настройте `.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 очищает `<DB_NAME>_test` и Redis DB 15. `make test-stand-destroy` удаляет именно тестовые volumes.
## Реализация и результаты
- 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. |
**156 pytest прошли за 42,30 с**. Проверки контракта и OpenAPI прошли.
Отдельный `make test-nginx` подтвердил конфигурацию, DNS без reload, ограничитель, ошибки и gzip 2060 → 61 байт.
| Сценарий | Успешных ответов | 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 не ослаблены.
+38
View File
@@ -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
View File
+4
View File
@@ -0,0 +1,4 @@
from app.main import main
if __name__ == "__main__":
main()
View File
+113
View File
@@ -0,0 +1,113 @@
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, 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):
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
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)
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}://")
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)
+44
View File
@@ -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
+40
View File
@@ -0,0 +1,40 @@
"""Идентификатор 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
INSTANCE_ID_HEADER = "X-Instance-Id"
def resolve_instance_id(configured: str | None) -> str:
"""Выбирает INSTANCE_ID, HOSTNAME или UUID при старте приложения."""
if configured and configured.strip():
return configured.strip()
hostname = os.getenv("HOSTNAME", "").strip()
if hostname:
return hostname
return str(uuid4())
class InstanceIdMiddleware(BaseHTTPMiddleware):
"""Добавляет сохранённый идентификатор реплики в ответ."""
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:
response = await call_next(request)
response.headers[INSTANCE_ID_HEADER] = self.instance_id
return response
+50
View File
@@ -0,0 +1,50 @@
"""Готовность реплики и мягкое завершение сервера."""
import asyncio
from types import FrameType
import uvicorn
class Lifecycle:
"""Хранит состояние завершения реплики."""
def __init__(self) -> None:
self._draining = False
@property
def draining(self) -> bool:
return self._draining
def start_draining(self) -> None:
"""Отключает приём новых бизнес-запросов."""
self._draining = True
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)
+38
View File
@@ -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
+42
View File
@@ -0,0 +1,42 @@
from collections.abc import AsyncIterator
from fastapi import Request
from app.errors.exceptions import rate_limited, unavailable
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]:
if request.app.state.lifecycle.draining:
raise unavailable("Реплика завершает работу")
capacity: RequestCapacity = request.app.state.request_capacity
if not capacity.try_acquire():
raise rate_limited()
try:
yield
finally:
capacity.release()
+22
View File
@@ -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
+63
View File
@@ -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, min(2, (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()
+1
View File
@@ -0,0 +1 @@
"""Бизнес-логика: проверки доступа, транзакции и ошибки API."""
+84
View File
@@ -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()
+104
View File
@@ -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
+66
View File
@@ -0,0 +1,66 @@
"""Атомарная отправка сообщения с защитой от повторов."""
import hashlib
import json
import re
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:
"""Проверяет обязательный 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:
"""Хеширует нормализованное содержимое запроса."""
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:
"""Создаёт сообщение или возвращает результат прежнего запроса."""
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)
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
+39
View File
@@ -0,0 +1,39 @@
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.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 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
+83
View File
@@ -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)
+41
View File
@@ -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
View File
+32
View File
@@ -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)
+32
View File
@@ -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)
+100
View File
@@ -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)]
+32
View File
@@ -0,0 +1,32 @@
import asyncio
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:
if request.app.state.lifecycle.draining:
raise unavailable()
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")
+38
View File
@@ -0,0 +1,38 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Header, Query
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
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,
idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None,
) -> Message:
return await send_message_idempotent(
session, sender, chat_id, new_message,
validate_idempotency_key(idempotency_key),
settings.max_messages, settings.idempotency_ttl_seconds,
)
@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)
+17
View File
@@ -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
View File
+85
View File
@@ -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", "Внутренняя ошибка сервера")
+201
View File
@@ -0,0 +1,201 @@
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.instance import INSTANCE_ID_HEADER
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,
}
instance_id = getattr(request.app.state, "instance_id", None)
if instance_id is not None:
response_headers[INSTANCE_ID_HEADER] = instance_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)
+84
View File
@@ -0,0 +1,84 @@
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.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
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)
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)]
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
application = create_app(settings)
config = uvicorn.Config(
application,
host=settings.app_host,
port=settings.app_port,
log_level=settings.log_level.lower(),
timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds,
)
GracefulServer(
config, application.state.lifecycle, settings.shutdown_drain_seconds
).run()
if __name__ == "__main__":
main()
+9
View File
@@ -0,0 +1,9 @@
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", "IdempotencyKey", "Message", "User"]
+27
View File
@@ -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),
}
+32
View File
@@ -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"
)
+26
View File
@@ -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")
+13
View File
@@ -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)
+24
View File
@@ -0,0 +1,24 @@
"""Сохранённый результат отправки сообщения."""
import uuid
from datetime import datetime
from sqlalchemy import ForeignKey, Index, String, func
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
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())
+30
View File
@@ -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")
+31
View File
@@ -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"
)
+6
View File
@@ -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"]
+35
View File
@@ -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")
+22
View File
@@ -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
+22
View File
@@ -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
+17
View File
@@ -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
+25
View File
@@ -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
)
+1
View File
@@ -0,0 +1 @@
"""Доступ к данным PostgreSQL и Redis."""
+71
View File
@@ -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
+63
View File
@@ -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(),
},
)
)
+58
View File
@@ -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
+38
View File
@@ -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
+6
View File
@@ -0,0 +1,6 @@
"""Общие типы слоя хранения."""
from datetime import datetime
from uuid import UUID
Position = tuple[datetime, UUID]
+47
View File
@@ -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
+10
View File
@@ -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:?Set DB_HOST_PORT in .env}"
redis:
ports:
- "127.0.0.1:${REDIS_HOST_PORT:?Set REDIS_HOST_PORT in .env}"
+160
View File
@@ -0,0 +1,160 @@
name: mtusi-messenger-lab3
x-api-image: &api-image
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
environment:
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
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 3s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
redis:
image: redis:7.4.2-bookworm
restart: unless-stopped
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-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping"]
interval: 3s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "0.5"
memory: 512M
migrate:
<<: *api-image
command: ["alembic", "upgrade", "head"]
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
environment:
<<: *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:?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
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:?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
timeout: 3s
retries: 5
depends_on:
api:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
volumes:
pgdata:
redisdata:
secrets:
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
+104 -3
View File
@@ -1,5 +1,106 @@
# Доказательства
# Доказательства лабораторной 3
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Прогон от 04.11.2026, автор: Григорян Илья Мурадович, БПИ2303. Цель — оценка 4.
Команды выполнялись на незакоммиченном рабочем дереве поверх commit
`f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit.
Текущий состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt).
Документация, `.env` и секреты в этот fingerprint не включены.
После прогона скрипт подготовки секретов удалён, Makefile изменён для ручного bootstrap.
Контрольные суммы пересчитаны для текущей версии без повторного запуска тестов;
вывод и метрики прежнего прогона сохранены. В `run.json` отдельно указаны хеш
списка исходного прогона (`test_run_source_manifest_sha256`) и текущего снимка
(`source_manifest_sha256`), а также время обновления снимка.
Не добавляйте .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 заменён на `<repository>`. |
| [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 с зависимостями проекта. До запуска вручную
подготовьте файлы паролей по [инструкции](../infra/README.md#секреты). Из корня:
```sh
test -f .env || cp .env.example .env
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. Собственные тесты используют отдельную БД `<DB_NAME>_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 храните отдельно по правилам преподавателя.
+19
View File
@@ -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.
+147
View File
@@ -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
}
]
+11
View File
@@ -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 и результат лимита
+154
View File
@@ -0,0 +1,154 @@
{
"started_at_utc": "2026-11-04T13:59:48.203542+00:00",
"base_commit": "f20b751207ed9948bfcdab829c458a4af122d611",
"worktree_dirty": true,
"source_manifest_sha256": "7a60b427d81530f186e6c4f036d436411c25b88dff69a724fe8bb56064f62dc2",
"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.",
"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
}
+106
View File
@@ -0,0 +1,106 @@
ce3cd59eb07b3f3cfb85c19c9dfcba82aeca3b4231d523c6a2c85d28bf2b66f9 .env.example
2ea849842e877eca40e5dd853a5299a81be15fa414476fbfe434ac487f59ec1f Dockerfile
068ed8012751bb79e56e6253b7824bc1a87078c22e3e5b9e23c4f914ada8946d 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
69f84438aa1fb42fac6e66865e36697b3e6e5f826448b17a4a6a854d458a2946 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
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
+254
View File
@@ -0,0 +1,254 @@
make[1]: Entering directory '<repository>'
.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 '<repository>'
make[1]: Entering directory '<repository>'
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 '<repository>'
make[1]: Entering directory '<repository>'
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 '<repository>'
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
+212 -4
View File
@@ -1,7 +1,215 @@
# Инфраструктура студента
# Инфраструктура проекта
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом 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, не считая миграций и диагностики.
### Секреты
Пароли задаются вручную в `secrets/db_password` и `secrets/redis_password`.
Каждый файл содержит один пароль без крайних пробелов; существующие значения
не заменяйте при обычном запуске. Значения в `.env` не копируются в эти файлы.
Перед первым запуском создайте каталог:
```sh
mkdir -p secrets
chmod 700 secrets
```
Создайте оба файла в редакторе, затем установите права:
```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 — ни одного.
Все переменные 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).
+117
View File
@@ -0,0 +1,117 @@
# Единая точка входа: round-robin между API-репликами, без sticky sessions.
# Директивы рассчитаны на закреплённый nginx:1.28.0-alpine.
worker_processes 2;
events {
worker_connections 1024;
}
http {
# В логе используем request_id ответа API, для собственных ошибок — id nginx.
map $upstream_http_x_request_id $response_request_id {
"" $request_id;
default $upstream_http_x_request_id;
}
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 {
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;
default_type text/plain;
return 200 "ok\n";
}
# Проверки готовности/жизни не расходуют бюджет бизнес-запросов.
location /health/ {
proxy_pass http://api_backend;
}
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"}}';
}
}
}
+5
View File
@@ -0,0 +1,5 @@
dir /data
appendonly yes
appendfsync always
maxmemory 256mb
maxmemory-policy noeviction
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
password_hash=$(tr -d '\r\n' </run/secrets/redis_password | sha256sum | cut -d ' ' -f 1)
mkdir -p /run/redis
umask 077
printf 'user default reset on #%s ~* &* +@all\n' "$password_hash" >/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
+68
View File
@@ -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()
+25
View File
@@ -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"}
View File
@@ -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")
@@ -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 ###
@@ -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 ###
+6
View File
@@ -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
+50
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
"""Команды управления учебным стендом."""
+348
View File
@@ -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)
+39
View File
@@ -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)
+261
View File
@@ -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()
+107
View File
@@ -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
+28
View File
@@ -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")"
+132
View File
@@ -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())
+148
View File
@@ -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)
+64
View File
@@ -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")"
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
compose() {
docker compose --env-file .env "$@"
}
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
compose restart nginx
wait_healthy nginx
+92
View File
@@ -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()
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
*[!a-zA-Z0-9_.:-]*|'') exit 1 ;;
esac
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
+200
View File
@@ -0,0 +1,200 @@
"""Фикстуры async-тестов на реальных PostgreSQL и Redis.
Перед запуском: `make test-stand-up` (тестовый стенд из compose.yaml + compose.test.yaml
и база <DB_NAME>_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)
+88
View File
@@ -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
+298
View File
@@ -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")
+209
View File
@@ -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"
+266
View File
@@ -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, idempotency_header, 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), **idempotency_header()},
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), **idempotency_header()},
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
+46
View File
@@ -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"]},
)
+76
View File
@@ -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")
+138
View File
@@ -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
+62
View File
@@ -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)
+78
View File
@@ -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)
+156
View File
@@ -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

Some files were not shown because too many files have changed in this diff Show More