forked from mtusi2026/mtusi2026lab3
two api-replicas with LB-nginx
This commit is contained in:
+4
-6
@@ -15,7 +15,6 @@ SESSION_STORE=redis
|
||||
REDIS_HOST=redis
|
||||
REDIS_PORT=6379
|
||||
REDIS_DB=0
|
||||
REDIS_PASSWORD=change-me
|
||||
REDIS_MAX_CONNECTIONS=20
|
||||
REDIS_POOL_TIMEOUT_SECONDS=1
|
||||
REDIS_CONNECT_TIMEOUT_SECONDS=1
|
||||
@@ -25,7 +24,6 @@ DB_HOST=postgres
|
||||
DB_PORT=5432
|
||||
DB_NAME=messenger
|
||||
DB_USER=messenger
|
||||
DB_PASSWORD=change-me
|
||||
|
||||
# Пул на одну реплику: суммарно API_REPLICAS * (POOL_SIZE + MAX_OVERFLOW)
|
||||
# соединений должно помещаться в max_connections PostgreSQL.
|
||||
@@ -37,12 +35,12 @@ DB_STATEMENT_TIMEOUT_MS=5000
|
||||
|
||||
# --- Балансировка и идемпотентность ---
|
||||
API_REPLICAS=2
|
||||
API_IMAGE=mtusi-messenger:lab3
|
||||
API_BUILD_REVISION=development
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
# Пусто -> id вычисляется в app/core/instance.py (TODO 3.2)
|
||||
# INSTANCE_ID=api-1
|
||||
# TODO(4.1): сколько секунд отдавать readiness=503 перед закрытием сокета
|
||||
SHUTDOWN_DRAIN_SECONDS=0
|
||||
SHUTDOWN_DRAIN_SECONDS=1
|
||||
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5
|
||||
READINESS_TIMEOUT_SECONDS=2
|
||||
|
||||
# Порт единственной публичной точки входа (nginx)
|
||||
LB_HOST_PORT=8080
|
||||
|
||||
+2
-1
@@ -34,4 +34,5 @@ coverage/
|
||||
/venv
|
||||
.ruff_cache/
|
||||
/docs
|
||||
AGENTS.md
|
||||
AGENTS.md
|
||||
.pytest_cache
|
||||
+7
-5
@@ -1,5 +1,7 @@
|
||||
FROM python:3.12.15-slim-bookworm
|
||||
|
||||
LABEL io.mtusi.messenger.secrets="file-v1"
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
@@ -16,14 +18,14 @@ COPY alembic.ini ./
|
||||
COPY migrations ./migrations
|
||||
COPY app ./app
|
||||
|
||||
USER appuser
|
||||
ARG API_BUILD_REVISION
|
||||
LABEL io.mtusi.messenger.revision=$API_BUILD_REVISION
|
||||
|
||||
# TODO(4.1): uvicorn корректно завершается по SIGTERM (сигнал Docker по умолчанию).
|
||||
# Проверьте, что python — PID 1 (exec-форма CMD), иначе сигнал не дойдёт.
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/live', timeout=2)"]
|
||||
HEALTHCHECK --interval=3s --timeout=3s --start-period=10s --retries=2 \
|
||||
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
|
||||
|
||||
CMD ["python", "-m", "app"]
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
-include .env
|
||||
|
||||
PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3)
|
||||
BASE_URL ?= http://localhost:8080
|
||||
PYTEST_ARGS ?=
|
||||
BASE_URL ?= http://localhost:$(LB_HOST_PORT)
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
@@ -10,18 +11,19 @@ COMPOSE = docker compose --env-file .env
|
||||
|
||||
# Отдельный тестовый стенд: свой compose-проект, свои порты, открытые БД/Redis
|
||||
# (compose.test.yaml). COMPOSE_FILE подхватывают и scripts/*.sh.
|
||||
TEST_PROJECT ?= $(notdir $(CURDIR))-test
|
||||
TEST_PROJECT ?= mtusi-messenger-lab3-test
|
||||
TEST_LB_PORT ?= 18080
|
||||
TEST_DB_PORT ?= 15432
|
||||
TEST_REDIS_PORT ?= 16379
|
||||
TEST_DB_PORT ?= $(DB_HOST_PORT)
|
||||
TEST_REDIS_PORT ?= $(REDIS_HOST_PORT)
|
||||
TEST_BASE_URL = http://localhost:$(TEST_LB_PORT)
|
||||
TEST_ENV = COMPOSE_PROJECT_NAME=$(TEST_PROJECT) COMPOSE_FILE=compose.yaml:compose.test.yaml \
|
||||
LB_HOST_PORT=$(TEST_LB_PORT) DB_HOST_PORT=$(TEST_DB_PORT) REDIS_HOST_PORT=$(TEST_REDIS_PORT)
|
||||
TEST_COMPOSE = $(TEST_ENV) $(COMPOSE)
|
||||
|
||||
TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test
|
||||
TEST_DB_PASSWORD = $(if $(wildcard secrets/db_password),$(file <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 ?= $(REDIS_PASSWORD)
|
||||
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
|
||||
|
||||
@@ -36,7 +38,8 @@ endef
|
||||
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
|
||||
explain expiry-demo failure-demo test-nginx test-grade3 test-stand-idempotency \
|
||||
prepare-secrets rolling-update failover-all test-grade4
|
||||
|
||||
help:
|
||||
@echo "Проверки: check | validate | test | load | test-persistence ACTION_SCRIPT=scripts/restart.sh"
|
||||
@@ -46,6 +49,10 @@ help:
|
||||
@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: prepare-secrets | rolling-update | failover-all"
|
||||
@echo " test-grade4 (полный прогон на отдельном стенде с очисткой)"
|
||||
@echo "Миграции: migration m='описание' (нужен поднятый тестовый стенд)"
|
||||
|
||||
# --- Проверки API и сценариев отказа (tests/) ---
|
||||
@@ -56,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) prepare-secrets 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)
|
||||
|
||||
@@ -72,6 +95,15 @@ test-failover:
|
||||
|
||||
# --- Основной стенд ---
|
||||
|
||||
prepare-secrets:
|
||||
$(PYTHON) -m scripts.prepare_secrets
|
||||
|
||||
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))
|
||||
@@ -125,6 +157,9 @@ test-stand-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)"
|
||||
@@ -139,10 +174,10 @@ test-stand-failover:
|
||||
# --- Собственные тесты (student-tests/) ---
|
||||
|
||||
test-own:
|
||||
$(PYTHON) -m pytest -q
|
||||
$(PYTHON) -m pytest -q $(PYTEST_ARGS)
|
||||
|
||||
test-docker:
|
||||
$(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q
|
||||
$(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q $(PYTEST_ARGS)
|
||||
|
||||
test-limits:
|
||||
$(PYTHON) -m pytest student-tests/test_limits.py -q
|
||||
|
||||
@@ -1,37 +1,92 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Автор: **Григорян Илья Мурадович, БПИ2303**. Целевая оценка: **4**, трек 5 не заявлен.
|
||||
Проверка: 04.11.2026. Базовый commit: `f20b751207ed9948bfcdab829c458a4af122d611`;
|
||||
реализация находится в незакоммиченном рабочем дереве, PR ещё не создан.
|
||||
Точный состав проверенного кода — [SHA-256 файлов](evidence/source-sha256.txt).
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Запуск и проверки
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Python 3.12, Docker и Compose. Из корня чистого клона:
|
||||
|
||||
## Архитектура и решения
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt
|
||||
test -f .env || cp .env.example .env
|
||||
make prepare-secrets PYTHON=.venv/bin/python
|
||||
make up
|
||||
make instances
|
||||
```
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Настройте `.env` перед запуском; существующий файл не заменяйте. Пароли читаются
|
||||
из `secrets/`; существующие файлы не перезаписываются. По умолчанию вход —
|
||||
`http://localhost:8080`, при изменении `LB_HOST_PORT` Make использует этот порт.
|
||||
`make down` сохраняет данные. Миграции выполняет отдельный сервис перед API.
|
||||
|
||||
## Доказательства критериев
|
||||
Полный прогон с отдельными данными и автоматическим удалением тестового стенда:
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
```sh
|
||||
make test-grade4 PYTHON=.venv/bin/python
|
||||
make test-nginx PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Для ручного тестового стенда: `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.
|
||||
|
||||
## Эксперименты и отказы
|
||||
## Реализация и результаты
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Nginx → две API → общие PostgreSQL и Redis. Сообщение, счётчик и результат ключа
|
||||
фиксируются одной транзакцией; PostgreSQL-блокировка сериализует одинаковый ключ
|
||||
между репликами. Подробности, файлы и параметры — [EXPLAIN.md](EXPLAIN.md), ответы
|
||||
для защиты — [DEFENCE.md](DEFENCE.md), методика — [evidence/README.md](evidence/README.md).
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Все строки ниже проверены командой `make test-grade4 PYTHON=.venv/bin/python`;
|
||||
исходный вывод — [test-output.txt](evidence/test-output.txt).
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
| Критерий README | Наблюдение |
|
||||
| --- | --- |
|
||||
| 3: воспроизводимая топология, ≥2 API, общие хранилища | Стенд создан с нуля; две API, одна PostgreSQL, одна Redis, вход через Nginx. |
|
||||
| 3: одна сессия на разных API | 24 конкурентных повтора с одной сессией обслужены двумя реальными репликами. |
|
||||
| 3: чтение/запись при отказе ≤10 с | Публичный failover прошёл; отдельный отказ каждой API — восстановление за 1,800 / 1,782 с. |
|
||||
| 3: общая идемпотентность | 24 повтора дали один Message и одну запись истории; конфликт тела, TTL и rollback покрыты pytest. |
|
||||
| 3: smoke, persistence, failover | Все прошли, существующая сессия и подтверждённые сообщения сохранены. |
|
||||
| 4: health, timeout, SIGTERM | При drain ready=503, live=200, новая работа=503; начатый POST=201, остановка за 2,145 с без SIGKILL. |
|
||||
| 4: последовательный отказ каждой API | До/после остановки и восстановления записаны состояния; RPS и ошибки приведены ниже. |
|
||||
| 4: лимиты, порты, секреты, масштабирование | Проверены фактические CPU/RAM, закрытые порты API, read-only секреты по назначению, отсутствие паролей в окружении и container_name. |
|
||||
| 4: обновление под нагрузкой | Оба контейнера заменены новым образом, миграционная команда вызвана один раз, перед остановкой доступны ≥2 здоровых API. |
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
**156 pytest прошли за 42,30 с**. Проверки контракта и OpenAPI прошли.
|
||||
Отдельный `make test-nginx` подтвердил конфигурацию, DNS без reload, ограничитель,
|
||||
ошибки и gzip 2060 → 61 байт: [вывод](evidence/nginx-output.txt).
|
||||
|
||||
| Сценарий | Успешных ответов | RPS | Ошибки попыток | Восстановление |
|
||||
| --- | ---: | ---: | --- | ---: |
|
||||
| Rolling update, 23,627 с | 456 | 19,300 | 13 × 503 | Не измерялось отдельно |
|
||||
| Отказ API 1, 13,853 с | 773 | 55,800 | 67 × 429; 16 × 503 | 1,800 с |
|
||||
| Отказ API 2, 13,875 с | 773 | 55,710 | 99 × 429; 17 × 503 | 1,782 с |
|
||||
|
||||
Подтверждённые сообщения сохранены, дублей нет. Ошибки измерены за весь сценарий;
|
||||
429 связаны с ограничителем, 503 — с временной недоступностью. Механизм обновления
|
||||
проверен изменением метки образа без изменения бизнес-кода; новых ожидающих DDL
|
||||
на этапе rolling не было. Будущие миграции требуют отдельной проверки совместимости.
|
||||
|
||||
## Параметры и ограничения
|
||||
|
||||
API: readiness каждые 3 с, timeout 3 с, две неудачи, start period 10 с; после старта
|
||||
оценка unhealthy ≤12 с. Nginx использует пассивные проверки: connect ≤0,5 с на попытку,
|
||||
пауза чтения ≤10 с, исключение peer на 5 с; без трафика обнаружение не происходит.
|
||||
Drain 1 с + ожидание задач 5 с < Docker grace 8 с. CPU/RAM каждого сервиса,
|
||||
оборудование, версии и профиль нагрузки — в [run.json](evidence/run.json) и
|
||||
[методике](evidence/README.md). Это один прогон с двумя клиентами, не измерение
|
||||
максимальной производительности. Средний RPS может превышать 50 из-за burst=100.
|
||||
|
||||
Стенд односерверный; PostgreSQL, Redis и Nginx остаются единичными точками отказа.
|
||||
Откат контейнеров не откатывает БД. TTL ключа — 24 часа, очистка при повторном
|
||||
использовании, фоновой очистки нет. Исходное задание и публичные tests не ослаблены.
|
||||
|
||||
Источники: [контракт](contracts/README.md), [курс](COURSE.md), закреплённые зависимости
|
||||
и их установленные исходники, ссылки на документацию Docker в [README](README.md#первичные-материалы).
|
||||
Для реализации, проверок и подготовки пояснений использован ИИ-помощник Codex;
|
||||
приведённые результаты получены реальным запуском команд.
|
||||
|
||||
+27
-9
@@ -1,11 +1,16 @@
|
||||
from enum import StrEnum
|
||||
from pathlib import Path
|
||||
from typing import Literal, Self
|
||||
|
||||
from pydantic import Field, SecretStr, model_validator
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict
|
||||
from sqlalchemy import URL
|
||||
|
||||
ASYNC_DRIVER = "postgresql+asyncpg"
|
||||
SECRETS_DIR = next(
|
||||
(path for path in (Path("/run/secrets"), Path(__file__).resolve().parents[2] / "secrets") if (path / "db_password").is_file()),
|
||||
None,
|
||||
)
|
||||
|
||||
|
||||
class LogLevel(StrEnum):
|
||||
@@ -51,23 +56,36 @@ class Settings(BaseSettings):
|
||||
db_connect_timeout_seconds: int = Field(default=3, ge=1)
|
||||
db_statement_timeout_ms: int = Field(default=5000, ge=1)
|
||||
|
||||
# Балансировка между репликами и идемпотентность
|
||||
instance_id: str | None = None # TODO(3.2): None -> вычислить в resolve_instance_id
|
||||
idempotency_ttl_seconds: int = Field(default=86400, ge=1) # TODO(3.4)
|
||||
shutdown_drain_seconds: float = Field(default=0, ge=0) # TODO(4.1)
|
||||
graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1) # TODO(4.1)
|
||||
instance_id: str | None = None
|
||||
idempotency_ttl_seconds: int = Field(default=86400, ge=1)
|
||||
shutdown_drain_seconds: float = Field(default=1, ge=0)
|
||||
graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1)
|
||||
readiness_timeout_seconds: float = Field(default=2, gt=0, lt=2.5)
|
||||
|
||||
# TODO(4.3): секреты из файлов (Docker secrets): pydantic-settings умеет
|
||||
# secrets_dir="/run/secrets" — имя файла = имя поля (db_password, ...).
|
||||
model_config = SettingsConfigDict(
|
||||
env_file=".env",
|
||||
env_file_encoding="utf-8",
|
||||
case_sensitive=False,
|
||||
extra="ignore",
|
||||
secrets_dir=SECRETS_DIR,
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def settings_customise_sources(
|
||||
cls,
|
||||
settings_cls: type[BaseSettings],
|
||||
init_settings: PydanticBaseSettingsSource,
|
||||
env_settings: PydanticBaseSettingsSource,
|
||||
dotenv_settings: PydanticBaseSettingsSource,
|
||||
file_secret_settings: PydanticBaseSettingsSource,
|
||||
) -> tuple[PydanticBaseSettingsSource, ...]:
|
||||
"""Явные параметры и файлы имеют приоритет над окружением."""
|
||||
return init_settings, file_secret_settings, env_settings, dotenv_settings
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _require_database_source(self) -> Self:
|
||||
if self.shutdown_drain_seconds + self.graceful_shutdown_timeout_seconds >= 8:
|
||||
raise ValueError("Drain и graceful shutdown должны суммарно занимать менее 8 секунд")
|
||||
if self.database_url is not None:
|
||||
if not self.database_url.get_secret_value().startswith(ASYNC_DRIVER):
|
||||
raise ValueError(f"DATABASE_URL должен начинаться с {ASYNC_DRIVER}://")
|
||||
@@ -75,7 +93,7 @@ class Settings(BaseSettings):
|
||||
|
||||
if not (self.db_host and self.db_name and self.db_user and self.db_password):
|
||||
raise ValueError(
|
||||
"Задайте DATABASE_URL или DB_HOST, DB_NAME, DB_USER и DB_PASSWORD"
|
||||
"Нужны DATABASE_URL либо DB_HOST, DB_NAME, DB_USER и секрет db_password"
|
||||
)
|
||||
return self
|
||||
|
||||
|
||||
+16
-16
@@ -1,5 +1,8 @@
|
||||
"""Идентификатор API-реплики и заголовок X-Instance-Id."""
|
||||
|
||||
import os
|
||||
from uuid import uuid4
|
||||
|
||||
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
@@ -8,25 +11,19 @@ INSTANCE_ID_HEADER = "X-Instance-Id"
|
||||
|
||||
|
||||
def resolve_instance_id(configured: str | None) -> str:
|
||||
"""Возвращает id реплики, стабильный в течение жизни процесса.
|
||||
"""Выбирает INSTANCE_ID, HOSTNAME или UUID при старте приложения."""
|
||||
if configured and configured.strip():
|
||||
return configured.strip()
|
||||
|
||||
TODO(3.2): выбрать источник id.
|
||||
- Если задан непустой INSTANCE_ID в настройках — вернуть его.
|
||||
- Иначе — что-то, что позволит stop-one.sh найти именно этот контейнер
|
||||
(подсказка: Docker кладёт короткий id контейнера в переменную HOSTNAME,
|
||||
а `docker stop <короткий id>` работает).
|
||||
- Значение вычисляется один раз при старте и не меняется до конца процесса.
|
||||
"""
|
||||
raise NotImplementedError("TODO(3.2): resolve_instance_id")
|
||||
hostname = os.getenv("HOSTNAME", "").strip()
|
||||
if hostname:
|
||||
return hostname
|
||||
|
||||
return str(uuid4())
|
||||
|
||||
|
||||
class InstanceIdMiddleware(BaseHTTPMiddleware):
|
||||
"""Добавляет X-Instance-Id в каждый ответ API, включая ошибки и /health/*.
|
||||
|
||||
TODO(3.2): реализовать dispatch по образцу RequestIdMiddleware
|
||||
(app/core/request_id.py) и подключить в create_app (app/main.py).
|
||||
Проверьте, что заголовок есть и у ответов из exception handlers.
|
||||
"""
|
||||
"""Добавляет сохранённый идентификатор реплики в ответ."""
|
||||
|
||||
def __init__(self, app, instance_id: str) -> None:
|
||||
super().__init__(app)
|
||||
@@ -37,4 +34,7 @@ class InstanceIdMiddleware(BaseHTTPMiddleware):
|
||||
request: Request,
|
||||
call_next: RequestResponseEndpoint,
|
||||
) -> Response:
|
||||
raise NotImplementedError("TODO(3.2): InstanceIdMiddleware.dispatch")
|
||||
response = await call_next(request)
|
||||
response.headers[INSTANCE_ID_HEADER] = self.instance_id
|
||||
|
||||
return response
|
||||
|
||||
+35
-17
@@ -1,12 +1,14 @@
|
||||
"""Состояние жизненного цикла реплики: готова / уходит (graceful shutdown).
|
||||
"""Готовность реплики и мягкое завершение сервера."""
|
||||
|
||||
Идея: при SIGTERM реплика сначала перестаёт быть "ready" (/health/ready -> 503),
|
||||
чтобы балансировщик успел исключить её, и только затем uvicorn перестаёт
|
||||
принимать соединения и дожидается текущих запросов.
|
||||
"""
|
||||
import asyncio
|
||||
from types import FrameType
|
||||
|
||||
import uvicorn
|
||||
|
||||
|
||||
class Lifecycle:
|
||||
"""Хранит состояние завершения реплики."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._draining = False
|
||||
|
||||
@@ -15,18 +17,34 @@ class Lifecycle:
|
||||
return self._draining
|
||||
|
||||
def start_draining(self) -> None:
|
||||
"""TODO(4.1): вызвать при получении SIGTERM / в начале shutdown."""
|
||||
"""Отключает приём новых бизнес-запросов."""
|
||||
self._draining = True
|
||||
|
||||
|
||||
# TODO(4.1): решить, где перехватывать SIGTERM.
|
||||
# uvicorn сам ставит обработчик SIGTERM и сразу закрывает listening socket,
|
||||
# поэтому "сначала readiness=503, потом закрыть приём" нужно сделать явно:
|
||||
# - либо обернуть/переопределить обработчик сигнала uvicorn
|
||||
# (uvicorn.Server.handle_exit) так, чтобы он сначала вызывал
|
||||
# lifecycle.start_draining(), ждал SHUTDOWN_DRAIN_SECONDS и только потом
|
||||
# передавал управление штатному завершению;
|
||||
# - либо полагаться на passive-проверки nginx (proxy_next_upstream) и честно
|
||||
# описать в REPORT.md, сколько запросов теряется.
|
||||
# Сумма drain + timeout_graceful_shutdown должна быть меньше stop_grace_period
|
||||
# в compose.yaml, иначе Docker добьёт процесс SIGKILL.
|
||||
class GracefulServer(uvicorn.Server):
|
||||
"""Оставляет время для исключения завершающейся реплики."""
|
||||
|
||||
def __init__(
|
||||
self, config: uvicorn.Config, lifecycle: Lifecycle, drain_seconds: float
|
||||
) -> None:
|
||||
super().__init__(config)
|
||||
self.lifecycle = lifecycle
|
||||
self.drain_seconds = drain_seconds
|
||||
self._drain_task: asyncio.Task[None] | None = None
|
||||
|
||||
def handle_exit(self, sig: int, frame: FrameType | None) -> None:
|
||||
"""Первый сигнал запускает drain, повторный ускоряет остановку."""
|
||||
if self._drain_task is not None:
|
||||
if not self._drain_task.done():
|
||||
self._drain_task.cancel()
|
||||
super().handle_exit(sig, frame)
|
||||
return
|
||||
self.lifecycle.start_draining()
|
||||
self._drain_task = asyncio.get_running_loop().create_task(
|
||||
self._finish_draining(sig, frame)
|
||||
)
|
||||
|
||||
async def _finish_draining(self, sig: int, frame: FrameType | None) -> None:
|
||||
"""Передаёт остановку Uvicorn после drain-периода."""
|
||||
await asyncio.sleep(self.drain_seconds)
|
||||
super().handle_exit(sig, frame)
|
||||
|
||||
@@ -2,7 +2,7 @@ from collections.abc import AsyncIterator
|
||||
|
||||
from fastapi import Request
|
||||
|
||||
from app.errors.exceptions import rate_limited
|
||||
from app.errors.exceptions import rate_limited, unavailable
|
||||
|
||||
|
||||
class RequestCapacity:
|
||||
@@ -29,6 +29,8 @@ def create_request_capacity(max_in_flight: int) -> RequestCapacity:
|
||||
|
||||
|
||||
async def acquire_request_slot(request: Request) -> AsyncIterator[None]:
|
||||
if request.app.state.lifecycle.draining:
|
||||
raise unavailable("Реплика завершает работу")
|
||||
capacity: RequestCapacity = request.app.state.request_capacity
|
||||
|
||||
if not capacity.try_acquire():
|
||||
|
||||
@@ -13,7 +13,7 @@ TOKEN_BYTES = 32
|
||||
|
||||
_hasher = PasswordHasher()
|
||||
_executor = ThreadPoolExecutor(
|
||||
max_workers=max(1, (os.cpu_count() or 1) // _hasher.parallelism),
|
||||
max_workers=max(1, min(2, (os.cpu_count() or 1) // _hasher.parallelism)),
|
||||
thread_name_prefix="argon2",
|
||||
)
|
||||
|
||||
|
||||
+32
-41
@@ -1,15 +1,4 @@
|
||||
"""Идемпотентность POST сообщения, общая для всех API-реплик.
|
||||
|
||||
Семантика:
|
||||
- ключ: ASCII [A-Za-z0-9._:-]{1,128}; нет/неверный — 400;
|
||||
- область уникальности: пользователь + метод + путь чата + ключ;
|
||||
- тот же JSON в течение 24 ч -> тот же 201 и то же Message;
|
||||
- другой JSON с тем же ключом -> 409;
|
||||
- одновременные повторы через разные реплики -> ровно одно сообщение;
|
||||
- повтор снова проверяет сессию и членство в чате;
|
||||
- транзиентная 5xx не фиксируется как окончательный результат;
|
||||
- побочный эффект (INSERT сообщения) и запись результата — атомарно.
|
||||
"""
|
||||
"""Атомарная отправка сообщения с защитой от повторов."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
@@ -18,27 +7,26 @@ from uuid import UUID
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.domain.chats import ensure_chat_member
|
||||
from app.errors.exceptions import conflict, invalid_request, unavailable
|
||||
from app.models.message import Message as MessageModel
|
||||
from app.schemas.message import CreateMessage, Message
|
||||
from app.schemas.user import User
|
||||
from app.storage import idempotency as key_storage
|
||||
from app.storage import messages as message_storage
|
||||
|
||||
IDEMPOTENCY_KEY_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}")
|
||||
|
||||
|
||||
def validate_idempotency_key(key: str | None) -> str:
|
||||
"""Возвращает ключ или бросает invalid_request (400).
|
||||
|
||||
TODO(3.4): проверить наличие и формат (fullmatch по IDEMPOTENCY_KEY_PATTERN).
|
||||
"""
|
||||
raise NotImplementedError("TODO(3.4): validate_idempotency_key")
|
||||
"""Проверяет обязательный ASCII-ключ запроса."""
|
||||
if key is None or IDEMPOTENCY_KEY_PATTERN.fullmatch(key) is None:
|
||||
raise invalid_request("Требуется корректный Idempotency-Key")
|
||||
return key
|
||||
|
||||
|
||||
def request_fingerprint(new_message: CreateMessage) -> str:
|
||||
"""Хеш семантического содержимого запроса для сравнения повторов.
|
||||
|
||||
Порядок ключей JSON не должен влиять на результат, поэтому хешируйте
|
||||
нормализованную форму (например, json.dumps(..., sort_keys=True)
|
||||
от new_message.model_dump()), а не сырые байты тела.
|
||||
"""
|
||||
"""Хеширует нормализованное содержимое запроса."""
|
||||
canonical = json.dumps(
|
||||
new_message.model_dump(mode="json"), sort_keys=True, ensure_ascii=False
|
||||
)
|
||||
@@ -54,22 +42,25 @@ async def send_message_idempotent(
|
||||
max_messages: int,
|
||||
ttl_seconds: int,
|
||||
) -> Message:
|
||||
"""Отправляет сообщение ровно один раз для (sender, POST, chat_id, key).
|
||||
"""Создаёт сообщение или возвращает результат прежнего запроса."""
|
||||
await ensure_chat_member(session, sender, chat_id)
|
||||
scope = (sender.id, "POST", f"/api/v1/chats/{chat_id}/messages", idempotency_key)
|
||||
fingerprint = request_fingerprint(new_message)
|
||||
|
||||
TODO(3.4). Один из рабочих вариантов на PostgreSQL:
|
||||
1. ensure_chat_member(...) — доступ проверяется и на повторе.
|
||||
2. В одной транзакции:
|
||||
INSERT INTO idempotency_keys (...) VALUES (...)
|
||||
ON CONFLICT (user_id, method, path, key) DO NOTHING RETURNING ...
|
||||
- вставилось -> создать сообщение, записать message_id в строку ключа,
|
||||
COMMIT (сообщение и ключ фиксируются вместе или не фиксируются вовсе);
|
||||
- конфликт -> прочитать существующую строку. Параллельная транзакция
|
||||
с тем же ключом будет ждать на уникальном индексе, пока первая
|
||||
не завершится, поэтому дубля не будет.
|
||||
3. Если fingerprint отличается -> conflict() (409).
|
||||
4. Если совпадает -> вернуть сохранённое сообщение (тот же id/created_at).
|
||||
5. Просроченные (> ttl_seconds) ключи считать отсутствующими.
|
||||
Альтернатива — Redis SET NX + PostgreSQL; тогда отдельно продумайте
|
||||
атомарность "сообщение записано, а ключ — нет" и наоборот.
|
||||
"""
|
||||
raise NotImplementedError("TODO(3.4): send_message_idempotent")
|
||||
await key_storage.lock_key(session, scope)
|
||||
previous = await key_storage.get_active_key(session, scope, ttl_seconds)
|
||||
if previous is not None:
|
||||
if previous.request_hash != fingerprint:
|
||||
raise conflict("Idempotency-Key уже использован для другого сообщения")
|
||||
message = await session.get(MessageModel, previous.message_id)
|
||||
else:
|
||||
if not await message_storage.reserve_message_slot(session, max_messages):
|
||||
raise unavailable("Достигнут лимит количества сообщений")
|
||||
message = await message_storage.create_message(
|
||||
session, chat_id=chat_id, sender_id=sender.id, text=new_message.text
|
||||
)
|
||||
await key_storage.save_result(session, scope, fingerprint, message.id)
|
||||
|
||||
result = Message.model_validate(message)
|
||||
await session.commit()
|
||||
return result
|
||||
|
||||
+1
-24
@@ -9,35 +9,12 @@ from app.domain.pagination import (
|
||||
decode_cursor,
|
||||
split_page,
|
||||
)
|
||||
from app.errors.exceptions import unavailable
|
||||
from app.schemas.message import CreateMessage, Message, MessagePage
|
||||
from app.schemas.message import Message, MessagePage
|
||||
from app.schemas.user import User
|
||||
from app.storage import messages as messages_storage
|
||||
from app.storage.types import Position
|
||||
|
||||
|
||||
async def send_message(
|
||||
session: AsyncSession,
|
||||
sender: User,
|
||||
chat_id: UUID,
|
||||
new_message: CreateMessage,
|
||||
max_messages: int,
|
||||
) -> Message:
|
||||
"""Отправляет сообщение от имени участника; при исчерпании лимита даёт 503."""
|
||||
await ensure_chat_member(session, sender, chat_id)
|
||||
|
||||
if not await messages_storage.reserve_message_slot(session, max_messages):
|
||||
raise unavailable("Достигнут лимит количества сообщений")
|
||||
|
||||
message = await messages_storage.create_message(
|
||||
session, chat_id=chat_id, sender_id=sender.id, text=new_message.text
|
||||
)
|
||||
await session.commit()
|
||||
|
||||
sent_message = Message.model_validate(message)
|
||||
return sent_message
|
||||
|
||||
|
||||
async def list_messages(
|
||||
session: AsyncSession,
|
||||
user: User,
|
||||
|
||||
+12
-6
@@ -1,3 +1,5 @@
|
||||
import asyncio
|
||||
|
||||
from fastapi import APIRouter, Request
|
||||
|
||||
from app.core.database import check_database
|
||||
@@ -15,12 +17,16 @@ async def liveness() -> Health:
|
||||
|
||||
@router.get("/ready")
|
||||
async def readiness(request: Request) -> Health:
|
||||
# TODO(4.1): если реплика получила SIGTERM (lifecycle.draining) — сразу 503,
|
||||
# чтобы LB исключил её до закрытия сокета.
|
||||
# TODO(4.1): проверки зависимостей должны укладываться в timeout healthcheck;
|
||||
# зафиксируйте в REPORT.md, какие зависимости критичны.
|
||||
if not await check_database(request.app.state.engine):
|
||||
if request.app.state.lifecycle.draining:
|
||||
raise unavailable()
|
||||
if not await check_redis(request.app.state.redis):
|
||||
try:
|
||||
async with asyncio.timeout(request.app.state.settings.readiness_timeout_seconds):
|
||||
dependencies = await asyncio.gather(
|
||||
check_database(request.app.state.engine),
|
||||
check_redis(request.app.state.redis),
|
||||
)
|
||||
except TimeoutError:
|
||||
raise unavailable() from None
|
||||
if not all(dependencies):
|
||||
raise unavailable()
|
||||
return Health(status="ok")
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Query
|
||||
from fastapi import APIRouter, Header, Query
|
||||
|
||||
from app.domain.messages import list_messages, send_message
|
||||
from app.domain.idempotency import send_message_idempotent, validate_idempotency_key
|
||||
from app.domain.messages import list_messages
|
||||
from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession
|
||||
from app.schemas.message import CreateMessage, Message, MessagePage
|
||||
|
||||
@@ -17,14 +18,12 @@ async def send_new_message(
|
||||
sender: CurrentUser,
|
||||
session: DbSession,
|
||||
settings: AppSettings,
|
||||
# TODO(3.4): принять заголовок Idempotency-Key:
|
||||
# idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None
|
||||
# и вызывать app.domain.idempotency.send_message_idempotent(...) вместо send_message.
|
||||
# Нет/неверный ключ -> 400 (validate_idempotency_key). Валидацию делайте сами,
|
||||
# а не через pattern= у Header, чтобы текст ошибки был в общем формате.
|
||||
idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None,
|
||||
) -> Message:
|
||||
return await send_message(
|
||||
session, sender, chat_id, new_message, settings.max_messages
|
||||
return await send_message_idempotent(
|
||||
session, sender, chat_id, new_message,
|
||||
validate_idempotency_key(idempotency_key),
|
||||
settings.max_messages, settings.idempotency_ttl_seconds,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@ from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError
|
||||
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from app.core.instance import INSTANCE_ID_HEADER
|
||||
from app.core.request_id import REQUEST_ID_HEADER
|
||||
from app.errors.exceptions import ApiError, internal_error, unavailable
|
||||
|
||||
@@ -43,6 +44,9 @@ def _build_response(
|
||||
**(headers or {}),
|
||||
REQUEST_ID_HEADER: request_id,
|
||||
}
|
||||
instance_id = getattr(request.app.state, "instance_id", None)
|
||||
if instance_id is not None:
|
||||
response_headers[INSTANCE_ID_HEADER] = instance_id
|
||||
|
||||
body = {
|
||||
"error": {
|
||||
|
||||
+13
-9
@@ -7,6 +7,8 @@ from fastapi import Depends, FastAPI
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.core.database import create_db_engine, create_session_factory
|
||||
from app.core.instance import InstanceIdMiddleware, resolve_instance_id
|
||||
from app.core.lifecycle import GracefulServer, Lifecycle
|
||||
from app.core.redis import create_redis_client
|
||||
from app.core.request_capacity import acquire_request_slot, create_request_capacity
|
||||
from app.core.request_id import RequestIdMiddleware
|
||||
@@ -45,12 +47,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
|
||||
application.state.session_factory = create_session_factory(engine)
|
||||
application.state.redis = redis
|
||||
application.state.request_capacity = create_request_capacity(settings.max_in_flight)
|
||||
|
||||
# TODO(3.2): application.state.instance_id = resolve_instance_id(settings.instance_id)
|
||||
# и application.add_middleware(InstanceIdMiddleware, instance_id=...)
|
||||
# (app/core/instance.py). Middleware, добавленный последним, — внешний.
|
||||
# TODO(4.1): application.state.lifecycle = Lifecycle() (app/core/lifecycle.py)
|
||||
application.state.instance_id = resolve_instance_id(settings.instance_id)
|
||||
application.state.lifecycle = Lifecycle()
|
||||
application.add_middleware(RequestIdMiddleware)
|
||||
application.add_middleware(
|
||||
InstanceIdMiddleware, instance_id=application.state.instance_id
|
||||
)
|
||||
register_exception_handlers(application)
|
||||
|
||||
limited = [Depends(acquire_request_slot)]
|
||||
@@ -65,15 +67,17 @@ def create_app(settings: Settings | None = None) -> FastAPI:
|
||||
|
||||
def main() -> None:
|
||||
settings = Settings() # type: ignore
|
||||
uvicorn.run(
|
||||
"app.main:create_app",
|
||||
factory=True,
|
||||
application = create_app(settings)
|
||||
config = uvicorn.Config(
|
||||
application,
|
||||
host=settings.app_host,
|
||||
port=settings.app_port,
|
||||
log_level=settings.log_level.lower(),
|
||||
# TODO(4.1): согласовать с stop_grace_period в compose.yaml и drain-периодом
|
||||
timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds,
|
||||
)
|
||||
GracefulServer(
|
||||
config, application.state.lifecycle, settings.shutdown_drain_seconds
|
||||
).run()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -2,7 +2,8 @@ from app.models.base import Base
|
||||
from app.models.chat import Chat
|
||||
from app.models.chat_member import ChatMember
|
||||
from app.models.counter import Counter
|
||||
from app.models.idempotency_key import IdempotencyKey
|
||||
from app.models.message import Message
|
||||
from app.models.user import User
|
||||
|
||||
__all__ = ["Base", "Chat", "ChatMember", "Counter", "Message", "User"]
|
||||
__all__ = ["Base", "Chat", "ChatMember", "Counter", "IdempotencyKey", "Message", "User"]
|
||||
|
||||
@@ -1,28 +1,24 @@
|
||||
"""ORM-модель записи идемпотентности.
|
||||
"""Сохранённый результат отправки сообщения."""
|
||||
|
||||
TODO(3.4): раскомментировать/доработать, добавить в app/models/__init__.py
|
||||
и сгенерировать миграцию: `make migration m="add idempotency keys"`
|
||||
(с поднятой БД), затем проверить сгенерированный файл руками.
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
Примерная схема:
|
||||
from sqlalchemy import ForeignKey, Index, String, func
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
class IdempotencyKey(Base):
|
||||
__tablename__ = "idempotency_keys"
|
||||
__table_args__ = (
|
||||
PrimaryKeyConstraint("user_id", "method", "path", "key"),
|
||||
Index("ix_idempotency_keys_created_at", "created_at"), # для чистки по TTL
|
||||
)
|
||||
from app.models.base import Base
|
||||
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
|
||||
method: Mapped[str] = mapped_column(String(8))
|
||||
path: Mapped[str] = mapped_column(String(255))
|
||||
key: Mapped[str] = mapped_column(String(128))
|
||||
request_hash: Mapped[str] = mapped_column(String(64))
|
||||
message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id"))
|
||||
created_at: Mapped[datetime] = mapped_column(server_default=func.now())
|
||||
|
||||
Вопросы проектирования:
|
||||
- почему достаточно сохранить message_id, а не весь JSON ответа;
|
||||
- как и когда удаляются ключи старше IDEMPOTENCY_TTL_SECONDS;
|
||||
- что видит второй параллельный запрос, пока первый ещё не COMMIT.
|
||||
"""
|
||||
class IdempotencyKey(Base):
|
||||
"""Ключ запроса и связанное сообщение."""
|
||||
|
||||
__tablename__ = "idempotency_keys"
|
||||
__table_args__ = (Index("ix_idempotency_keys_created_at", "created_at"),)
|
||||
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
|
||||
method: Mapped[str] = mapped_column(String(8), primary_key=True)
|
||||
path: Mapped[str] = mapped_column(String(255), primary_key=True)
|
||||
key: Mapped[str] = mapped_column(String(128), primary_key=True)
|
||||
request_hash: Mapped[str] = mapped_column(String(64))
|
||||
message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id"))
|
||||
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
|
||||
|
||||
@@ -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(),
|
||||
},
|
||||
)
|
||||
)
|
||||
+2
-2
@@ -4,7 +4,7 @@
|
||||
services:
|
||||
postgres:
|
||||
ports:
|
||||
- "127.0.0.1:${DB_HOST_PORT:-15432}:5432"
|
||||
- "127.0.0.1:${DB_HOST_PORT:?Set DB_HOST_PORT in .env}"
|
||||
redis:
|
||||
ports:
|
||||
- "127.0.0.1:${REDIS_HOST_PORT:-16379}:6379"
|
||||
- "127.0.0.1:${REDIS_HOST_PORT:?Set REDIS_HOST_PORT in .env}"
|
||||
|
||||
+95
-40
@@ -1,75 +1,125 @@
|
||||
# Клиент → nginx (LB) → api × N → postgres + redis.
|
||||
# Незавершённые места помечены TODO(<номер>).
|
||||
#
|
||||
# Запуск: docker compose --env-file .env up -d --build (или make up)
|
||||
name: mtusi-messenger-lab3
|
||||
|
||||
x-api-image: &api-image
|
||||
build: .
|
||||
image: mtusi-messenger:lab3
|
||||
build:
|
||||
context: .
|
||||
args:
|
||||
API_BUILD_REVISION: ${API_BUILD_REVISION:?Set API_BUILD_REVISION in .env}
|
||||
image: ${API_IMAGE:?Set API_IMAGE in .env}
|
||||
|
||||
x-base-env: &base-env
|
||||
APP_HOST: ${APP_HOST:?Set APP_HOST in .env}
|
||||
APP_PORT: ${APP_PORT:?Set APP_PORT in .env}
|
||||
APP_ENV: ${APP_ENV:?Set APP_ENV in .env}
|
||||
LOG_LEVEL: ${LOG_LEVEL:?Set LOG_LEVEL in .env}
|
||||
MAX_MESSAGES: ${MAX_MESSAGES:?Set MAX_MESSAGES in .env}
|
||||
MAX_IN_FLIGHT: ${MAX_IN_FLIGHT:?Set MAX_IN_FLIGHT in .env}
|
||||
DB_HOST: ${DB_HOST:?Set DB_HOST in .env}
|
||||
DB_PORT: ${DB_PORT:?Set DB_PORT in .env}
|
||||
DB_NAME: ${DB_NAME:?Set DB_NAME in .env}
|
||||
DB_USER: ${DB_USER:?Set DB_USER in .env}
|
||||
DB_POOL_SIZE: ${DB_POOL_SIZE:?Set DB_POOL_SIZE in .env}
|
||||
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:?Set DB_MAX_OVERFLOW in .env}
|
||||
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:?Set DB_POOL_TIMEOUT_SECONDS in .env}
|
||||
DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:?Set DB_CONNECT_TIMEOUT_SECONDS in .env}
|
||||
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:?Set DB_STATEMENT_TIMEOUT_MS in .env}
|
||||
SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:?Set SHUTDOWN_DRAIN_SECONDS in .env}
|
||||
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS: ${GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS:?Set GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS in .env}
|
||||
READINESS_TIMEOUT_SECONDS: ${READINESS_TIMEOUT_SECONDS:?Set READINESS_TIMEOUT_SECONDS in .env}
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.10-bookworm
|
||||
restart: unless-stopped
|
||||
# TODO(4.3): секреты через `secrets:` (POSTGRES_PASSWORD_FILE), а не env.
|
||||
environment:
|
||||
POSTGRES_USER: ${DB_USER}
|
||||
POSTGRES_DB: ${DB_NAME}
|
||||
POSTGRES_PASSWORD: ${DB_PASSWORD}
|
||||
POSTGRES_USER: ${DB_USER:?Set DB_USER in .env}
|
||||
POSTGRES_DB: ${DB_NAME:?Set DB_NAME in .env}
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
|
||||
secrets:
|
||||
- db_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
# Порты наружу не публикуются; для локальных pytest см. compose.test.yaml.
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
# TODO(4.3): deploy.resources.limits (cpus / memory)
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-bookworm
|
||||
restart: unless-stopped
|
||||
# TODO(4.3): пароль через secrets, а не в командной строке
|
||||
command: ["redis-server", "/usr/local/etc/redis/redis.conf", "--requirepass", "${REDIS_PASSWORD}"]
|
||||
environment:
|
||||
REDISCLI_AUTH: ${REDIS_PASSWORD}
|
||||
entrypoint: ["/bin/sh", "/usr/local/bin/start-redis.sh"]
|
||||
secrets:
|
||||
- redis_password
|
||||
volumes:
|
||||
- ./infra/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro
|
||||
- ./infra/redis/start-redis.sh:/usr/local/bin/start-redis.sh:ro
|
||||
- redisdata:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
# TODO(4.3): deploy.resources.limits
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 512M
|
||||
|
||||
# Однократные миграции до старта реплик: api ждёт service_completed_successfully,
|
||||
# поэтому реплики не устраивают гонку `alembic upgrade`.
|
||||
# TODO(4.4): описать совместимость миграций с работающей версией (expand/contract).
|
||||
migrate:
|
||||
<<: *api-image
|
||||
command: ["alembic", "upgrade", "head"]
|
||||
env_file: .env
|
||||
environment: *base-env
|
||||
secrets:
|
||||
- db_password
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
|
||||
api:
|
||||
<<: *api-image
|
||||
restart: unless-stopped
|
||||
env_file: .env
|
||||
environment:
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
# Не задавайте container_name и ports: несколько реплик одного service,
|
||||
# доступ только через nginx.
|
||||
<<: *base-env
|
||||
REDIS_HOST: ${REDIS_HOST:?Set REDIS_HOST in .env}
|
||||
REDIS_PORT: ${REDIS_PORT:?Set REDIS_PORT in .env}
|
||||
REDIS_DB: ${REDIS_DB:?Set REDIS_DB in .env}
|
||||
REDIS_MAX_CONNECTIONS: ${REDIS_MAX_CONNECTIONS:?Set REDIS_MAX_CONNECTIONS in .env}
|
||||
REDIS_POOL_TIMEOUT_SECONDS: ${REDIS_POOL_TIMEOUT_SECONDS:?Set REDIS_POOL_TIMEOUT_SECONDS in .env}
|
||||
REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:?Set REDIS_CONNECT_TIMEOUT_SECONDS in .env}
|
||||
REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:?Set REDIS_SOCKET_TIMEOUT_SECONDS in .env}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:?Set SESSION_TTL_SECONDS in .env}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:?Set IDEMPOTENCY_TTL_SECONDS in .env}
|
||||
secrets:
|
||||
- db_password
|
||||
- redis_password
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
# TODO(4.3): resources.limits: { cpus: "...", memory: "..." }
|
||||
# TODO(4.1): healthcheck по /health/ready (interval/timeout/retries),
|
||||
# согласованный с проверками nginx; сейчас действует HEALTHCHECK
|
||||
# из Dockerfile по /health/live.
|
||||
# TODO(4.1): stop_signal / stop_grace_period > drain + graceful timeout.
|
||||
replicas: ${API_REPLICAS:?Set API_REPLICAS in .env}
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
start_period: 10s
|
||||
retries: 2
|
||||
stop_signal: SIGTERM
|
||||
stop_grace_period: 8s
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
@@ -84,8 +134,7 @@ services:
|
||||
volumes:
|
||||
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
ports:
|
||||
# Единственная публичная точка входа.
|
||||
- "127.0.0.1:${LB_HOST_PORT:-8080}:8080"
|
||||
- "127.0.0.1:${LB_HOST_PORT:?Set LB_HOST_PORT in .env}:8080"
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb-health"]
|
||||
interval: 5s
|
||||
@@ -94,12 +143,18 @@ services:
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
# TODO(4.3): deploy.resources.limits
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
|
||||
# TODO(4.3): secrets:
|
||||
# db_password:
|
||||
# file: ./secrets/db_password # каталог secrets/ в .gitignore
|
||||
secrets:
|
||||
db_password:
|
||||
file: ./secrets/db_password
|
||||
redis_password:
|
||||
file: ./secrets/redis_password
|
||||
|
||||
+99
-3
@@ -1,5 +1,101 @@
|
||||
# Доказательства
|
||||
# Доказательства лабораторной 3
|
||||
|
||||
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
|
||||
Прогон от 04.11.2026, автор: Григорян Илья Мурадович, БПИ2303. Цель — оценка 4.
|
||||
Команды выполнялись на незакоммиченном рабочем дереве поверх commit
|
||||
`f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit.
|
||||
Состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt).
|
||||
Документация не включена в этот fingerprint; её подготовка продолжалась после тестов.
|
||||
|
||||
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
|
||||
## Артефакты
|
||||
|
||||
| Файл | Содержание |
|
||||
| --- | --- |
|
||||
| [run.json](run.json) | Время прогона, базовый commit, версии Docker/Compose/Python, оборудование, параметры, лимиты и команды. |
|
||||
| [test-output.txt](test-output.txt) | Реальный stdout/stderr полного `test-grade4`: 156 pytest, smoke, конкурентные повторы, persistence, failover, SIGTERM, rolling и остановка каждой реплики. Абсолютный путь checkout заменён на `<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 с зависимостями проекта. Из корня:
|
||||
|
||||
```sh
|
||||
test -f .env || cp .env.example .env
|
||||
make prepare-secrets PYTHON=.venv/bin/python
|
||||
make test-grade4 PYTHON=.venv/bin/python
|
||||
make test-nginx PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Существующий `.env` не заменяется. Пароли находятся в `secrets/`, а не в артефактах.
|
||||
`test-grade4` создаёт отдельный проект `mtusi-messenger-lab3-test` с двумя API,
|
||||
PostgreSQL, Redis, migrate и Nginx. Вход — localhost:18080, PostgreSQL:15432,
|
||||
Redis:16379. Фактические параметры этого запуска перечислены в `run.json`.
|
||||
В конце, включая ошибку, тестовые контейнеры, сеть и volumes удаляются.
|
||||
|
||||
## Что измерялось
|
||||
|
||||
1. Контракт и OpenAPI; 156 pytest с реальными PostgreSQL и Redis, включая реальный
|
||||
restart Redis. Собственные тесты используют отдельную БД `<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 храните отдельно по правилам преподавателя.
|
||||
|
||||
@@ -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.
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
@@ -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 и результат лимита
|
||||
@@ -0,0 +1,149 @@
|
||||
{
|
||||
"started_at_utc": "2026-11-04T13:59:48.203542+00:00",
|
||||
"base_commit": "f20b751207ed9948bfcdab829c458a4af122d611",
|
||||
"worktree_dirty": true,
|
||||
"source_manifest_sha256": "73187c6a987b4fce648f79198a89a99b238bc5aa0617339d662b09c86cb423cb",
|
||||
"runtime_profile": {
|
||||
"API_REPLICAS": "2",
|
||||
"APP_PORT": "8080",
|
||||
"LB_HOST_PORT": "8080",
|
||||
"DB_HOST_PORT": "15432",
|
||||
"REDIS_HOST_PORT": "16379",
|
||||
"MAX_MESSAGES": "100000",
|
||||
"MAX_IN_FLIGHT": "16",
|
||||
"DB_POOL_SIZE": "5",
|
||||
"DB_MAX_OVERFLOW": "10",
|
||||
"DB_POOL_TIMEOUT_SECONDS": "3",
|
||||
"DB_CONNECT_TIMEOUT_SECONDS": "3",
|
||||
"DB_STATEMENT_TIMEOUT_MS": "5000",
|
||||
"REDIS_MAX_CONNECTIONS": "20",
|
||||
"REDIS_POOL_TIMEOUT_SECONDS": "1",
|
||||
"REDIS_CONNECT_TIMEOUT_SECONDS": "1",
|
||||
"REDIS_SOCKET_TIMEOUT_SECONDS": "0.5",
|
||||
"SESSION_TTL_SECONDS": "3600",
|
||||
"IDEMPOTENCY_TTL_SECONDS": "86400",
|
||||
"SHUTDOWN_DRAIN_SECONDS": "1",
|
||||
"GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS": "5",
|
||||
"READINESS_TIMEOUT_SECONDS": "2"
|
||||
},
|
||||
"commands": [
|
||||
"make test-grade4 PYTHON=.venv/bin/python",
|
||||
"make test-nginx PYTHON=.venv/bin/python"
|
||||
],
|
||||
"local_python": "Python 3.12.14",
|
||||
"docker_compose": "5.6.1",
|
||||
"docker_host": {
|
||||
"server_version": "29.9.2",
|
||||
"os": "linux",
|
||||
"architecture": "x86_64",
|
||||
"cpus": 8,
|
||||
"memory_bytes": 16400363520,
|
||||
"kernel": "7.2.11-zen1-1-zen"
|
||||
},
|
||||
"host_cpu_model": "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz",
|
||||
"finished_at_utc": "2026-11-04T14:07:19.867546+00:00",
|
||||
"results": {
|
||||
"test_grade4_exit_code": 0,
|
||||
"test_nginx_exit_code": 0,
|
||||
"pytest_passed": 156,
|
||||
"pytest_seconds": 42.3
|
||||
},
|
||||
"container_limits": {
|
||||
"postgres": {
|
||||
"cpus": 1,
|
||||
"memory_mib": 512
|
||||
},
|
||||
"redis": {
|
||||
"cpus": 0.5,
|
||||
"memory_mib": 512
|
||||
},
|
||||
"api_each": {
|
||||
"cpus": 1,
|
||||
"memory_mib": 512
|
||||
},
|
||||
"migrate": {
|
||||
"cpus": 0.5,
|
||||
"memory_mib": 256
|
||||
},
|
||||
"nginx": {
|
||||
"cpus": 0.5,
|
||||
"memory_mib": 128
|
||||
}
|
||||
},
|
||||
"test_profile": {
|
||||
"project": "mtusi-messenger-lab3-test",
|
||||
"compose_files": [
|
||||
"compose.yaml",
|
||||
"compose.test.yaml"
|
||||
],
|
||||
"lb_host_port": 18080,
|
||||
"api_replicas": 2,
|
||||
"test_postgres_port": 15432,
|
||||
"test_redis_port": 16379,
|
||||
"pytest_redis_db": 15,
|
||||
"rolling": {
|
||||
"clients": 2,
|
||||
"timeout_seconds": 2,
|
||||
"pause_after_attempt_seconds": 0.08,
|
||||
"warmup_seconds": 1,
|
||||
"after_update_seconds": 1,
|
||||
"image_change": "API_BUILD_REVISION label; same business code",
|
||||
"pending_migrations": false
|
||||
},
|
||||
"failover_each": {
|
||||
"clients": 2,
|
||||
"timeout_seconds": 2,
|
||||
"warmup_seconds": 2,
|
||||
"after_stop_hook_seconds": 10,
|
||||
"error_backoff_seconds": 0.1,
|
||||
"stop_timeout_seconds": 8
|
||||
}
|
||||
},
|
||||
"installed_local_packages": {
|
||||
"fastapi": "0.143.3",
|
||||
"uvicorn": "0.54.0",
|
||||
"pydantic": "2.14.1",
|
||||
"pydantic-settings": "2.16.0",
|
||||
"SQLAlchemy": "2.1.4",
|
||||
"alembic": "1.20.0",
|
||||
"asyncpg": "0.32.0",
|
||||
"redis": "8.1.0",
|
||||
"pytest": "9.1.1",
|
||||
"pytest-asyncio": "1.4.1"
|
||||
},
|
||||
"images": [
|
||||
{
|
||||
"tag": "mtusi-messenger:lab3",
|
||||
"id": "sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413",
|
||||
"repo_digests": [
|
||||
"mtusi-messenger@sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413"
|
||||
],
|
||||
"revision": "verification-81ccd2376178"
|
||||
},
|
||||
{
|
||||
"tag": "postgres:16.10-bookworm",
|
||||
"id": "sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74",
|
||||
"repo_digests": [
|
||||
"postgres@sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74"
|
||||
],
|
||||
"revision": null
|
||||
},
|
||||
{
|
||||
"tag": "redis:7.4.2-bookworm",
|
||||
"id": "sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9",
|
||||
"repo_digests": [
|
||||
"redis@sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9"
|
||||
],
|
||||
"revision": null
|
||||
},
|
||||
{
|
||||
"tag": "nginx:1.28.0-alpine",
|
||||
"id": "sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284",
|
||||
"repo_digests": [
|
||||
"nginx@sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284"
|
||||
],
|
||||
"revision": null
|
||||
}
|
||||
],
|
||||
"manifest_scope": "Executable sources, tests and configuration; excludes documentation, .env and secrets."
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
ce3cd59eb07b3f3cfb85c19c9dfcba82aeca3b4231d523c6a2c85d28bf2b66f9 .env.example
|
||||
2ea849842e877eca40e5dd853a5299a81be15fa414476fbfe434ac487f59ec1f Dockerfile
|
||||
dd18f3dabac00cf562e2d4eec2615a3b7e37bb5343b47f1eb0f0fb49c2a11b7e Makefile
|
||||
274785e9cfb1af978fcdf254f3b9c93847216d9183cf290098f857f174f43b41 alembic.ini
|
||||
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/__init__.py
|
||||
5839d94c506f0362278a4f85bca8346774f5f323112963dd3830e525a069fb61 app/__main__.py
|
||||
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/core/__init__.py
|
||||
f66f54d722c4bde445e402c5f80fc2c826dd02a35b49a7ef8e78183aae577e30 app/core/config.py
|
||||
e9ae2ff773dfd0f3f0515b6fd29c8b23820cd1a3b83e2b99dccaca8f0ddf8a40 app/core/database.py
|
||||
da4dcfda3dabeb595aa7b917d321e794074676fd258828c84be4322b917ac43c app/core/instance.py
|
||||
aedcaa71c991f0147603bad32bbd105ebdc689cfc388d274e83ce693f32ba534 app/core/lifecycle.py
|
||||
69056a1660683bc5086b558b38660c304650d261f760248499ace499031c7e4e app/core/redis.py
|
||||
290d97e3551e1661feb04debc0272c9c91fe7636d1771de9e78055c64e23933c app/core/request_capacity.py
|
||||
e1f3f08c65cf17ea24574682050e0435d5a5c22b7b2194ea40aad941716871b4 app/core/request_id.py
|
||||
7717e9ea31415dd9803f14e6290e709bfb63aa38cb1524db9b04881cf2512256 app/core/security.py
|
||||
6acb951afe3a628d9bd9ae25ab8c321b8debb0f481c745881a7af1f48e620c90 app/domain/__init__.py
|
||||
d7026b518eb7f3f054a5aaa5307171db031718c0c70555d40c03e7aabc9f539d app/domain/auth.py
|
||||
33f20c63c3fdcb491adb2153a147e822e0a16de4a5f634355a6d2db514aaa668 app/domain/chats.py
|
||||
a2bc40d13dca0215bc817c8781038586827d8b5601dd916b18c0f472e28e17b3 app/domain/idempotency.py
|
||||
f127324bf34b423b33dd0e446ab049740ee6364785b34a805556331b8e324c22 app/domain/messages.py
|
||||
df9aa94fab247467fe5f6fa030bdf3e587b5749060f0c3d663f5bd3e57e8dfe9 app/domain/pagination.py
|
||||
31ec7ba4c47ae6c31661eb8b4231efe9f561784c3bc0555c7d9b9bde804fe88f app/domain/users.py
|
||||
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/endpoints/__init__.py
|
||||
0cb1dded40038b80eafabcb288f43b1b7fcac1d8d41898e657eb9b62afaa2aab app/endpoints/auth.py
|
||||
2fc7d2b4f155e1cdba6d02ac157b1c2d74932c930d6cba7ac93c0a811af1494a app/endpoints/chats.py
|
||||
1980c53bce1e96c801bb0ad49c6d35957c07f3e50db1804475a67f07a7d96082 app/endpoints/dependencies.py
|
||||
2e1606211c689a8959041433bcb4b70e4c5fd1647038fe391eb5435b9d07ddca app/endpoints/health.py
|
||||
a6424660ce901defac67b5d66a882f8051a531328fc6d4aa998c407ca276c4e3 app/endpoints/messages.py
|
||||
13fe05bec4b4b0a9e7a2f90756065bf97e257601b119a71465b24fc0144f3bf9 app/endpoints/users.py
|
||||
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/errors/__init__.py
|
||||
355a762e6dc81dd844671982a68d944fa10d9631ef91cd3afd9312f2cffb8ec2 app/errors/exceptions.py
|
||||
5e5616f8bb0b1b3fdaaba69f2e9248de79ebd3c1d0d123c9c613aa106e691960 app/errors/handlers.py
|
||||
21a24f61599534856d11c5ce574111ce8a1d395f06aef5618558c4e54afefbc0 app/main.py
|
||||
116ec0d604cecd9306827761bfa2290a87dc99c6c5519bfd5b618f0de6d6dddf app/models/__init__.py
|
||||
548f10800483dd91a4d321c3cef845f3f5b126169a50474bf846f78839fdb43e app/models/base.py
|
||||
7076f06111aca1e3845a8515112fa1302da9bd331cf79c699259c91d3d23c9cf app/models/chat.py
|
||||
dfb64d43bd519d06f09e479eab4bdd277f317fdb92e206fdedf0afbed1fe18ad app/models/chat_member.py
|
||||
35eaa453501b48d178d7b17fd22314783386b64951cbb518b450698ba65219f8 app/models/counter.py
|
||||
693039c889d92ebdb5ef3fc6833278f59b4aa88f802b4726b9c3bf441f83fb18 app/models/idempotency_key.py
|
||||
9bbf725b6eae51e23e4fc71aea3dbc137d5a275b069e7e378351773297a7559f app/models/message.py
|
||||
b5f1bbdc4370e2671427c8d7590aba58916b1981f225c4734d8bdeb944b1539a app/models/user.py
|
||||
7c9d4ef216ed8b027ddfbad9746147cf0fed6463baf396b7244bd9b1b286e9ee app/schemas/__init__.py
|
||||
9a3f14dc23e704d9fdce681ae7187a6b95638f9736711a8edef245fbbaea3eb6 app/schemas/base.py
|
||||
2111aef9c942b34d02afa99da6d23a1d5ca0f6cfd75a1c0ebfb2ba85a29584b1 app/schemas/chat.py
|
||||
defae263397458b7b7d1acdb3dfa2b774c00e5ec3981c8b098748d1586777fb6 app/schemas/message.py
|
||||
617bcba33dcb01e4f66a50b5c425ebcbc1aef1c6148148f0eb862a7743bcf9b6 app/schemas/session.py
|
||||
01fc238693c3686595cc910fadce6200e9753d0c4a0397ff327d8a0c937dc4df app/schemas/user.py
|
||||
33296ca85924a22644fda573be072e5b810a284b939469580445925a85f0b5e9 app/storage/__init__.py
|
||||
e479c8be1f56030fc4faaa74417fb959fb2c1f0c57f72974df8b538ff1209a7b app/storage/chats.py
|
||||
2a9243ad419e7cc48ce0c6da13053df6773bea53a2342eb408cb3ebe2455f921 app/storage/idempotency.py
|
||||
f196fc426771cc9a628d25f466113badd1de1f123e9b3adc3cff9dc96e49824d app/storage/messages.py
|
||||
aeb6851a54d71051912ad588c47de3d5a3d92d518a0a198dbb3e283dd64837c7 app/storage/sessions.py
|
||||
46a0562d557ac96bd49f9975ff25ac8cce7f7f803b8c280d1d0bf2463ebfdaec app/storage/types.py
|
||||
f9dc7df7affda7144991944ff20a1ae5b372921b14fd391afa189d0e613dc45e app/storage/users.py
|
||||
46f25ac85ff2a20a52cddf67b38c69f340bf007a355cd2e18c46e6aab9d22757 compose.test.yaml
|
||||
2a40970440a7c3fcdcb621a00ba9e55b3d5cae4c8da8cf2b8bef3b70dc29f263 compose.yaml
|
||||
d88506d8590ce549fd43dda7eea87f040dfff128af071f457b87e17df6282f5a infra/nginx/nginx.conf
|
||||
9d4e7faeab76340dadda9916430048c32c849fb2bf02206653ea827e3304b666 infra/redis/redis.conf
|
||||
0f6fe080f5f7cd1d77da5f8ee9989874e9617bd7f4830f90b91978a5bfb88056 infra/redis/start-redis.sh
|
||||
37dce514d48aa4e021e063f6ebb8fb3e34275f6a76f51926d789802cad8dfa75 migrations/env.py
|
||||
4ae6aee859bcbcdb238d4cb2fa35419503d7a1d5a3caaffd0f0d2e9e9dce2937 migrations/versions/49d2c947a3f1_add_idempotency_keys.py
|
||||
cbe0b9e7584f26c0b859936a2584c147fe3f1ffaa9eb55c85ff753ecb10aa5a4 migrations/versions/abd273076068_add_counters.py
|
||||
dd0e8073817e3a08bae19b17d4d502aa0dca0639f95d0b08caaf0e5dce16f302 migrations/versions/db06fd3126ff_create_initial_schema.py
|
||||
92ce287c8eb0aa508e0efd4553650b4ebd2474d1987587d6467c26e316e6a547 pytest.ini
|
||||
4cefdb67007caf026d1613be7c519c01b4c8343db7c4f4b618677e01cf113525 requirements-dev.txt
|
||||
6f31c6f105a5774db02e970977bf2d26fbdba47dbb6e81836124816555d6d83f requirements.txt
|
||||
599958169a2b3c35b72b9b27f54d1c156032b2fadf041cc0e905bd49e48d8c60 scripts/__init__.py
|
||||
7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671 scripts/check_contract.py
|
||||
22befc4a28b1a08452c769d66106d0a5b7fabc4edca7d5be1657cdf72824d899 scripts/check_grade4.py
|
||||
1ebdc8a4423305b6b972254e0b856b9381f7a5279aaa537a3c9d3cdb791adccf scripts/check_idempotency.py
|
||||
c95f74ebfec55b047424d65ed201519a79cd3292b9067fcf6913f5ac1bf3ab0b scripts/check_nginx.py
|
||||
0926fac2e73573a6e8b32c254bfc635132823aed9c4b429e91bf180e047bc32f scripts/deployment.py
|
||||
4cf255992270adfdaa0a3fd304050ed858b7a49d9e3c8856337a310cf59f8596 scripts/expiry_demo.sh
|
||||
21f2e3baa4d9615e0411edbecfbdc394d471b70b4f237d1e45557c9602b0ecad scripts/explain_history.py
|
||||
af3422b5b039583980599765cea8315546a1a3de80671f78c7c205faa2bac65f scripts/failover_all.py
|
||||
e06776d5e44eded34a7fc849ba4cabe955428cf9f924e077a48511656538e7b2 scripts/failure_demo.sh
|
||||
a5dcd78d708a7d1e69d92f56cb97e0a0a4f69577aac530d8ee195cd293dfc0cc scripts/prepare_secrets.py
|
||||
0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b scripts/restart.example.sh
|
||||
442cb99a2a32e91f6348b18e2729e777e4f14acf82ed8aa899abdd1bf19ca4cc scripts/restart.sh
|
||||
60d48ba1c8050a79f8a3725a0ea7bba34dadba3bef0b86bd2d2e6a768e6ca7d5 scripts/rolling_update.py
|
||||
1bcf34394520b89d95b7605ec56675be799eea920e83cfbba306d5dc0a6d9811 scripts/stop-one.example.sh
|
||||
c78f3fee788c907764162069ee09e3bd043b3b3eb3823f5bbb8f84dd1ab5bed0 scripts/stop-one.sh
|
||||
4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54 scripts/validate_openapi.py
|
||||
fa12e0945cc8d7b3fdfbf476fd6a140c0a8262bb6728a1fd360cac335922da61 student-tests/conftest.py
|
||||
8c11a6fbc9003c2d92225bfc676edfffe416e70d8b6972a864cf6c5c0b64c95b student-tests/helpers.py
|
||||
20cd1c8ea397fe558a9ded78723dd319cabe47f520a631375171c448a01b1de2 student-tests/test_auth.py
|
||||
f57751337441fbc909549d553cd32e20d7f7918dc42f2000c15f9ba2706349a4 student-tests/test_chats.py
|
||||
b9c2ed985bb2cf0261bfb928f0bcc2694c8980a5c55fea4c445d0ca410ca30c6 student-tests/test_concurrency.py
|
||||
b8c9a1f7535318b946adff13b11ac2459622a1a9b23962f0981d0fc7793de0c9 student-tests/test_constraints.py
|
||||
76b4fe648fd257eb603cfc06da76b59b783986f96a9b357bc87238210757ef34 student-tests/test_errors.py
|
||||
045203d83f8ff50e48b8fad4328dba7f12de8adffebef597efadfd40c79ed5c1 student-tests/test_failures.py
|
||||
2594b7bce03d36e6c32c1644e76f4d8f40e7099de6c687e13a74706e329bcefe student-tests/test_health.py
|
||||
edaf79363adb942f9501d933deb86e39aed558f32c1a73188ae2d18d088378ae student-tests/test_history_plan.py
|
||||
640a12067597a7e576d3db0fb6f9bbb14639a14d701f6a9b682ed97ad70cdf8e student-tests/test_idempotency.py
|
||||
722951c437488d0c5d63839d418b2456c37a40c9e8dc55a52c7e8ea3a4066c3c student-tests/test_instance.py
|
||||
e39e046d8fd85711682f43220cbeded8212f9870fb6475d32f946a56b7864332 student-tests/test_lifecycle.py
|
||||
71e48fab2816753b213603bd977c9c1babb2b540596cd3401c1e62a6f538a3b5 student-tests/test_limits.py
|
||||
cc040ae5ee2f196362fab4c7006711bf8d8c7f5e2f56acc8c74646ef2efb801d student-tests/test_messages.py
|
||||
834077f0541a2a939adc726342fba70c0b7da4b54cd8715709685a3ad23cc16c student-tests/test_migrations.py
|
||||
2c573efd6b0a6204a8bac483bb6e2594c565f2d32faa04ebc3540298eb02af2d student-tests/test_pagination.py
|
||||
cb981f15ad186faa2e1f8b6aecb7766eed66378b6db9dfc496dd1d76afc94b1b student-tests/test_sessions.py
|
||||
bf840d8dcb6094412b9e2947df4a0a3c3f32c5d80af9df19693ed5b52b9c8d6d student-tests/test_users.py
|
||||
851376079a214a655f6343bbc3f34b0e57192d8f7d84c33eb4e0a79a22d6a1bb tests/__init__.py
|
||||
8d50976fc7c7bbb81e88a152f613c61ab25eaf53dba33c6a9dfab19f868d546d tests/client.py
|
||||
6d3511ea719c7a7e841083e73d435c86dcbfd9f4e5c2a07d62eb9614b01d9933 tests/load.py
|
||||
1f96663a174b3978d24eff66f2741f5f8c9b788d3242261d37a972720c52788b tests/resilience.py
|
||||
52ac38eb343ff7d43e7543588e1da58ca06c9fce74b2b0d0bf0e4982bc23c1db tests/smoke.py
|
||||
@@ -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
|
||||
+201
-4
@@ -1,7 +1,204 @@
|
||||
# Инфраструктура студента
|
||||
# Инфраструктура проекта
|
||||
|
||||
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
|
||||
Топология — [compose.yaml](../compose.yaml) и [тестовый override](../compose.test.yaml).
|
||||
Запуск и результаты — [REPORT.md](../REPORT.md), объяснение изменений относительно
|
||||
lab2 и терминов — [EXPLAIN.md](../EXPLAIN.md), ответы для защиты —
|
||||
[DEFENCE.md](../DEFENCE.md). `compose.example.yaml` остаётся исходным worksheet задания.
|
||||
|
||||
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
|
||||
## Nginx в текущем решении
|
||||
|
||||
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
|
||||
Конфигурация — [nginx/nginx.conf](nginx/nginx.conf), образ — `nginx:1.28.0-alpine`
|
||||
из `compose.yaml`. Клиент обращается к Nginx, тот распределяет запросы между
|
||||
репликами `api`; данные и сессии остаются общими в PostgreSQL и Redis.
|
||||
|
||||
| Настройка | Значение и назначение |
|
||||
| --- | --- |
|
||||
| DNS | `127.0.0.11`, `valid=5s`, `resolver_timeout=1s`: обновление адресов сервиса `api` без reload Nginx. `resolve` работает с общей зоной `zone api_backend 64k`. |
|
||||
| Балансировка | Round-robin, без закрепления клиента за репликой. |
|
||||
| Проверки отказа | Пассивные: `max_fails=1`, `fail_timeout=5s`. Ошибка запроса временно исключает backend; Nginx сам не опрашивает `/health/ready`. |
|
||||
| Соединения | HTTP/1.1, пустой `Connection`, кэш до 16 свободных соединений на worker с временем простоя до 4 с. Это не ограничитель одновременных запросов. |
|
||||
| Тайм-ауты к API | Подключение 500 мс; отправка/чтение 10 с между операциями ввода-вывода. |
|
||||
| Переключение | Не более двух попыток, окно начала следующей попытки 2 с; условия — ошибка соединения, тайм-аут, 502/503/504. Эти 2 с не являются общим ограничением длительности ответа. |
|
||||
| Ограничение запросов | На IP, видимый Nginx: в среднем 50 запросов/с, `burst=100 nodelay` допускает всплеск без очереди. Состояние общее для worker-процессов одного Nginx; `/health/*` и `/lb-health` не ограничиваются. |
|
||||
| Превышение лимита | JSON 429 `rate_limited`, `Retry-After: 1`, `X-Request-Id`, совпадающий с `error.request_id`. |
|
||||
| Нет доступных backend | Собственная ошибка LB — JSON 503 `unavailable`, `Retry-After: 1` и `X-Request-Id`. У ответов LB нет `X-Instance-Id` реплики. |
|
||||
| Ошибки приложения | JSON и заголовки API передаются без подмены, в том числе собственный 429 приложения. |
|
||||
| Gzip | Для `application/json` от 1024 байт, уровень 3, при согласии клиента через `Accept-Encoding`; `Vary: Accept-Encoding` различает варианты ответа. Меньше переданных байт ценой вычислений на сжатие; ускорение нужно измерять. |
|
||||
| Наблюдение | JSON access log в stdout: request id, статус, время, адрес/статус backend, id реплики и результат ограничения. Заголовок авторизации и тела запросов не журналируются; вместо полного URL записывается путь без query string. |
|
||||
|
||||
`non_idempotent` не включён: уже отправленный POST нельзя прозрачно повторять
|
||||
для входа или создания чата. Повтор сообщения после неопределённого результата
|
||||
выполняется клиентом с прежним `Idempotency-Key`; ключ и сообщение сохраняются
|
||||
атомарно в PostgreSQL. Ошибка подключения до отправки допускает другую попытку.
|
||||
|
||||
Лимит Nginx действует по IP, а `MAX_IN_FLIGHT` приложения — по числу одновременных
|
||||
запросов на реплику. Это разные ограничения. За NAT несколько клиентов могут
|
||||
получать один бюджет; произвольный `X-Forwarded-For` не меняет ключ лимита.
|
||||
При исследовании производительности учитывайте ответы 429 и заданный порог;
|
||||
50 запросов/с — начальная настройка стенда, а не измеренная ёмкость системы.
|
||||
|
||||
Период DNS 5 с и пассивные проверки не задают универсального срока обнаружения
|
||||
любого отказа. Например, подключение к молчащему адресу ограничено 500 мс, а
|
||||
зависание уже установленного соединения — тайм-аутом чтения. Время восстановления
|
||||
нужно измерять для выбранного отказа и нагрузки; проверка через Nginx входит
|
||||
в `make test-grade4 PYTHON=.venv/bin/python`.
|
||||
|
||||
## Реализация уровня 4
|
||||
|
||||
Единый прогон: `make test-grade4 PYTHON=.venv/bin/python`. Он проверяет контракт,
|
||||
pytest, публичные сценарии, SIGTERM, замену образа под записью и отказ каждой
|
||||
реплики. Тестовый проект и его volumes удаляются при выходе. Выбор pytest:
|
||||
`PYTEST_ARGS="student-tests/test_sessions.py"`. Реальный вывод и метаданные
|
||||
сохранены в [evidence/](../evidence/README.md), таблица критериев — в [отчёте](../REPORT.md).
|
||||
|
||||
### Завершение и readiness
|
||||
|
||||
`GracefulServer` в `app/core/lifecycle.py` перехватывает первый SIGTERM/SIGINT:
|
||||
переводит приложение в drain, ждёт `SHUTDOWN_DRAIN_SECONDS`, затем запускает
|
||||
штатное завершение Uvicorn. Во время drain `/health/ready` и новые бизнес-запросы
|
||||
получают 503; ранее принятые запросы продолжаются. `/health/live` остаётся 200.
|
||||
Повторный сигнал пропускает оставшуюся drain-паузу.
|
||||
Реализация рассчитана на установленный Uvicorn 0.54.0 и использует его
|
||||
`Server.handle_exit`; при обновлении зависимости этот интерфейс нужно пересмотреть.
|
||||
|
||||
Профиль по умолчанию: drain 1 с, ожидание текущих запросов 5 с, Docker grace 8 с.
|
||||
Настройки приложения требуют `drain + graceful < 8`. В прежнем `.env` следует
|
||||
изменить `SHUTDOWN_DRAIN_SECONDS=0` на `1`, если он был скопирован из старого примера.
|
||||
Команда остановки одной реплики использует такой же предел 8 с; требование
|
||||
публичного hook завершиться за 10 с учитывается отдельно при последующей проверке.
|
||||
|
||||
Readiness одновременно проверяет PostgreSQL и Redis с общим бюджетом 2 с.
|
||||
Python healthcheck ждёт до 2,5 с, Docker — до 3 с; проверки API выполняются каждые
|
||||
3 с с двумя неудачами для unhealthy и стартовым периодом 10 с. После выхода из
|
||||
стартового периода консервативная оценка перехода healthy → unhealthy составляет
|
||||
`2 × (3 + 3) = 12 с`. Nginx не использует этот статус для маршрутизации: он исключает
|
||||
backend по собственным пассивным проверкам. Для отказа установления соединения
|
||||
тайм-аут одной попытки — 500 мс, для зависания чтения — 10 с между порциями данных.
|
||||
Эти границы относятся к разным отказам, а не к единому времени восстановления.
|
||||
|
||||
### Ресурсы
|
||||
|
||||
| Контейнер | CPU | RAM |
|
||||
| --- | --- | --- |
|
||||
| postgres | 1 | 512 MiB |
|
||||
| redis | 0,5 | 512 MiB |
|
||||
| api, каждая реплика | 1 | 512 MiB |
|
||||
| migrate | 0,5 | 256 MiB |
|
||||
| nginx | 0,5 | 128 MiB |
|
||||
|
||||
У Nginx два worker-процесса. Пул вычисления Argon2 ограничен двумя задачами, чтобы
|
||||
параллельный вход не расходовал память пропорционально числу CPU Docker-host.
|
||||
Во время обновления временно работает `N + 1` API-реплик; необходимы свободные
|
||||
ресурсы и запас соединений PostgreSQL. При стандартных пулах две реплики дают
|
||||
до 30 соединений, три — до 45, не считая миграций и диагностики.
|
||||
|
||||
### Секреты
|
||||
|
||||
Перед первым запуском нового профиля:
|
||||
|
||||
```sh
|
||||
make prepare-secrets PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Скрипт создаёт отсутствующие `secrets/db_password` и `secrets/redis_password`.
|
||||
Прежние значения из локального `.env` сохраняются; если их нет, генерируются
|
||||
случайные пароли. Существующие секреты не перезаписываются, значения не выводятся.
|
||||
Это не ротация пароля уже созданной БД. Каталог исключён из Git.
|
||||
|
||||
Compose монтирует файлы в `/run/secrets/`. PostgreSQL получает только пароль БД,
|
||||
Redis — только свой пароль, API — оба, миграции — только пароль БД, Nginx — ни одного.
|
||||
Все переменные Compose обязательны: значения задаются в `.env`, подстановок
|
||||
по умолчанию нет; отсутствующая переменная останавливает запуск. Новые ключи
|
||||
сверяйте с `.env.example`. Контейнерам передаются перечисленные несекретные настройки, весь `.env`
|
||||
через `env_file` больше не передаётся. Порядок настроек приложения: явные параметры,
|
||||
файлы секретов, окружение, локальный `.env`. На хосте также поддерживается `secrets/`.
|
||||
В контейнерах API внутренний порт фиксирован на 8080, идентификатор берётся из
|
||||
собственного HOSTNAME; общий `INSTANCE_ID` всем репликам из `.env` не передаётся.
|
||||
|
||||
Каталог создаётся с правами 0700, файлы — 0444: Compose использует bind-mount
|
||||
файлов, и их должны читать UID приложения и служебные UID PostgreSQL/Redis.
|
||||
Доступ других пользователей хоста ограничивает родительский каталог. Существующие
|
||||
файлы также получают этот режим. Пароли не должны содержать крайние пробелы или
|
||||
переносы строк. Локальные тесты Make читают те же файлы, сохраняя fallback старого `.env`.
|
||||
|
||||
Redis запускается через `infra/redis/start-redis.sh`: SHA-256 пароля записывается
|
||||
во временный ACL-файл с правами 0600 для пользователя redis. В аргументах процесса
|
||||
и конфигурации окружения контейнера пароль отсутствует. Healthcheck читает файл
|
||||
только для вызова `redis-cli`. Настройка ACL совместима с Redis 7.4.
|
||||
|
||||
### Обновление и сценарии отказа
|
||||
|
||||
Первый переход со старого образа уровня 3 на файловые секреты выполняется через
|
||||
`make up` с допустимым окном обслуживания: старый образ не умеет читать секреты
|
||||
нового профиля и не годится для автоматического отката. После перехода образы
|
||||
маркируются `io.mtusi.messenger.secrets=file-v1`.
|
||||
|
||||
```sh
|
||||
make rolling-update PYTHON=.venv/bin/python
|
||||
make failover-all PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Rolling update собирает API один раз, однократно применяет миграции, затем
|
||||
для каждой старой реплики добавляет одну новую, ждёт healthy и наблюдения её ID
|
||||
через Nginx, останавливает и удаляет старую. Число реплик возвращается к исходному.
|
||||
При неизменившемся образе замена пропускается. При неудаче сценарий пытается
|
||||
восстановить исходный образ через пересоздание API без отката БД; аварийный откат
|
||||
может вызвать перерыв. Неиспользуемый прежний образ удаляется после успеха, если
|
||||
у него нет других тегов и контейнеров.
|
||||
|
||||
Миграции при работающих старых репликах должны только расширять схему. Текущие
|
||||
миграции добавляют таблицы и совместимы с прежним API; удаление или переименование
|
||||
используемых полей требует отдельного перехода. Совместимость произвольной будущей
|
||||
миграции сценарий автоматически не доказывает. Откат образа не отменяет миграцию.
|
||||
|
||||
`failover-all` проверяет каждую реплику под записью:
|
||||
останавливает одну выбранную API, сохраняет ключ при неопределённом POST,
|
||||
восстанавливает её до следующей, проверяет подтверждённые сообщения и выводит
|
||||
RPS, ошибки и время восстановления в stdout. По умолчанию два клиента, 2 с прогрева
|
||||
и 15 с после остановки. Лимит Nginx 50 запросов/с влияет на профиль нагрузки.
|
||||
После ошибок применяется пауза 100 мс; нагрузка использует закрытый цикл и не
|
||||
является доказательством максимальной пропускной способности. Для обычного профиля
|
||||
срок сессии должен быть не менее 300 с. Результаты в файлы не записываются.
|
||||
|
||||
Оба сценария используют общую блокировку проекта, чтобы не выполняться одновременно.
|
||||
Ручные команды изменения Docker/Compose во время сценария выполнять не следует.
|
||||
Интеграционная проверка обновления меняет метку `API_BUILD_REVISION`, получая
|
||||
другой ID образа без изменения бизнес-кода, и проверяет замену обоих контейнеров,
|
||||
наличие здоровых реплик перед остановкой, однократный запуск миграций и сохранность
|
||||
записей. Это проверка механизма обновления; произвольные будущие изменения API
|
||||
и схемы требуют собственных проверок совместимости. Для повторения только
|
||||
обновления и отказов на готовом тестовом проекте используется
|
||||
`python -m scripts.check_grade4 --base-url http://localhost:18080 --phase update-and-failover`
|
||||
с теми же `COMPOSE_FILE` и `COMPOSE_PROJECT_NAME`, что у тестового стенда.
|
||||
|
||||
Конкурентный сценарий сообщений использует локальный `tests/client.py`, а не
|
||||
внешний пакет `client`. Запуск из корня — `python -m scripts.check_idempotency`
|
||||
с параметром `--base-url`; цель Make уже использует этот способ запуска.
|
||||
|
||||
## Проверка Nginx без данных мессенджера
|
||||
|
||||
```sh
|
||||
make test-nginx PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Нужны Docker Compose и локальный образ `nginx:1.28.0-alpine`. Скрипт
|
||||
`scripts/check_nginx.py` создаёт отдельный проект с уникальным именем, случайным
|
||||
локальным портом и тестовыми HTTP-backend на том же образе; `.env` приложения,
|
||||
PostgreSQL и Redis не используются. Образы автоматически не скачиваются.
|
||||
Тестовые контейнеры и сеть удаляются в конце, volumes не создаются.
|
||||
|
||||
Проверяются `nginx -t`, две реплики и добавление третьей через DNS без reload,
|
||||
gzip с проверкой исходных байт, лимит 429 и исключение health, передача ошибки API,
|
||||
отсутствие повторной отправки POST, чтение после остановки backend, JSON 503 при
|
||||
отказе всех backend и формат access log. Сценарий не доказывает сохранность
|
||||
сообщений, общую идемпотентность и мягкое завершение реального API — для них нужны
|
||||
публичные и собственные проверки приложения.
|
||||
|
||||
Для уже запущенного основного стенда синтаксис можно проверить командой
|
||||
`docker compose --env-file .env exec -T nginx nginx -t`; после проверки изменение
|
||||
применяется через `docker compose --env-file .env exec -T nginx nginx -s reload`.
|
||||
|
||||
Источники директив: [upstream/DNS](https://nginx.org/en/docs/http/ngx_http_upstream_module.html),
|
||||
[proxy/timeouts/retry](https://nginx.org/en/docs/http/ngx_http_proxy_module.html),
|
||||
[limit_req](https://nginx.org/en/docs/http/ngx_http_limit_req_module.html),
|
||||
[gzip](https://nginx.org/en/docs/http/ngx_http_gzip_module.html).
|
||||
|
||||
+90
-28
@@ -1,34 +1,85 @@
|
||||
# nginx как единая точка входа перед репликами api.
|
||||
# Сейчас — минимальный рабочий round-robin; доработки помечены TODO.
|
||||
# Единая точка входа: round-robin между API-репликами, без sticky sessions.
|
||||
# Директивы рассчитаны на закреплённый nginx:1.28.0-alpine.
|
||||
|
||||
worker_processes auto;
|
||||
worker_processes 2;
|
||||
|
||||
events {
|
||||
worker_connections 1024;
|
||||
}
|
||||
|
||||
http {
|
||||
access_log /dev/stdout;
|
||||
error_log /dev/stderr warn;
|
||||
# В логе используем request_id ответа API, для собственных ошибок — id nginx.
|
||||
map $upstream_http_x_request_id $response_request_id {
|
||||
"" $request_id;
|
||||
default $upstream_http_x_request_id;
|
||||
}
|
||||
|
||||
# TODO(3.3): DNS-обновление адресов backend.
|
||||
# Сейчас `server api:8080` резолвится ОДИН раз при старте nginx: если
|
||||
# реплику пересоздали с новым IP или увеличили число реплик, nginx об этом
|
||||
# не узнает. Варианты:
|
||||
# resolver 127.0.0.11 valid=5s ipv6=off; # встроенный DNS Docker
|
||||
# upstream api_backend { zone api_backend 64k; server api:8080 resolve; }
|
||||
# (параметр `resolve` в open-source nginx доступен с 1.27.3).
|
||||
log_format requests escape=json
|
||||
'{"time":"$time_iso8601","request_id":"$response_request_id",'
|
||||
'"method":"$request_method","uri":"$uri","status":$status,'
|
||||
'"bytes":$body_bytes_sent,"request_time":$request_time,'
|
||||
'"upstream":"$upstream_addr","upstream_status":"$upstream_status",'
|
||||
'"upstream_time":"$upstream_response_time",'
|
||||
'"instance_id":"$upstream_http_x_instance_id",'
|
||||
'"limit_status":"$limit_req_status"}';
|
||||
|
||||
access_log /dev/stdout requests;
|
||||
error_log /dev/stderr warn;
|
||||
server_tokens off;
|
||||
|
||||
# DNS Docker возвращает адреса всех реплик сервиса api.
|
||||
resolver 127.0.0.11 valid=5s ipv6=off;
|
||||
resolver_timeout 1s;
|
||||
|
||||
# Общий для worker-процессов лимит на IP, который видит nginx.
|
||||
# Клиентский X-Forwarded-For не используется в качестве ключа лимита.
|
||||
limit_req_zone $binary_remote_addr zone=per_client:10m rate=50r/s;
|
||||
|
||||
gzip on;
|
||||
gzip_vary on;
|
||||
gzip_min_length 1024;
|
||||
gzip_comp_level 3;
|
||||
gzip_types application/json;
|
||||
|
||||
upstream api_backend {
|
||||
server api:8080;
|
||||
# TODO(4.1): пассивные проверки: max_fails=... fail_timeout=...
|
||||
# (активных health checks в open-source nginx нет — это nginx Plus).
|
||||
# TODO(4.1): keepalive N; + proxy_http_version 1.1 и пустой Connection.
|
||||
zone api_backend 64k;
|
||||
server api:8080 resolve max_fails=1 fail_timeout=5s;
|
||||
|
||||
# Кэш свободных соединений на worker, а не лимит запросов к API.
|
||||
keepalive 16;
|
||||
keepalive_timeout 4s;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
|
||||
client_header_timeout 10s;
|
||||
client_body_timeout 10s;
|
||||
send_timeout 10s;
|
||||
keepalive_timeout 30s;
|
||||
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Connection "";
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
|
||||
proxy_connect_timeout 500ms;
|
||||
proxy_send_timeout 10s;
|
||||
proxy_read_timeout 10s;
|
||||
|
||||
# Пассивное обнаружение отказов; Docker healthcheck сам не управляет LB.
|
||||
# non_idempotent не включён: уже отправленные POST не повторяем.
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504;
|
||||
proxy_next_upstream_tries 2;
|
||||
# Окно перехода на другой backend, не общий deadline ответа.
|
||||
proxy_next_upstream_timeout 2s;
|
||||
|
||||
# JSON и заголовки ошибок API передаются без подмены.
|
||||
proxy_intercept_errors off;
|
||||
error_page 429 = @rate_limited;
|
||||
error_page 502 503 504 = @unavailable;
|
||||
|
||||
# Проверка самого LB для healthcheck в compose; не проксируется в API.
|
||||
location = /lb-health {
|
||||
access_log off;
|
||||
@@ -36,20 +87,31 @@ http {
|
||||
return 200 "ok\n";
|
||||
}
|
||||
|
||||
location / {
|
||||
# Проверки готовности/жизни не расходуют бюджет бизнес-запросов.
|
||||
location /health/ {
|
||||
proxy_pass http://api_backend;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
}
|
||||
|
||||
# TODO(4.1): таймауты, согласованные с API и тестами:
|
||||
# proxy_connect_timeout ...; proxy_send_timeout ...; proxy_read_timeout ...;
|
||||
# TODO(4.1): переключение на другой backend при отказе:
|
||||
# proxy_next_upstream error timeout http_502 http_503 ...;
|
||||
# proxy_next_upstream_tries ...; proxy_next_upstream_timeout ...;
|
||||
# Внимание: POST nginx по умолчанию НЕ повторяет после отправки
|
||||
# запроса (non_idempotent). Подумайте, безопасно ли добавлять
|
||||
# non_idempotent при наличии Idempotency-Key.
|
||||
# Не используйте ip_hash/sticky как "лечение" раздельного состояния.
|
||||
location / {
|
||||
limit_req zone=per_client burst=100 nodelay;
|
||||
limit_req_status 429;
|
||||
limit_req_log_level warn;
|
||||
proxy_pass http://api_backend;
|
||||
}
|
||||
|
||||
# Это ответы балансировщика: X-Instance-Id реплики у них отсутствует.
|
||||
location @rate_limited {
|
||||
default_type application/json;
|
||||
add_header X-Request-Id $request_id always;
|
||||
add_header Retry-After 1 always;
|
||||
return 429 '{"error":{"code":"rate_limited","message":"Request rate exceeded","request_id":"$request_id"}}';
|
||||
}
|
||||
|
||||
location @unavailable {
|
||||
default_type application/json;
|
||||
add_header X-Request-Id $request_id always;
|
||||
add_header Retry-After 1 always;
|
||||
return 503 '{"error":{"code":"unavailable","message":"API temporarily unavailable","request_id":"$request_id"}}';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
@@ -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 @@
|
||||
"""Команды управления учебным стендом."""
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Подготавливает локальные файлы Docker secrets."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
import secrets
|
||||
|
||||
from pydantic import SecretStr
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
class ExistingSecrets(BaseSettings):
|
||||
"""Читает прежние пароли без вывода значений."""
|
||||
|
||||
db_password: SecretStr | None = None
|
||||
redis_password: SecretStr | None = None
|
||||
model_config = SettingsConfigDict(env_file=ROOT / ".env", extra="ignore")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""Создаёт отсутствующие файлы, сохраняя существующие значения."""
|
||||
directory = ROOT / "secrets"
|
||||
directory.mkdir(mode=0o700, exist_ok=True)
|
||||
directory.chmod(0o700)
|
||||
existing = ExistingSecrets()
|
||||
for name in ("db_password", "redis_password"):
|
||||
path = directory / name
|
||||
if path.is_symlink():
|
||||
raise RuntimeError(f"Секрет {name} не должен быть символьной ссылкой")
|
||||
if path.exists() and not path.is_file():
|
||||
raise RuntimeError(f"Секрет {name} должен быть обычным файлом")
|
||||
if not path.exists():
|
||||
previous = getattr(existing, name)
|
||||
value = previous.get_secret_value() if previous else secrets.token_urlsafe(32)
|
||||
if not value or value.strip() != value or "\n" in value or "\r" in value:
|
||||
raise ValueError(f"Секрет {name} должен занимать одну строку без крайних пробелов")
|
||||
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "w") as file:
|
||||
file.write(value + "\n")
|
||||
path.chmod(0o444)
|
||||
print(f"Готов файл secrets/{name}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,6 +1,4 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API и всех хранилищ с сохранением volumes (make test-persistence).
|
||||
# У api несколько реплик, перед ними nginx.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
@@ -8,7 +6,6 @@ compose() {
|
||||
docker compose --env-file .env "$@"
|
||||
}
|
||||
|
||||
# Ждёт, пока ВСЕ контейнеры service станут healthy (у api их несколько).
|
||||
wait_healthy() {
|
||||
for service in "$@"; do
|
||||
attempts=0
|
||||
@@ -29,7 +26,5 @@ compose restart postgres redis
|
||||
wait_healthy postgres redis
|
||||
compose restart api
|
||||
wait_healthy api
|
||||
# TODO(3.3): если nginx перерезолвит DNS сам, рестарт LB не обязателен —
|
||||
# но перезапуск «всего стенда» в защите всё равно его включает.
|
||||
compose restart nginx
|
||||
wait_healthy nginx
|
||||
|
||||
@@ -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()
|
||||
+24
-15
@@ -1,21 +1,30 @@
|
||||
#!/bin/sh
|
||||
# Останавливает одну API-реплику по TARGET_INSTANCE_ID (сценарий отказа, make test-failover).
|
||||
# TODO(3.5): реализовать — см. docs/LAB3_TASKS.md, задача 3.5.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
# Что нужно сделать:
|
||||
# 1. Сопоставить TARGET_INSTANCE_ID (значение X-Instance-Id) с контейнером.
|
||||
# Проще всего, если X-Instance-Id = короткий id контейнера (HOSTNAME):
|
||||
# docker compose --env-file .env ps -q api -> полные id реплик api
|
||||
# и найти тот, что начинается с TARGET_INSTANCE_ID.
|
||||
# 2. Убедиться, что это контейнер service `api` ЭТОГО compose-проекта,
|
||||
# а не postgres/nginx/чужой контейнер. Не нашли -> exit 1.
|
||||
# 3. Остановить его (docker stop [-t N]) и оставить остановленным.
|
||||
# Не трогать БД/LB/volumes. Уложиться в 10 секунд.
|
||||
# 4. Напечатать (в stderr), что именно остановлено — пригодится для отчёта.
|
||||
# Восстановление — отдельно: make restore.
|
||||
case "$TARGET_INSTANCE_ID" in
|
||||
*[!a-zA-Z0-9_.:-]*|'') exit 1 ;;
|
||||
esac
|
||||
|
||||
echo 'TODO: implement stop-one.sh' >&2
|
||||
exit 2
|
||||
target=""
|
||||
for container in $(docker compose --env-file .env ps -q api); do
|
||||
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$container")
|
||||
configured=$(docker inspect --format '{{range .Config.Env}}{{if eq (index (split . "=") 0) "INSTANCE_ID"}}{{println .}}{{end}}{{end}}' "$container" \
|
||||
| sed -n 's/^INSTANCE_ID=//p' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||||
if [ "$TARGET_INSTANCE_ID" = "$hostname" ] || [ "$TARGET_INSTANCE_ID" = "$configured" ]; then
|
||||
if [ -n "$target" ]; then
|
||||
echo 'Instance id matches multiple API containers' >&2
|
||||
exit 1
|
||||
fi
|
||||
target="$container"
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -z "$target" ]; then
|
||||
echo 'Target API instance not found in this Compose project' >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Stopping API container $target" >&2
|
||||
docker stop --timeout 8 "$target" >/dev/null
|
||||
|
||||
@@ -8,7 +8,7 @@ from sqlalchemy import text
|
||||
|
||||
from app.main import create_app
|
||||
from conftest import close_app, make_client
|
||||
from helpers import PASSWORD, basic_header, bearer, create_user, register
|
||||
from helpers import PASSWORD, basic_header, bearer, create_user, idempotency_header, register
|
||||
|
||||
|
||||
async def test_parallel_registration_of_same_username_creates_exactly_one_user(
|
||||
@@ -62,7 +62,7 @@ async def test_100_messages_from_10_clients(make_settings):
|
||||
*(
|
||||
client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(user),
|
||||
headers={**bearer(user), **idempotency_header()},
|
||||
json={"text": f"client-{index}-message-{n}"},
|
||||
)
|
||||
for n in range(10)
|
||||
@@ -207,7 +207,7 @@ async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine
|
||||
*(
|
||||
client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(user),
|
||||
headers={**bearer(user), **idempotency_header()},
|
||||
json={"text": f"m{i}"},
|
||||
)
|
||||
for i in range(20)
|
||||
|
||||
@@ -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
|
||||
@@ -0,0 +1,106 @@
|
||||
"""Идентификатор реплики и заголовки ответов без PostgreSQL, Redis и Docker."""
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
import pytest
|
||||
from fastapi import Request
|
||||
|
||||
from app.core.instance import resolve_instance_id
|
||||
from app.errors.exceptions import unavailable
|
||||
from app.main import create_app
|
||||
from conftest import close_app, make_client
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def clean_db() -> None:
|
||||
"""Заменяет очистку БД из conftest: эти тесты не обращаются к хранилищам."""
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("configured", "expected"),
|
||||
[
|
||||
("api-explicit", "api-explicit"),
|
||||
(" api-explicit ", "api-explicit"),
|
||||
(None, "container-123"),
|
||||
("", "container-123"),
|
||||
(" ", "container-123"),
|
||||
],
|
||||
)
|
||||
def test_resolve_prefers_configured_id_then_hostname(monkeypatch, configured, expected):
|
||||
monkeypatch.setenv("HOSTNAME", " container-123 ")
|
||||
|
||||
assert resolve_instance_id(configured) == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize("hostname", [None, "", " "])
|
||||
def test_resolve_without_config_or_hostname_returns_uuid(monkeypatch, hostname):
|
||||
if hostname is None:
|
||||
monkeypatch.delenv("HOSTNAME", raising=False)
|
||||
else:
|
||||
monkeypatch.setenv("HOSTNAME", hostname)
|
||||
|
||||
assert UUID(resolve_instance_id(None)).version == 4
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def instance_client(make_settings):
|
||||
app = create_app(
|
||||
make_settings(
|
||||
instance_id="api-test",
|
||||
database_url="postgresql+asyncpg://unused@127.0.0.1:1/unused",
|
||||
redis_port=1,
|
||||
)
|
||||
)
|
||||
|
||||
@app.get("/__test__/request-id", include_in_schema=False)
|
||||
async def request_id(request: Request) -> dict[str, str]:
|
||||
return {"request_id": request.state.request_id}
|
||||
|
||||
@app.get("/__test__/explode", include_in_schema=False)
|
||||
async def explode() -> None:
|
||||
raise RuntimeError("test error")
|
||||
|
||||
@app.get("/__test__/unavailable", include_in_schema=False)
|
||||
async def dependency_failure() -> None:
|
||||
raise unavailable()
|
||||
|
||||
try:
|
||||
async with make_client(app, raise_app_exceptions=False) as client:
|
||||
yield client
|
||||
finally:
|
||||
await close_app(app)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("method", "path", "status"),
|
||||
[
|
||||
("GET", "/health/live", 200),
|
||||
("POST", "/api/v1/users", 400),
|
||||
("GET", "/api/v1/users/me", 401),
|
||||
("GET", "/no-such-path", 404),
|
||||
("DELETE", "/health/live", 405),
|
||||
("GET", "/__test__/explode", 500),
|
||||
("GET", "/__test__/unavailable", 503),
|
||||
],
|
||||
)
|
||||
async def test_instance_header_is_present_on_success_and_errors(
|
||||
instance_client, method, path, status
|
||||
):
|
||||
response = await instance_client.request(method, path)
|
||||
|
||||
assert response.status_code == status
|
||||
assert response.headers["X-Instance-Id"] == "api-test"
|
||||
assert response.headers["X-Request-Id"]
|
||||
if status >= 400:
|
||||
assert response.json()["error"]["request_id"] == response.headers["X-Request-Id"]
|
||||
|
||||
|
||||
async def test_instance_id_is_stable_while_request_ids_are_distinct(instance_client):
|
||||
first = await instance_client.get("/__test__/request-id")
|
||||
second = await instance_client.get("/__test__/request-id")
|
||||
|
||||
assert first.status_code == second.status_code == 200
|
||||
assert first.headers["X-Instance-Id"] == second.headers["X-Instance-Id"] == "api-test"
|
||||
assert first.headers["X-Request-Id"] != second.headers["X-Request-Id"]
|
||||
for response in (first, second):
|
||||
assert response.json()["request_id"] == response.headers["X-Request-Id"]
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Готовность при завершении и ограничение времени проверки зависимостей."""
|
||||
|
||||
import asyncio
|
||||
import time
|
||||
|
||||
import pytest
|
||||
|
||||
from app.endpoints import health
|
||||
from app.main import create_app
|
||||
from conftest import close_app, make_client
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def clean_db() -> None:
|
||||
"""Эти проверки не обращаются к хранилищам."""
|
||||
|
||||
|
||||
async def test_draining_keeps_liveness_but_rejects_new_work(make_settings):
|
||||
app = create_app(make_settings())
|
||||
app.state.lifecycle.start_draining()
|
||||
try:
|
||||
async with make_client(app) as client:
|
||||
assert (await client.get('/health/live')).status_code == 200
|
||||
assert (await client.get('/health/ready')).status_code == 503
|
||||
assert (await client.get('/api/v1/users/me')).status_code == 503
|
||||
finally:
|
||||
await close_app(app)
|
||||
|
||||
|
||||
async def test_readiness_timeout_cancels_dependency_checks(make_settings, monkeypatch):
|
||||
cancelled = []
|
||||
|
||||
async def stalled(_):
|
||||
try:
|
||||
await asyncio.sleep(30)
|
||||
finally:
|
||||
cancelled.append(True)
|
||||
|
||||
monkeypatch.setattr(health, 'check_database', stalled)
|
||||
monkeypatch.setattr(health, 'check_redis', stalled)
|
||||
app = create_app(make_settings(readiness_timeout_seconds=0.03))
|
||||
try:
|
||||
async with make_client(app) as client:
|
||||
started = time.monotonic()
|
||||
response = await client.get('/health/ready')
|
||||
assert response.status_code == 503
|
||||
assert time.monotonic() - started < 1
|
||||
assert len(cancelled) == 2
|
||||
finally:
|
||||
await close_app(app)
|
||||
@@ -6,7 +6,7 @@ import httpx
|
||||
|
||||
from app.main import create_app
|
||||
from conftest import close_app, make_client
|
||||
from helpers import assert_request_id, bearer, create_chat, create_user
|
||||
from helpers import assert_request_id, bearer, create_chat, create_user, idempotency_header
|
||||
|
||||
|
||||
def _assert_error(response: httpx.Response, status: int, code: str) -> None:
|
||||
@@ -25,12 +25,12 @@ async def test_message_limit_rejects_without_deleting_confirmed_messages(make_se
|
||||
|
||||
for index in range(2):
|
||||
ok = await client.post(
|
||||
url, headers=bearer(user), json={"text": f"confirmed-{index}"}
|
||||
url, headers={**bearer(user), **idempotency_header()}, json={"text": f"confirmed-{index}"}
|
||||
)
|
||||
assert ok.status_code == 201
|
||||
|
||||
rejected = await client.post(
|
||||
url, headers=bearer(user), json={"text": "rejected"}
|
||||
url, headers={**bearer(user), **idempotency_header()}, json={"text": "rejected"}
|
||||
)
|
||||
_assert_error(rejected, 503, "unavailable")
|
||||
|
||||
@@ -48,7 +48,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
|
||||
|
||||
app = create_app(make_settings(max_in_flight=2))
|
||||
|
||||
original_send_message = message_endpoint.send_message
|
||||
original_send_message = message_endpoint.send_message_idempotent
|
||||
accepted_count = 0
|
||||
all_slots_taken = asyncio.Event()
|
||||
release = asyncio.Event()
|
||||
@@ -65,12 +65,12 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
|
||||
user = await create_user(client)
|
||||
chat = await create_chat(client, user)
|
||||
|
||||
monkeypatch.setattr(message_endpoint, "send_message", blocking_send_message)
|
||||
monkeypatch.setattr(message_endpoint, "send_message_idempotent", blocking_send_message)
|
||||
url = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
held = [
|
||||
asyncio.create_task(
|
||||
client.post(url, headers=bearer(user), json={"text": f"held-{i}"})
|
||||
client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"held-{i}"})
|
||||
)
|
||||
for i in range(2)
|
||||
]
|
||||
@@ -79,7 +79,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
|
||||
|
||||
rejected = await asyncio.gather(
|
||||
*(
|
||||
client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"})
|
||||
client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"rejected-{i}"})
|
||||
for i in range(4)
|
||||
)
|
||||
)
|
||||
@@ -92,7 +92,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
|
||||
release.set()
|
||||
assert all(r.status_code == 201 for r in await asyncio.gather(*held))
|
||||
|
||||
recovered = await client.post(url, headers=bearer(user), json={"text": "after"})
|
||||
recovered = await client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": "after"})
|
||||
assert recovered.status_code == 201
|
||||
assert_request_id(recovered)
|
||||
await close_app(app)
|
||||
|
||||
@@ -8,6 +8,7 @@ from helpers import (
|
||||
bearer,
|
||||
create_chat,
|
||||
create_user,
|
||||
idempotency_header,
|
||||
send_message,
|
||||
)
|
||||
|
||||
@@ -58,7 +59,7 @@ async def test_extra_message_field_is_rejected(client: AsyncClient):
|
||||
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(alice),
|
||||
headers={**bearer(alice), **idempotency_header()},
|
||||
json={"text": "hello", "sender_id": alice["id"]},
|
||||
)
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ from sqlalchemy import inspect, text
|
||||
from app.models import Base
|
||||
from conftest import reset_schema, upgrade_head
|
||||
|
||||
EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters"}
|
||||
EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters", "idempotency_keys"}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
"""Публичный HTTP-клиент и проверки контракта."""
|
||||
Reference in New Issue
Block a user