From 2e7a80be9279d1d40b97e2526bcccfe3004fbdaf Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 17:24:54 +0300 Subject: [PATCH] =?UTF-8?q?lab3:=20=D0=B1=D0=B0=D0=BB=D0=B0=D0=BD=D1=81?= =?UTF-8?q?=D0=B8=D1=80=D0=BE=D0=B2=D0=BA=D0=B0,=20=D0=B8=D0=B4=D0=B5?= =?UTF-8?q?=D0=BC=D0=BF=D0=BE=D1=82=D0=B5=D0=BD=D1=82=D0=BD=D0=BE=D1=81?= =?UTF-8?q?=D1=82=D1=8C,=20=D0=BE=D1=82=D0=BA=D0=B0=D0=B7=20=D1=80=D0=B5?= =?UTF-8?q?=D0=BF=D0=BB=D0=B8=D0=BA=D0=B8,=20=D1=82=D1=80=D0=B5=D0=BA=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - X-Instance-Id, обязательный Idempotency-Key (PostgreSQL, одна транзакция) - HAProxy + 2..N реплик API, readiness/drain по SIGTERM, однократные миграции - скрипты stop-one/restore/restart/rolling-update/collect-evidence - трек 1: параметризованный стенд, cmd/bench, оркестратор и анализ - workflow реального прогона Docker-стенда на GitHub Actions Co-Authored-By: Claude Opus 5.5 --- .dockerignore | 2 + .env.example | 13 +- .github/workflows/lab3-stand.yml | 91 +++++ Dockerfile | 54 +++ Makefile | 28 +- REPORT.md | 193 ++++++++++- cmd/api/main.go | 151 ++++++++ cmd/bench/main.go | 328 ++++++++++++++++++ compose.yaml | 131 +++++++ evidence/idempotency_concurrent_native.json | 88 +++++ evidence/local_native_check.txt | 15 + experiments/track1.json | 72 ++++ go.mod | 21 ++ go.sum | 43 +++ infra/haproxy/haproxy.cfg | 59 ++++ internal/config/config.go | 113 ++++++ internal/domain/chat.go | 30 ++ internal/domain/message.go | 25 ++ internal/domain/session.go | 10 + internal/domain/user.go | 25 ++ internal/repository/postgres/chat.go | 159 +++++++++ internal/repository/postgres/message.go | 135 +++++++ internal/repository/postgres/pool.go | 39 +++ internal/repository/postgres/user.go | 77 ++++ internal/repository/redis/message_cache.go | 111 ++++++ internal/repository/redis/session.go | 73 ++++ internal/repository/repository.go | 55 +++ internal/service/auth.go | 99 ++++++ internal/service/chat.go | 138 ++++++++ internal/service/cursor.go | 39 +++ internal/service/errors.go | 12 + internal/service/id.go | 23 ++ internal/service/message.go | 161 +++++++++ internal/service/password.go | 66 ++++ internal/service/user.go | 64 ++++ internal/service/validate.go | 48 +++ internal/transport/http/auth.go | 92 +++++ internal/transport/http/chat.go | 86 +++++ internal/transport/http/health.go | 54 +++ internal/transport/http/internal_stats.go | 39 +++ internal/transport/http/message.go | 75 ++++ internal/transport/http/middleware/auth.go | 48 +++ .../transport/http/middleware/instance.go | 14 + internal/transport/http/middleware/logging.go | 34 ++ .../transport/http/middleware/recovery.go | 25 ++ .../transport/http/middleware/request_id.go | 29 ++ internal/transport/http/middleware/timeout.go | 18 + internal/transport/http/router.go | 54 +++ internal/transport/http/user.go | 49 +++ internal/transport/httputil/response.go | 158 +++++++++ migrations/0001_init.down.sql | 6 + migrations/0001_init.up.sql | 50 +++ migrations/0002_idempotency.down.sql | 1 + migrations/0002_idempotency.up.sql | 18 + scripts/collect-evidence.sh | 67 ++++ scripts/init-secrets.sh | 16 + scripts/restart.sh | 16 + scripts/restore.sh | 17 + scripts/rolling-update.sh | 35 ++ scripts/stop-one.sh | 25 ++ scripts/track1.py | 316 +++++++++++++++++ scripts/track1_report.py | 304 ++++++++++++++++ scripts/win/restart.cmd | 3 + scripts/win/restore.cmd | 3 + scripts/win/stop-one.cmd | 3 + tests/failover_series.py | 171 +++++++++ tests/idempotency_concurrent.py | 89 +++++ tests/negative.py | 58 ++++ 68 files changed, 4747 insertions(+), 17 deletions(-) create mode 100644 .github/workflows/lab3-stand.yml create mode 100644 Dockerfile create mode 100644 cmd/api/main.go create mode 100644 cmd/bench/main.go create mode 100644 compose.yaml create mode 100644 evidence/idempotency_concurrent_native.json create mode 100644 evidence/local_native_check.txt create mode 100644 experiments/track1.json create mode 100644 go.mod create mode 100644 go.sum create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 internal/config/config.go create mode 100644 internal/domain/chat.go create mode 100644 internal/domain/message.go create mode 100644 internal/domain/session.go create mode 100644 internal/domain/user.go create mode 100644 internal/repository/postgres/chat.go create mode 100644 internal/repository/postgres/message.go create mode 100644 internal/repository/postgres/pool.go create mode 100644 internal/repository/postgres/user.go create mode 100644 internal/repository/redis/message_cache.go create mode 100644 internal/repository/redis/session.go create mode 100644 internal/repository/repository.go create mode 100644 internal/service/auth.go create mode 100644 internal/service/chat.go create mode 100644 internal/service/cursor.go create mode 100644 internal/service/errors.go create mode 100644 internal/service/id.go create mode 100644 internal/service/message.go create mode 100644 internal/service/password.go create mode 100644 internal/service/user.go create mode 100644 internal/service/validate.go create mode 100644 internal/transport/http/auth.go create mode 100644 internal/transport/http/chat.go create mode 100644 internal/transport/http/health.go create mode 100644 internal/transport/http/internal_stats.go create mode 100644 internal/transport/http/message.go create mode 100644 internal/transport/http/middleware/auth.go create mode 100644 internal/transport/http/middleware/instance.go create mode 100644 internal/transport/http/middleware/logging.go create mode 100644 internal/transport/http/middleware/recovery.go create mode 100644 internal/transport/http/middleware/request_id.go create mode 100644 internal/transport/http/middleware/timeout.go create mode 100644 internal/transport/http/router.go create mode 100644 internal/transport/http/user.go create mode 100644 internal/transport/httputil/response.go create mode 100644 migrations/0001_init.down.sql create mode 100644 migrations/0001_init.up.sql create mode 100644 migrations/0002_idempotency.down.sql create mode 100644 migrations/0002_idempotency.up.sql create mode 100755 scripts/collect-evidence.sh create mode 100755 scripts/init-secrets.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/restore.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh create mode 100644 scripts/track1.py create mode 100644 scripts/track1_report.py create mode 100644 scripts/win/restart.cmd create mode 100644 scripts/win/restore.cmd create mode 100644 scripts/win/stop-one.cmd create mode 100644 tests/failover_series.py create mode 100644 tests/idempotency_concurrent.py create mode 100644 tests/negative.py diff --git a/.dockerignore b/.dockerignore index bc16e55..a77c419 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,5 @@ __pycache__ node_modules evidence .DS_Store +bin +experiments diff --git a/.env.example b/.env.example index d32b9be..b6af872 100644 --- a/.env.example +++ b/.env.example @@ -7,7 +7,18 @@ SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +SESSION_STORE=redis CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +# Graceful shutdown: after SIGTERM readiness=503 for DRAIN_DELAY, then Shutdown up to SHUTDOWN_TIMEOUT. +DRAIN_DELAY=3s +SHUTDOWN_TIMEOUT=8s +# Tuning knobs (track 1 experiments; defaults shown). +DB_POOL_MAX=20 +CACHE_INVALIDATION=version +LB_BALANCE=roundrobin +API_CPUS=0.50 +API_MEMORY=256M +PG_CPUS=1.00 +PG_MAX_CONNECTIONS=100 diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml new file mode 100644 index 0000000..ae00212 --- /dev/null +++ b/.github/workflows/lab3-stand.yml @@ -0,0 +1,91 @@ +# Реальный прогон Docker-стенда lab3 на GitHub-hosted runner (ubuntu, 4 vCPU / 16 GB). +# Нужен потому, что на машине разработки нет аппаратной виртуализации для Docker Desktop. +# Все результаты — настоящие измерения; сокращённая методика трека 1 описана в REPORT.md. +name: lab3 stand + +on: + push: + branches: [lab3] + workflow_dispatch: + +permissions: + contents: read + +env: + PYTHONUTF8: "1" + +jobs: + levels-3-4: + name: Уровни 3–4 (smoke, failover, persistence, идемпотентность, серия отказов, rolling update) + runs-on: ubuntu-24.04 + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Секреты и запуск стенда + run: | + chmod +x scripts/*.sh + sh scripts/init-secrets.sh + docker compose --env-file .env config --quiet + docker compose --env-file .env up -d --build --wait + - name: make check + сбор доказательств + run: | + make check PYTHON=python + PYTHON=python sh scripts/collect-evidence.sh + - name: Окружение runner + if: always() + run: | + { nproc; free -m; docker version --format '{{.Server.Version}}'; docker compose version; } > evidence/runner.txt + docker compose ps -a > evidence/docker_ps_final.txt || true + docker compose logs --no-color lb > evidence/lb_log.txt 2>&1 || true + - uses: actions/upload-artifact@v4 + if: always() + with: + name: evidence-levels-3-4 + path: evidence/ + + track1: + name: Трек 1 — ${{ matrix.series }} + runs-on: ubuntu-24.04 + timeout-minutes: 40 + strategy: + fail-fast: false + matrix: + include: + - series: A_fixed_total + configs: "" + levels: "4,16,64" + - series: B_scale_out + configs: "1x0.50,2x0.50,4x0.50" + levels: "4,16,64" + - series: D_improvement + configs: "" + levels: "32,64" + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + - name: Секреты + run: chmod +x scripts/*.sh && sh scripts/init-secrets.sh + - name: Серия ${{ matrix.series }} + run: | + python scripts/track1.py --series ${{ matrix.series }} \ + --configs "${{ matrix.configs }}" --levels "${{ matrix.levels }}" \ + --duration 15s --warmup 3s --repeats 3 \ + --output evidence/track1/raw_${{ matrix.series }}.jsonl + - name: Окружение runner + if: always() + run: | + mkdir -p evidence/track1 + { nproc; free -m; lscpu | grep -E 'Model name|^CPU\(s\)'; } > evidence/track1/runner_${{ matrix.series }}.txt + - uses: actions/upload-artifact@v4 + if: always() + with: + name: track1-${{ matrix.series }} + path: evidence/track1/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..7bbb0a8 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,54 @@ +# ============================================================ +# Stage 1: builder — компилируем статический бинарник +# ============================================================ +FROM golang:1.26-alpine AS builder + +WORKDIR /src + +# Сначала манифесты зависимостей — кэшируем слой. +COPY go.mod go.sum ./ +RUN go mod download + +# Затем исходники. +COPY . . + +# Статический бинарник с оптимизациями: +# CGO_ENABLED=0 — статическая линковка (не требует libc) +# -ldflags="-s -w" — убираем отладочную информацию +# -trimpath — убираем пути сборки из бинарника +RUN CGO_ENABLED=0 GOOS=linux go build \ + -ldflags="-s -w" \ + -trimpath \ + -o /out/api \ + ./cmd/api + +# ============================================================ +# Stage 2: runtime — минимальный образ только с бинарником +# ============================================================ +FROM alpine:3.20 + +# ca-certificates — для HTTPS в lab2+ +# tzdata — для корректной работы с временными зонами +RUN apk --no-cache add ca-certificates tzdata + +# Непривилегированный пользователь (UID/GID 1001). +RUN addgroup -g 1001 -S appgroup && \ + adduser -u 1001 -S appuser -G appgroup + +WORKDIR /app + +# Копируем бинарник и сразу выставляем владельца. +COPY --from=builder --chown=appuser:appgroup /out/api /app/api + +# Переключаемся на непривилегированного пользователя. +USER 1001:1001 + +# Информативно: какой порт слушает приложение. +EXPOSE 8080 + +# Healthcheck: readiness (БД + Redis + не в режиме drain). +HEALTHCHECK --interval=5s --timeout=2s --start-period=5s --retries=3 \ + CMD wget --spider -q http://localhost:8080/health/ready || exit 1 + +# Exec-форма CMD — критично для доставки SIGTERM в приложение. +CMD ["/app/api"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d17..af27325 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover up down test-idempotency test-failover-series track1 track1-quick track1-report help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +28,29 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --- Студенческие цели (lab3) --- +up: + sh scripts/init-secrets.sh + docker compose --env-file .env up -d --build --wait + +down: + docker compose --env-file .env stop + +test-idempotency: + $(PYTHON) tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-failover-series: + $(PYTHON) tests/failover_series.py --base-url "$(BASE_URL)" $(TLS_ARGS) --output evidence/failover_series.json + +# --- Трек 5.1: цена масштабирования (отдельный compose-проект на :18080) --- +track1: + $(PYTHON) scripts/track1.py --resume + $(PYTHON) scripts/track1_report.py + +track1-quick: + $(PYTHON) scripts/track1.py --quick --output evidence/track1/raw_quick.jsonl + $(PYTHON) scripts/track1_report.py --input evidence/track1/raw_quick.jsonl --outdir evidence/track1/quick + +track1-report: + $(PYTHON) scripts/track1_report.py diff --git a/REPORT.md b/REPORT.md index c267900..a1a1913 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,200 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303 +- Целевая оценка: 5 (уровни 3, 4 и трек 1 «Цена масштабирования») - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Основа: собственная lab2 — https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab2 +- Использованные источники: + - Контракт: contracts/openapi.json, contracts/README.md (раздел «Балансировка и повторная отправка») + - Go: net/http (Server.Shutdown), log/slog, sync/atomic, crypto/sha256 + - Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2 + - Документация: HAProxy 3.0 (server-template, resolvers, http-check, retry-on), Docker Compose services/deploy, PostgreSQL INSERT … ON CONFLICT + - AI-ассистент использован для переноса кода lab2, реализации идемпотентности, конфигурации LB и скриптов; код проверен вручную и тестами. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +### Версии +| Компонент | Образ / версия | +| --- | --- | +| API builder / runtime | golang:1.26-alpine / alpine:3.20 (multi-stage, бинарник static, USER 1001) | +| LB | haproxy:3.0.5-alpine | +| БД | postgres:16.4-alpine | +| Сессии + кэш | redis:7.4.1-alpine (AOF, appendfsync everysec) | +| Миграции | migrate/migrate:v4.17.0 | + +Prerequisites: Docker Engine/Desktop с Compose v2, Python 3.9+, POSIX shell (Linux/macOS/WSL или Git Bash). + +### Команды + +```sh +# 1. Локальные .env и secrets/ (случайный пароль БД; повторный запуск ничего не перезаписывает) +sh scripts/init-secrets.sh + +# 2. Проверка и запуск: postgres/redis → migrate (однократно) → api ×2 → lb +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait + +# 3. Готовность и проверки +curl -i http://localhost:8080/health/ready +make test +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +sh scripts/restore.sh # вернуть остановленную реплику +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-idempotency +make test-failover-series + +# Все доказательства одной командой (пишет в evidence/): +sh scripts/collect-evidence.sh +``` + +Windows: `python3` там часто заглушка — используйте `make ... PYTHON=python` и `PYTHONUTF8=1`. Python на Windows не исполняет `.sh` напрямую (WinError 193), поэтому для публичных тестов есть обёртки: `ACTION_SCRIPT=scripts/win/stop-one.cmd`, `scripts/win/restart.cmd` (вызывают Git Bash). + +Число реплик: `API_REPLICAS` в `.env` или `docker compose up -d --scale api=4`. + +Остановка без потери данных: `docker compose --env-file .env stop`. +Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет volumes pg_data и redis_data). ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──► lb (HAProxy :8080, единственный опубликованный порт; :8404 stats, только 127.0.0.1) + │ roundrobin, active check GET /health/ready каждые 1 s, DNS Docker + ▼ + api × N (сеть front+back, портов наружу нет, без container_name) + │ + ├──► postgres (сеть back): users, chats, chat_members, messages, idempotency_keys + └──► redis (сеть back): сессии (AOF), кэш истории (версия чата) +migrate (one-shot) ──► postgres — до старта api +``` + +**Перенесено из lab2 без изменений:** API, валидация, Argon2id, keyset-пагинация, сессии в Redis с TTL (переживают рестарт благодаря AOF), кэш истории с версионированием чата. + +**Изменено в lab3:** + +1. **X-Instance-Id** — middleware на самом внешнем уровне, есть в каждом ответе API, включая ошибки и health. Значение = hostname процесса; в Docker это короткий ID контейнера, поэтому `stop-one.sh` однозначно находит контейнер (`docker compose ps -q api` + сравнение префикса). Переопределяется `INSTANCE_ID`. В lab7 будет заменён на непрозрачный alias. +2. **Идемпотентность POST сообщения** (`internal/repository/postgres/message.go`, миграция `0002_idempotency`): + - заголовок обязателен, `^[A-Za-z0-9._:-]{1,128}$`, иначе 400; + - область: `PRIMARY KEY (user_id, chat_id, key)` (метод всегда POST, путь задаётся chat_id); + - `request_hash` = SHA-256 от канонического JSON уже разобранного тела, поэтому порядок ключей/пробелы не важны; + - в **одной транзакции**: удалить просроченный ключ этой области → `INSERT message` → `INSERT idempotency_keys … ON CONFLICT DO NOTHING`. Конкурентный запрос с тем же ключом через другую реплику блокируется на уникальном индексе до COMMIT первой транзакции, получает конфликт, откатывает своё сообщение и возвращает сохранённое (тот же 201 и тот же Message) или 409 при другом body; + - если первая транзакция откатилась (транзиентная 5xx), ключ не фиксируется и повтор выполняется заново; + - авторизация и членство в чате проверяются до обращения к ключу, т. е. при каждом повторе; + - TTL `IDEMPOTENCY_TTL_SECONDS` (86400); фоновая очистка раз в час (идемпотентный DELETE, безопасен с любой реплики). +3. **Миграции** — отдельный one-shot сервис `migrate` (golang-migrate хранит версию и берёт advisory lock); `api` зависит от него через `service_completed_successfully`, поэтому реплики не гоняются за схему. DSN читается из secret, пароль не хранится в compose.yaml (в lab2 был захардкожен — исправлено). +4. **Graceful shutdown**: по SIGTERM `/health/ready` сразу отвечает 503, процесс продолжает обслуживать запросы `DRAIN_DELAY=3s` (HAProxy за это время исключает его: inter 1s × fall 2), затем `http.Server.Shutdown` с `SHUTDOWN_TIMEOUT=8s`. `stop_grace_period: 15s` > 3 + 8, поэтому SIGKILL не обрывает запросы. +5. **LB HAProxy**: `server-template api 8 api:8080` + `resolvers docker` (127.0.0.11) — новые/пересозданные реплики подхватываются без перезапуска LB; `retry-on conn-failure` + `option redispatch` — повтор только когда запрос ещё не отправлен, поэтому неидемпотентные POST /users и /chats не дублируются. Sticky sessions нет: состояние общее. +6. **Ресурсы** (переопределяются переменными для трека 1): api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M. Сети: `front` (lb↔api) и `back` (api↔хранилища) — LB не видит БД. + +**Критичные зависимости readiness:** PostgreSQL и Redis (сессии нужны каждому защищённому запросу) + флаг drain. `/health/live` — только жизнь процесса. + +**Тайминги обнаружения отказа:** +| Механизм | Параметры | Максимальное время | +| --- | --- | --- | +| Graceful stop (SIGTERM) | readiness 503 → inter 1s, fall 2 | ≈2 s, всё это время реплика ещё обслуживает запросы → ошибок нет | +| Падение процесса (kill) | conn refused → `retry-on conn-failure`, redispatch; check fall 2 | запросы перенаправляются сразу; из пула ≈2 s | +| Зависание без ответа | timeout server 15s, check timeout = inter | ≈2 s до исключения; запросы в полёте получат 504 | + +**Соответствие .env.example:** APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/IDEMPOTENCY_TTL_SECONDS — как есть; DATABASE_URL_FILE и CACHE_URL_FILE — docker secrets `/run/secrets/*`; SESSION_STORE=redis (сессии в Redis с lab2); API_REPLICAS → `deploy.replicas`; DRAIN_DELAY/SHUTDOWN_TIMEOUT — добавлены. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +### Что уже проверено -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Docker Desktop на машине разработки не запускает движок (`backend state: hasNoVirtualization=true` — выключена аппаратная виртуализация / нет WSL2), поэтому логика приложения проверена **нативно**: PostgreSQL 17 (initdb), fakeredis (TCP) вместо Redis, 2 процесса API с разными `INSTANCE_ID` за временным round-robin прокси (заменитель HAProxy только для этой проверки). Это доказывает корректность кода, но **не** инфраструктуры Compose/HAProxy. + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| Публичный smoke | tests/smoke.py | PASS: lab3 public API scenario | evidence/local_native_check.txt | +| Негативные проверки lab2 | tests/negative.py | PASS | evidence/local_native_check.txt | +| Отказ реплики, ≥2 реплик до отказа | tests/resilience.py --mode failover | PASS, observed 2, 21 успешных записей, 7 ошибок переходного периода, первая запись после hook за 3.7 s, дублей нет | evidence/local_native_check.txt | +| Конкурентный повтор одного ключа через разные реплики | tests/idempotency_concurrent.py (10 раундов × 16 параллельно) | PASS: 160/160 → 201 с одинаковым Message, 1 сообщение на ключ, 2 реплики, 409 на другой body, ключ изолирован по чату/пользователю, посторонний — 404 | evidence/idempotency_concurrent_native.json | +| compose.yaml корректен | docker compose --env-file .env config --quiet | OK; 2 реплики, лимиты, опубликован только lb | — | + +### На Docker-стенде (заполнить после `sh scripts/collect-evidence.sh`) + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| ≥2 X-Instance-Id через LB с одной сессией | collect-evidence: instances + make test-failover | TODO | evidence/instances.txt | +| Публичный smoke | make test | TODO | evidence/smoke.txt | +| Отказ любой одной реплики ≤10 s | make test-failover ×2 + restore | TODO | evidence/failover_1.txt, failover_2.txt | +| Persistence с прежним токеном | make test-persistence ACTION_SCRIPT=scripts/restart.sh | TODO | evidence/persistence.txt | +| Идемпотентность параллельно | make test-idempotency | TODO | evidence/idempotency_concurrent.json | +| 4: поочерёдный отказ каждой реплики, RPS/ошибки/восстановление | make test-failover-series | TODO | evidence/failover_series.json | +| 4: rolling update под нагрузкой | scripts/rolling-update.sh + tests/load.py | TODO | evidence/rolling_update*.{txt,json} | +| 4: лимиты, нет портов api, нет container_name | docker compose config, docker compose ps | TODO | evidence/docker_ps.txt | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Методика (уровень 4), `tests/failover_series.py`: closed-loop нагрузка 4 потока через LB (POST сообщения с повтором того же ключа после неопределённого ответа + GET истории), прогрев 5 s; для каждой реплики по очереди `docker stop -t 15` → наблюдение 15 s → `docker start` → ожидание healthy и появления в ответах LB → 3 s паузы. Метрики: успешные RPS до/во время, число ошибок, время от начала остановки до последней ошибки, время, когда остановленная реплика последний раз ответила, время восстановления. В конце — полная история: нет дублей текста и ID, все подтверждённые сообщения на месте. + +Rolling update (`scripts/rolling-update.sh`): build → migrate → для каждой старой реплики `up --scale api=N+1 --no-recreate` → ждать healthy → `docker stop` старой (drain) → `rm`. Во время замены 60 s нагрузки `tests/load.py`. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| kill одного процесса API (нативно) | краткие ошибки, затем запись через вторую реплику | 7 ошибок, PASS | первая запись 3.7 s; потерь/дублей нет | +| docker stop реплики 1 под нагрузкой | 0–единицы ошибок благодаря drain | TODO | TODO | +| docker stop реплики 2 под нагрузкой | то же | TODO | TODO | +| rolling update | 0 ошибок | TODO | TODO | +| restart всего стенда | сессия и данные сохранены | TODO | TODO | + +## Трек 5.1: цена масштабирования + +### Вопрос и гипотезы + +Помогает ли добавление API-реплик, где точка насыщения стенда и почему рост реплик перестаёт помогать? Гипотезы записаны **до** измерений в [experiments/track1.json](experiments/track1.json): + +| Серия | Что меняем | Гипотеза | +| --- | --- | --- | +| A_fixed_total | 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU, 768M) | пиковый RPS не растёт (тот же бюджет), p95 немного хуже из-за накладных расходов процессов и пулов; выигрыш реплик — только отказоустойчивость | +| B_scale_out | 1/2/4/8 реплик по 0.5 CPU, БД 1.0, LB 0.5, Redis 0.5 | рост почти линейный, пока узкое место — CPU API; затем остановка на общей зависимости | +| C_shared_resources | 4×0.5 API; PG 1→2 CPU, LB 0.5→1, Redis 0.5→1 | RPS поднимает только рост ресурса той зависимости, которая насыщена в B | +| D_improvement | 4×0.5 API: baseline vs 3 кандидата | инвалидация кэша через SCAN (наследие lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (`CACHE_INVALIDATION=version`, 1 INCR) поднимает RPS. Альтернативы: `DB_POOL_MAX=8`, `LB_BALANCE=leastconn` | + +### Методика (повторяемая) + +- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080, свои volumes) — рабочие данные стенда не трогаются. Конфигурация задаётся только переменными окружения compose (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`); образ API один и тот же. +- Нагрузка — [cmd/bench](cmd/bench/main.go) (Go, closed-loop): 50% POST сообщения с уникальным Idempotency-Key, 50% GET истории `limit=50`; 8 чатов × 2 участника; без повторов; таймаут 5 s. Уровни параллелизма 1/4/8/16/32/64, прогрев 5 s, измерение 30 s, 3 повтора (серия D: 16/32/64, 5 повторов). Поддерживается и open-loop (`-rate`) с отсчётом задержки от запланированного момента (поправка на coordinated omission). +- Фоновый keyspace Redis — 10 000 синтетических ключей `pad:*` (≈ активные сессии и прочие данные). Это параметр профиля: от него зависит цена SCAN. +- Во время каждого прогона ~1 раз в секунду: `docker stats` всех контейнеров (CPU нормируется на лимит роли) и `pg_stat_activity` (активные соединения); до/после — счётчики пула pgx каждой реплики (внутренний порт 9090, не публикуется и не проксируется LB, читается через `docker exec`). +- Правила анализа фиксированы в [scripts/track1_report.py](scripts/track1_report.py): медиана по повторам; насыщение — первый уровень, где RPS вырос < 10%; узкое место — роль с максимальной утилизацией CPU от лимита (≥ 0.85 — насыщена) + доля ожиданий пула; улучшение **подтверждено**, только если на уровнях ≥ точки насыщения min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже и ошибок не больше. + +Запуск (Docker-стенд должен работать; основной стенд лучше остановить, чтобы не делить CPU): + +```sh +make track1-quick PYTHON=python # ~15 мин, 1 повтор — проверка, что всё работает +make track1 PYTHON=python # полная методика (~2–3 ч), продолжает после обрыва (--resume) +# Результаты: evidence/track1/raw.jsonl (сырые данные), summary.csv, summary.md, report.html (графики) +python scripts/track1.py --cleanup --series none # удалить bench-проект и его volumes +``` + +Перед прогоном зафиксировать в этом разделе: CPU/RAM хоста и лимиты Docker Desktop (скрипт пишет их в каждую строку raw.jsonl), версии образов. + +### Проверка инструментов (без Docker) + +Нативно (PostgreSQL 17, fakeredis, 2 процесса API в режимах `scan` и `version`, round-robin прокси) проверено: smoke и конкурентная идемпотентность проходят в обоих режимах кэша; `bin/bench` выдаёт корректную смесь (≈50/50) и распределение по репликам; `/internal/stats` отдаёт счётчики пула; `track1_report.py` строит таблицы, графики и вердикт по синтетическому файлу (не сохранён в evidence — это не результат). **Реальных измерений трека пока нет.** + +### Результаты + +TODO после `make track1`: перенести из evidence/track1/summary.md таблицы по сериям, графики из report.html и выводы: + +| Серия | Наблюдение | Узкое место (утилизация) | Вывод | +| --- | --- | --- | --- | +| A_fixed_total | TODO | TODO | TODO | +| B_scale_out | TODO | TODO | TODO: с какого N рост прекращается и почему | +| C_shared_resources | TODO | TODO | TODO: какой ресурс снимает насыщение | +| D_improvement | TODO | TODO | TODO: какое улучшение подтверждено (или ни одно) | + +### Ограничения трека + +- Один хост: генератор нагрузки, LB, API и БД делят физические ядра; лимиты Docker — это квоты CFS, а не выделенные ядра. Если пик упирается в CPU клиента, это видно по CPU хоста, и вывод о стенде делать нельзя. +- Closed-loop показывает пропускную способность при заданном параллелизме, но не задержку при фиксированной входящей нагрузке; для отдельных точек можно повторить с `-rate`. +- История растёт во время серии; GET читает первые 50 сообщений чата по индексу, поэтому стоимость чтения от объёма почти не зависит, но размер таблиц растёт. +- Утилизация из `docker stats` усредняется с шагом ~1–2 s; короткие всплески не видны. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Выдерживается отказ одной API-реплики (процесс/контейнер). Не выдерживается: отказ LB, PostgreSQL, Redis, хоста — это SPOF (один узел, БД не реплицирована). +- Миграции совместимы с работающей версией только при подходе expand→contract; `0002` только добавляет таблицу, поэтому старые реплики продолжают работать во время rolling update. Деструктивные миграции так применять нельзя. +- Idempotency-ключи хранятся в PostgreSQL рядом с сообщением — атомарность без распределённых транзакций, ценой одной лишней записи на POST. +- Ошибки, сгенерированные самим HAProxy (502/503/504), не содержат X-Instance-Id — это допускается контрактом. +- Результаты Docker-стенда (таблицы TODO выше) ещё не получены из-за отсутствия виртуализации на машине разработки; после включения VT-x/WSL2 — запустить `sh scripts/collect-evidence.sh` и заполнить таблицы. diff --git a/cmd/api/main.go b/cmd/api/main.go new file mode 100644 index 0000000..14b53ed --- /dev/null +++ b/cmd/api/main.go @@ -0,0 +1,151 @@ +package main + +import ( + "context" + "errors" + "log/slog" + "net/http" + "os" + "os/signal" + "sync/atomic" + "syscall" + "time" + + "github.com/charawein/mtusi2026lab3/internal/config" + "github.com/charawein/mtusi2026lab3/internal/repository/postgres" + redisrepo "github.com/charawein/mtusi2026lab3/internal/repository/redis" + "github.com/charawein/mtusi2026lab3/internal/service" + transporthttp "github.com/charawein/mtusi2026lab3/internal/transport/http" +) + +func main() { + cfg := config.Load() + logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel})) + slog.SetDefault(logger) + + if cfg.DatabaseURL == "" { + slog.Error("DATABASE_URL_FILE is not set or empty") + os.Exit(1) + } + if cfg.CacheURL == "" { + slog.Error("CACHE_URL_FILE is not set or empty") + os.Exit(1) + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, cfg.DBPoolMax) + cancel() + if err != nil { + slog.Error("connect to postgres", "err", err) + os.Exit(1) + } + defer pool.Close() + + rctx, rcancel := context.WithTimeout(context.Background(), 10*time.Second) + redisClient, err := redisrepo.NewClient(rctx, cfg.CacheURL) + rcancel() + if err != nil { + slog.Error("connect to redis", "err", err) + os.Exit(1) + } + defer redisClient.Close() + + userRepo := postgres.NewUserRepository(pool) + chatRepo := postgres.NewChatRepository(pool) + msgRepo := postgres.NewMessageRepository(pool) + sessRepo := redisrepo.NewSessionRepository(redisClient) + + userSvc := service.NewUserService(userRepo) + chatSvc := service.NewChatService(chatRepo, userRepo) + + var msgCache *redisrepo.MessageCache + if cfg.CacheEnabled { + msgCache = redisrepo.NewMessageCache(redisClient, cfg.CacheInvalidation) + } + msgSvc := service.NewMessageService(msgRepo, chatRepo, msgCache, cfg.IdempotencyTTL) + + authSvc := service.NewAuthService(userRepo, sessRepo, cfg.SessionTTL()) + + // draining выставляется по SIGTERM: /health/ready начинает отвечать 503, + // LB исключает реплику, и только затем закрывается listener. + var draining atomic.Bool + router := transporthttp.NewRouter(userSvc, chatSvc, msgSvc, authSvc, pool, redisClient, cfg.InstanceID, &draining) + + // Очистка просроченных ключей идемпотентности. Запрос идемпотентен, + // поэтому параллельный запуск на всех репликах безопасен. + cleanupCtx, cleanupStop := context.WithCancel(context.Background()) + defer cleanupStop() + go func() { + t := time.NewTicker(time.Hour) + defer t.Stop() + for { + select { + case <-cleanupCtx.Done(): + return + case <-t.C: + ctx, cancel := context.WithTimeout(cleanupCtx, 30*time.Second) + if n, err := msgRepo.DeleteExpiredKeys(ctx, cfg.IdempotencyTTL); err != nil { + slog.Warn("idempotency cleanup failed", "err", err) + } else if n > 0 { + slog.Info("idempotency keys expired", "deleted", n) + } + cancel() + } + } + }() + + srv := &http.Server{ + Addr: cfg.Addr(), + Handler: router, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + // Внутренний endpoint метрик для экспериментов (трек 1). Порт не публикуется + // и не проксируется LB: читается только через docker exec внутри контейнера. + internalSrv := &http.Server{ + Addr: cfg.InternalAddr, + Handler: transporthttp.NewInternalStatsHandler(pool, cfg), + ReadHeaderTimeout: 2 * time.Second, + } + go func() { + if err := internalSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + slog.Warn("internal stats server failed", "err", err) + } + }() + defer internalSrv.Close() + + errCh := make(chan error, 1) + go func() { + slog.Info("server starting", "addr", cfg.Addr(), "instance_id", cfg.InstanceID) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- err + } + }() + + sigCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) + defer stop() + + select { + case err := <-errCh: + slog.Error("server failed", "err", err) + os.Exit(1) + case <-sigCtx.Done(): + slog.Info("shutdown signal received, draining", "delay", cfg.DrainDelay) + } + + // Перестаём быть ready и даём LB время заметить это (inter*fall у HAProxy), + // продолжая обслуживать уже направленные к нам запросы. + draining.Store(true) + time.Sleep(cfg.DrainDelay) + + shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout) + defer cancel() + if err := srv.Shutdown(shutdownCtx); err != nil { + slog.Error("graceful shutdown failed", "err", err) + os.Exit(1) + } + slog.Info("server stopped") +} diff --git a/cmd/bench/main.go b/cmd/bench/main.go new file mode 100644 index 0000000..71212ea --- /dev/null +++ b/cmd/bench/main.go @@ -0,0 +1,328 @@ +// Command bench — генератор нагрузки для трека 1 (цена масштабирования). +// +// Профиль: смесь POST сообщения (с Idempotency-Key) и GET истории (limit=50) +// по нескольким чатам; каждый запрос идёт через LB с Bearer-токеном. +// +// Режимы: +// - closed loop (-concurrency N): N воркеров, каждый ждёт ответ перед следующим +// запросом. Показывает пропускную способность при фиксированном параллелизме. +// - open loop (-rate R): запросы назначаются по расписанию R/s независимо от +// ответов; задержка считается от НАЗНАЧЕННОГО момента, поэтому ожидание в +// очереди клиента входит в latency (поправка на coordinated omission). +// +// Повторов нет: ошибка/timeout учитывается как ошибка. Токены не печатаются. +package main + +import ( + "bytes" + "crypto/rand" + "encoding/base64" + "encoding/hex" + "encoding/json" + "flag" + "fmt" + "io" + "math" + mrand "math/rand/v2" + "net" + "net/http" + "os" + "sort" + "sync" + "sync/atomic" + "time" +) + +type actor struct { + token string + chat string +} + +type sample struct { + write bool + ok bool + latency time.Duration + class string +} + +type result struct { + mu sync.Mutex + samples []sample + instances map[string]int + dropped atomic.Int64 +} + +func (r *result) add(s sample, instance string) { + r.mu.Lock() + r.samples = append(r.samples, s) + if instance != "" { + r.instances[instance]++ + } + r.mu.Unlock() +} + +func randHex(n int) string { + b := make([]byte, n) + _, _ = rand.Read(b) + return hex.EncodeToString(b) +} + +func main() { + base := flag.String("base-url", "http://localhost:8080", "LB URL") + duration := flag.Duration("duration", 30*time.Second, "measured duration") + warmup := flag.Duration("warmup", 5*time.Second, "warmup (not measured)") + concurrency := flag.Int("concurrency", 8, "closed-loop workers (ignored when -rate > 0)") + rate := flag.Float64("rate", 0, "open-loop arrival rate, req/s (0 = closed loop)") + maxInflight := flag.Int("max-inflight", 512, "open-loop: max concurrent requests; excess arrivals are dropped and counted") + writeRatio := flag.Float64("write-ratio", 0.5, "fraction of POST message") + chats := flag.Int("chats", 8, "number of chats/users") + timeout := flag.Duration("timeout", 5*time.Second, "per-request timeout") + label := flag.String("label", "", "free-form label copied to output") + out := flag.String("output", "", "append JSON line to file") + flag.Parse() + + transport := &http.Transport{ + MaxIdleConns: 2048, + MaxIdleConnsPerHost: 2048, + IdleConnTimeout: 30 * time.Second, + DialContext: (&net.Dialer{Timeout: 2 * time.Second}).DialContext, + } + client := &http.Client{Transport: transport, Timeout: *timeout} + + actors, err := setup(client, *base, *chats) + if err != nil { + fmt.Fprintln(os.Stderr, "setup failed:", err) + os.Exit(1) + } + + res := &result{instances: map[string]int{}} + var measuring atomic.Bool + var seq atomic.Int64 + + do := func(scheduled time.Time) { + n := seq.Add(1) + a := actors[int(n)%len(actors)] + // Независимо от выбора actor: иначе при чётном числе actor и 0.5 одни бы только писали. + write := mrand.Float64() < *writeRatio + var req *http.Request + if write { + body, _ := json.Marshal(map[string]string{"text": "bench " + randHex(8)}) + req, _ = http.NewRequest("POST", *base+"/api/v1/chats/"+a.chat+"/messages", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Idempotency-Key", randHex(16)) + } else { + req, _ = http.NewRequest("GET", *base+"/api/v1/chats/"+a.chat+"/messages?limit=50", nil) + } + req.Header.Set("Authorization", "Bearer "+a.token) + resp, err := client.Do(req) + lat := time.Since(scheduled) + s := sample{write: write, latency: lat} + inst := "" + switch { + case err != nil: + s.class = "transport" + if e, ok := err.(net.Error); ok && e.Timeout() { + s.class = "timeout" + } + default: + _, _ = io.Copy(io.Discard, resp.Body) + resp.Body.Close() + inst = resp.Header.Get("X-Instance-Id") + want := http.StatusOK + if write { + want = http.StatusCreated + } + s.ok = resp.StatusCode == want + if !s.ok { + s.class = fmt.Sprintf("http_%d", resp.StatusCode) + } + } + if measuring.Load() { + res.add(s, inst) + } + } + + start := time.Now() + measureStart := start.Add(*warmup) + end := measureStart.Add(*duration) + go func() { + time.Sleep(time.Until(measureStart)) + measuring.Store(true) + time.Sleep(time.Until(end)) + measuring.Store(false) + }() + + var wg sync.WaitGroup + if *rate > 0 { + sem := make(chan struct{}, *maxInflight) + interval := time.Duration(float64(time.Second) / *rate) + next := time.Now() + for next.Before(end) { + if d := time.Until(next); d > 0 { + time.Sleep(d) + } + scheduled := next + next = next.Add(interval) + select { + case sem <- struct{}{}: + wg.Add(1) + go func() { + defer wg.Done() + defer func() { <-sem }() + do(scheduled) + }() + default: + if measuring.Load() { + res.dropped.Add(1) + } + } + } + } else { + for i := 0; i < *concurrency; i++ { + wg.Add(1) + go func() { + defer wg.Done() + for time.Now().Before(end) { + do(time.Now()) + } + }() + } + } + wg.Wait() + + report := summarize(res, *duration) + report["label"] = *label + report["mode"] = map[bool]string{true: "open", false: "closed"}[*rate > 0] + report["concurrency"] = *concurrency + report["rate"] = *rate + report["write_ratio"] = *writeRatio + report["chats"] = *chats + report["duration_s"] = duration.Seconds() + report["warmup_s"] = warmup.Seconds() + report["timestamp"] = time.Now().UTC().Format(time.RFC3339) + line, _ := json.Marshal(report) + fmt.Println(string(line)) + if *out != "" { + f, err := os.OpenFile(*out, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644) + if err == nil { + _, _ = f.Write(append(line, '\n')) + f.Close() + } + } +} + +func percentiles(lat []time.Duration) map[string]float64 { + if len(lat) == 0 { + return map[string]float64{"p50": 0, "p95": 0, "p99": 0, "max": 0} + } + sort.Slice(lat, func(i, j int) bool { return lat[i] < lat[j] }) + p := func(q float64) float64 { + i := int(math.Ceil(q*float64(len(lat)))) - 1 + if i < 0 { + i = 0 + } + return float64(lat[i].Microseconds()) / 1000 + } + return map[string]float64{"p50": p(.50), "p95": p(.95), "p99": p(.99), "max": float64(lat[len(lat)-1].Microseconds()) / 1000} +} + +func summarize(r *result, d time.Duration) map[string]any { + var all, w, rd []time.Duration + errs := map[string]int{} + ok, okW, okR := 0, 0, 0 + for _, s := range r.samples { + if !s.ok { + errs[s.class]++ + continue + } + ok++ + all = append(all, s.latency) + if s.write { + okW++ + w = append(w, s.latency) + } else { + okR++ + rd = append(rd, s.latency) + } + } + total := len(r.samples) + errN := total - ok + return map[string]any{ + "requests": total, + "ok": ok, + "errors": errN, + "error_ratio": ratio(errN, total), + "errors_by_class": errs, + "dropped": r.dropped.Load(), + "ok_rps": float64(ok) / d.Seconds(), + "ok_write_rps": float64(okW) / d.Seconds(), + "ok_read_rps": float64(okR) / d.Seconds(), + "latency_ms": percentiles(all), + "write_ms": percentiles(w), + "read_ms": percentiles(rd), + "instances": r.instances, + } +} + +func ratio(a, b int) float64 { + if b == 0 { + return 0 + } + return float64(a) / float64(b) +} + +// setup создаёт пары пользователей, сессии и по одному чату на пару. +func setup(c *http.Client, base string, n int) ([]actor, error) { + post := func(path string, body any, hdr map[string]string) (map[string]any, error) { + var rdr io.Reader + if body != nil { + raw, _ := json.Marshal(body) + rdr = bytes.NewReader(raw) + } + req, _ := http.NewRequest("POST", base+path, rdr) + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + for k, v := range hdr { + req.Header.Set(k, v) + } + resp, err := c.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusCreated { + return nil, fmt.Errorf("POST %s: status %d", path, resp.StatusCode) + } + var m map[string]any + return m, json.NewDecoder(resp.Body).Decode(&m) + } + var actors []actor + for i := 0; i < n; i++ { + var ids [2]string + var tokens [2]string + for j := 0; j < 2; j++ { + name := "bench_" + randHex(6) + pw := "Bench-" + randHex(12) + u, err := post("/api/v1/users", map[string]string{"username": name, "display_name": "Bench", "password": pw}, nil) + if err != nil { + return nil, err + } + ids[j] = u["id"].(string) + cred := base64.StdEncoding.EncodeToString([]byte(name + ":" + pw)) + s, err := post("/api/v1/auth/sessions", nil, map[string]string{"Authorization": "Basic " + cred}) + if err != nil { + return nil, err + } + tokens[j] = s["token"].(string) + } + ch, err := post("/api/v1/chats", map[string]any{"title": "bench", "member_ids": []string{ids[0], ids[1]}}, + map[string]string{"Authorization": "Bearer " + tokens[0]}) + if err != nil { + return nil, err + } + chat := ch["id"].(string) + actors = append(actors, actor{token: tokens[0], chat: chat}, actor{token: tokens[1], chat: chat}) + } + return actors, nil +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..41db643 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,131 @@ +# Lab3: клиент → HAProxy → API × N → общие PostgreSQL (данные, идемпотентность) и Redis (сессии, кэш). +# Запуск: scripts/init-secrets.sh && docker compose --env-file .env up -d --build --wait +name: mtusi2026lab3 + +x-api-env: &api-env + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: ${APP_PORT:-8080} + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-redis} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DRAIN_DELAY: ${DRAIN_DELAY:-3s} + SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8s} + DB_POOL_MAX: ${DB_POOL_MAX:-20} + CACHE_INVALIDATION: ${CACHE_INVALIDATION:-version} + +services: + lb: + image: haproxy:3.0.5-alpine + ports: + - "127.0.0.1:${LB_PORT:-8080}:8080" + - "127.0.0.1:${LB_STATS_PORT:-8404}:8404" + environment: + LB_BALANCE: ${LB_BALANCE:-roundrobin} + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + depends_on: + api: + condition: service_healthy + restart: unless-stopped + networks: [front] + deploy: + resources: + limits: { cpus: "${LB_CPUS:-0.50}", memory: 128M } + + api: + build: . + image: mtusi2026lab3-api:local + # Без container_name и без ports: реплики доступны только через lb. + environment: *api-env + secrets: [database_url, cache_url] + depends_on: + migrate: + condition: service_completed_successfully + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/ready"] + interval: 5s + timeout: 2s + retries: 3 + start_period: 5s + # DRAIN_DELAY + SHUTDOWN_TIMEOUT < stop_grace_period, иначе SIGKILL оборвёт запросы. + stop_grace_period: 15s + restart: unless-stopped + networks: [front, back] + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: { cpus: "${API_CPUS:-0.50}", memory: "${API_MEMORY:-256M}" } + + # Однократные миграции до старта API: реплики не гоняются за схему. + migrate: + image: migrate/migrate:v4.17.0 + volumes: + - ./migrations:/migrations:ro + secrets: [database_url] + entrypoint: ["/bin/sh", "-c", "exec migrate -path /migrations -database \"$$(cat /run/secrets/database_url)\" up"] + depends_on: + postgres: + condition: service_healthy + restart: "no" + networks: [back] + + postgres: + image: postgres:16.4-alpine + command: ["postgres", "-c", "max_connections=${PG_MAX_CONNECTIONS:-100}"] + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + secrets: [postgres_password] + volumes: + - pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + networks: [back] + deploy: + resources: + limits: { cpus: "${PG_CPUS:-1.00}", memory: "${PG_MEMORY:-512M}" } + + redis: + image: redis:7.4.1-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + networks: [back] + deploy: + resources: + limits: { cpus: "${REDIS_CPUS:-0.50}", memory: 256M } + +networks: + # front: lb ↔ api; back: api ↔ хранилища. LB не видит БД. + front: + back: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + +volumes: + pg_data: + redis_data: diff --git a/evidence/idempotency_concurrent_native.json b/evidence/idempotency_concurrent_native.json new file mode 100644 index 0000000..0d31054 --- /dev/null +++ b/evidence/idempotency_concurrent_native.json @@ -0,0 +1,88 @@ +{ + "rounds": 10, + "parallel_per_round": 16, + "distinct_instances_seen": 2, + "duplicates_found": 0, + "per_round": [ + { + "round": 0, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 1, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 2, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 3, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 4, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 5, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 6, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 7, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 8, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 9, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + } + ] +} diff --git a/evidence/local_native_check.txt b/evidence/local_native_check.txt new file mode 100644 index 0000000..46f8a16 --- /dev/null +++ b/evidence/local_native_check.txt @@ -0,0 +1,15 @@ +# Нативная проверка логики приложения (НЕ Docker-стенд) +# Дата: 2026-10-23T08:43Z; Windows 10, Go go1.26.0, PostgreSQL 17 (локальный initdb), fakeredis 2.40 (TCP) вместо Redis, +# 2 процесса API (INSTANCE_ID=local-8081/local-8082) за временным round-robin прокси на Python (заменитель HAProxy только для этой проверки). +# Причина: Docker Desktop на машине разработки не стартует (backend state: hasNoVirtualization=true). + +$ python tests/smoke.py +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. + +$ python tests/negative.py +PASS: negative checks + +$ python tests/resilience.py --mode failover (hook: kill процесса TARGET_INSTANCE_ID) +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 21, "failed_attempts": 7, "first_recovery_seconds": 3.719} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/experiments/track1.json b/experiments/track1.json new file mode 100644 index 0000000..7ac811d --- /dev/null +++ b/experiments/track1.json @@ -0,0 +1,72 @@ +{ + "description": "Трек 1: цена масштабирования. Профиль: closed-loop, 50% POST сообщения / 50% GET истории limit=50, 8 чатов по 2 участника, без повторов. Отдельный compose-проект mtusi2026lab3-bench на порту 18080 — рабочие данные стенда не трогаются.", + "project": "mtusi2026lab3-bench", + "lb_port": 18080, + "base_env": { + "PG_CPUS": "1.00", + "PG_MEMORY": "512M", + "PG_MAX_CONNECTIONS": "200", + "LB_CPUS": "0.50", + "REDIS_CPUS": "0.50", + "DB_POOL_MAX": "20", + "CACHE_INVALIDATION": "scan", + "LB_BALANCE": "roundrobin", + "SESSION_TTL_SECONDS": "86400" + }, + "redis_padding_keys": 10000, + "load": { + "levels": [1, 4, 8, 16, 32, 64], + "duration": "30s", + "warmup": "5s", + "write_ratio": 0.5, + "chats": 8, + "repeats": 3 + }, + "series": [ + { + "name": "A_fixed_total", + "title": "Фиксированный суммарный бюджет API: 1.0 CPU / 768M", + "hypothesis": "При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.", + "configs": [ + {"label": "1x1.00", "API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M"}, + {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M"}, + {"label": "4x0.25", "API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M"} + ] + }, + { + "name": "B_scale_out", + "title": "Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU", + "hypothesis": "Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.", + "configs": [ + {"label": "1x0.50", "API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "4x0.50", "API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "8x0.50", "API_REPLICAS": "8", "API_CPUS": "0.50", "API_MEMORY": "256M"} + ] + }, + { + "name": "C_shared_resources", + "title": "4×0.5 CPU API, меняем ресурсы общих зависимостей", + "hypothesis": "Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.", + "configs": [ + {"label": "pg1_lb0.5_redis0.5", "API_REPLICAS": "4", "API_CPUS": "0.50"}, + {"label": "pg2", "API_REPLICAS": "4", "API_CPUS": "0.50", "PG_CPUS": "2.00"}, + {"label": "lb1", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_CPUS": "1.00"}, + {"label": "redis1", "API_REPLICAS": "4", "API_CPUS": "0.50", "REDIS_CPUS": "1.00"} + ] + }, + { + "name": "D_improvement", + "title": "Кандидаты улучшения на 4×0.5 CPU", + "hypothesis": "Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.", + "levels": [16, 32, 64], + "repeats": 5, + "configs": [ + {"label": "baseline_scan", "API_REPLICAS": "4", "API_CPUS": "0.50"}, + {"label": "cache_version", "API_REPLICAS": "4", "API_CPUS": "0.50", "CACHE_INVALIDATION": "version"}, + {"label": "pool_8", "API_REPLICAS": "4", "API_CPUS": "0.50", "DB_POOL_MAX": "8"}, + {"label": "leastconn", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_BALANCE": "leastconn"} + ] + } + ] +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..335dbf9 --- /dev/null +++ b/go.mod @@ -0,0 +1,21 @@ +module github.com/charawein/mtusi2026lab3 + +go 1.26.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.11.0 + github.com/redis/go-redis/v9 v9.23.0 + golang.org/x/crypto v0.58.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + go.uber.org/atomic v1.12.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/text v0.43.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..3f1c785 --- /dev/null +++ b/go.sum @@ -0,0 +1,43 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= +github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 0000000..05fa5e6 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,59 @@ +# HAProxy — единственная публичная точка входа (lab3). +# Backend-адреса берутся из встроенного DNS Docker (service name "api"), +# поэтому масштабирование/пересоздание реплик не требует перезапуска LB. + +global + log stdout format raw local0 info + maxconn 2048 + +defaults + mode http + log global + option httplog + option dontlognull + timeout connect 2s + timeout client 30s + timeout server 15s + timeout http-request 10s + timeout queue 5s + # Повтор только при ошибке установки соединения (запрос ещё не отправлен), + # поэтому неидемпотентные POST /users, /chats не дублируются. + retries 2 + retry-on conn-failure + option redispatch 1 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + # Как долго держать последний ответ DNS при ошибке/пропаже записи. + hold valid 5s + hold other 5s + hold refused 5s + hold nx 2s + hold timeout 5s + hold obsolete 2s + accepted_payload_size 8192 + +frontend public + bind :8080 + default_backend api + +backend api + # roundrobin по умолчанию; leastconn — вариант для эксперимента трека 1 (env LB_BALANCE). + balance "${LB_BALANCE}" + # Активная проверка готовности: 503 во время drain или без БД/Redis. + option httpchk + http-check send meth GET uri /health/ready + http-check expect status 200 + # Период проверки 1s, исключение после 2 неудач (~2s), возврат после 2 успехов. + default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none + # До 8 слотов под реплики сервиса api; лишние слоты остаются в MAINT. + server-template api 8 api:8080 + +frontend stats + bind :8404 + stats enable + stats uri /stats + stats refresh 2s diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 0000000..0c28cfb --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,113 @@ +package config + +import ( + "log/slog" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Host string + Port string + Env string + SessionTTLSeconds int + DatabaseURL string + CacheURL string + SessionStore string + LogLevel slog.Level + ShutdownTimeout time.Duration + CacheEnabled bool + InstanceID string + IdempotencyTTL time.Duration + DrainDelay time.Duration + DBPoolMax int32 + CacheInvalidation string + InternalAddr string +} + +func Load() Config { + return Config{ + Host: getEnv("APP_HOST", "0.0.0.0"), + Port: getEnv("APP_PORT", "8080"), + Env: getEnv("APP_ENV", "lab"), + SessionTTLSeconds: getInt("SESSION_TTL_SECONDS", 3600), + DatabaseURL: readSecretFile("DATABASE_URL_FILE"), + CacheURL: readSecretFile("CACHE_URL_FILE"), + SessionStore: getEnv("SESSION_STORE", "postgres"), + LogLevel: parseLevel(getEnv("LOG_LEVEL", "info")), + ShutdownTimeout: parseDuration(getEnv("SHUTDOWN_TIMEOUT", "8s")), + CacheEnabled: getEnv("CACHE_ENABLED", "true") == "true", + InstanceID: instanceID(), + IdempotencyTTL: time.Duration(getInt("IDEMPOTENCY_TTL_SECONDS", 86400)) * time.Second, + DrainDelay: parseDuration(getEnv("DRAIN_DELAY", "3s")), + DBPoolMax: int32(max(1, getInt("DB_POOL_MAX", 20))), + CacheInvalidation: getEnv("CACHE_INVALIDATION", "version"), + InternalAddr: getEnv("INTERNAL_ADDR", ":9090"), + } +} + +// instanceID — идентификатор реплики для X-Instance-Id. По умолчанию hostname, +// который в Docker равен короткому ID контейнера: так stop-one.sh однозначно +// находит контейнер. В lab7 его заменит непрозрачный alias. +func instanceID() string { + if v := os.Getenv("INSTANCE_ID"); v != "" { + return v + } + if h, err := os.Hostname(); err == nil && h != "" { + return h + } + return "unknown" +} + +func (c Config) SessionTTL() time.Duration { + return time.Duration(c.SessionTTLSeconds) * time.Second +} + +func (c Config) Addr() string { return c.Host + ":" + c.Port } + +func getEnv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func getInt(key string, def int) int { + if v := os.Getenv(key); v != "" { + if n, err := strconv.Atoi(v); err == nil { + return n + } + } + return def +} + +func readSecretFile(envKey string) string { + path := os.Getenv(envKey) + if path == "" { + return "" + } + b, err := os.ReadFile(path) + if err != nil { + slog.Warn("secret file not readable", "path", path, "err", err) + return "" + } + return strings.TrimSpace(string(b)) +} + +func parseLevel(s string) slog.Level { + var l slog.Level + if err := l.UnmarshalText([]byte(s)); err != nil { + return slog.LevelInfo + } + return l +} + +func parseDuration(s string) time.Duration { + d, err := time.ParseDuration(s) + if err != nil { + return 8 * time.Second + } + return d +} diff --git a/internal/domain/chat.go b/internal/domain/chat.go new file mode 100644 index 0000000..5307e69 --- /dev/null +++ b/internal/domain/chat.go @@ -0,0 +1,30 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +func (c Chat) MarshalJSON() ([]byte, error) { + type Alias Chat + members := c.MemberIDs + if members == nil { + members = []string{} + } + return json.Marshal(&struct { + Alias + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(c), + MemberIDs: members, + CreatedAt: c.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/message.go b/internal/domain/message.go new file mode 100644 index 0000000..08099f4 --- /dev/null +++ b/internal/domain/message.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +func (m Message) MarshalJSON() ([]byte, error) { + type Alias Message + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(m), + CreatedAt: m.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/session.go b/internal/domain/session.go new file mode 100644 index 0000000..2a42b94 --- /dev/null +++ b/internal/domain/session.go @@ -0,0 +1,10 @@ +package domain + +import "time" + +type Session struct { + Token string `json:"token"` + UserID string `json:"-"` + ExpiresAt time.Time `json:"expires_at"` + CreatedAt time.Time `json:"-"` +} diff --git a/internal/domain/user.go b/internal/domain/user.go new file mode 100644 index 0000000..e1d91c4 --- /dev/null +++ b/internal/domain/user.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +// MarshalJSON форматирует CreatedAt в RFC3339 без микросекунд. +func (u User) MarshalJSON() ([]byte, error) { + type Alias User + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(u), + CreatedAt: u.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/repository/postgres/chat.go b/internal/repository/postgres/chat.go new file mode 100644 index 0000000..9534938 --- /dev/null +++ b/internal/repository/postgres/chat.go @@ -0,0 +1,159 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type ChatRepository struct { + pool *pgxpool.Pool +} + +func NewChatRepository(pool *pgxpool.Pool) *ChatRepository { + return &ChatRepository{pool: pool} +} + +func (r *ChatRepository) Create(ctx context.Context, chat *domain.Chat) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("begin tx: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)` + if _, err := tx.Exec(ctx, insertChat, chat.ID, chat.Title, chat.CreatedAt); err != nil { + return fmt.Errorf("insert chat: %w", err) + } + + const insertMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)` + for _, uid := range chat.MemberIDs { + if _, err := tx.Exec(ctx, insertMember, chat.ID, uid); err != nil { + return fmt.Errorf("insert member %s: %w", uid, err) + } + } + + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("commit tx: %w", err) + } + return nil +} + +func (r *ChatRepository) GetByID(ctx context.Context, id string) (*domain.Chat, error) { + const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid` + var c domain.Chat + err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select chat: %w", err) + } + + const qMembers = `SELECT user_id FROM chat_members WHERE chat_id = $1::uuid ORDER BY user_id` + rows, err := r.pool.Query(ctx, qMembers, id) + if err != nil { + return nil, fmt.Errorf("select members: %w", err) + } + defer rows.Close() + c.MemberIDs = []string{} + for rows.Next() { + var uid string + if err := rows.Scan(&uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + c.MemberIDs = append(c.MemberIDs, uid) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + return &c, nil +} + +func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (bool, error) { + const q = `SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid` + var one int + err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&one) + if err == nil { + return true, nil + } + if !errors.Is(err, pgx.ErrNoRows) { + return false, fmt.Errorf("check membership: %w", err) + } + const qChat = `SELECT 1 FROM chats WHERE id = $1::uuid` + err = r.pool.QueryRow(ctx, qChat, chatID).Scan(&one) + if err == nil { + return false, nil + } + if errors.Is(err, pgx.ErrNoRows) { + return false, repository.ErrNotFound + } + return false, fmt.Errorf("check chat exists: %w", err) +} + +func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) { + const qChats = ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1::uuid + AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid) + ORDER BY c.created_at, c.id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, qChats, userID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list chats: %w", err) + } + defer rows.Close() + + chats := []*domain.Chat{} + var chatIDs []string + for rows.Next() { + var c domain.Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, fmt.Errorf("scan chat: %w", err) + } + c.MemberIDs = []string{} + chats = append(chats, &c) + chatIDs = append(chatIDs, c.ID) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate chats: %w", err) + } + if len(chats) == 0 { + return chats, nil + } + + const qMembers = `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[]) ORDER BY chat_id, user_id` + memberRows, err := r.pool.Query(ctx, qMembers, chatIDs) + if err != nil { + return nil, fmt.Errorf("list members: %w", err) + } + defer memberRows.Close() + + byChat := make(map[string][]string) + for memberRows.Next() { + var chatID, uid string + if err := memberRows.Scan(&chatID, &uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + byChat[chatID] = append(byChat[chatID], uid) + } + if err := memberRows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + for _, c := range chats { + if members, ok := byChat[c.ID]; ok { + c.MemberIDs = members + } + } + return chats, nil +} diff --git a/internal/repository/postgres/message.go b/internal/repository/postgres/message.go new file mode 100644 index 0000000..324afbe --- /dev/null +++ b/internal/repository/postgres/message.go @@ -0,0 +1,135 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type MessageRepository struct { + pool *pgxpool.Pool +} + +func NewMessageRepository(pool *pgxpool.Pool) *MessageRepository { + return &MessageRepository{pool: pool} +} + +func (r *MessageRepository) Create(ctx context.Context, msg *domain.Message) error { + const q = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5) + ` + if _, err := r.pool.Exec(ctx, q, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return fmt.Errorf("insert message: %w", err) + } + return nil +} + +// CreateIdempotent вставляет сообщение и ключ в одной транзакции. +// Конкурентные запросы с одним ключом сериализуются уникальным индексом +// idempotency_keys: второй INSERT ждёт завершения первой транзакции, после +// COMMIT получает конфликт (DO NOTHING), откатывает своё сообщение и читает +// уже сохранённое. Если первая транзакция откатилась (транзиентная ошибка), +// вторая просто продолжает — неуспешный результат не фиксируется. +func (r *MessageRepository) CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (*domain.Message, bool, error) { + tx, err := r.pool.Begin(ctx) + if err != nil { + return nil, false, fmt.Errorf("begin tx: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + // Ключ старше TTL больше не защищает от повтора — освобождаем его. + const deleteExpired = ` + DELETE FROM idempotency_keys + WHERE user_id = $1::uuid AND chat_id = $2::uuid AND key = $3 + AND created_at < now() - make_interval(secs => $4) + ` + if _, err := tx.Exec(ctx, deleteExpired, msg.SenderID, msg.ChatID, key, ttl.Seconds()); err != nil { + return nil, false, fmt.Errorf("delete expired key: %w", err) + } + + const insertMsg = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5) + ` + if _, err := tx.Exec(ctx, insertMsg, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return nil, false, fmt.Errorf("insert message: %w", err) + } + + const insertKey = ` + INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id) + VALUES ($1::uuid, $2::uuid, $3, $4, $5::uuid) + ON CONFLICT (user_id, chat_id, key) DO NOTHING + ` + tag, err := tx.Exec(ctx, insertKey, msg.SenderID, msg.ChatID, key, requestHash, msg.ID) + if err != nil { + return nil, false, fmt.Errorf("insert idempotency key: %w", err) + } + if tag.RowsAffected() == 1 { + if err := tx.Commit(ctx); err != nil { + return nil, false, fmt.Errorf("commit tx: %w", err) + } + return msg, true, nil + } + + // Ключ уже занят подтверждённой записью: наше сообщение не сохраняем. + _ = tx.Rollback(ctx) + + const selectStored = ` + SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM idempotency_keys k + JOIN messages m ON m.id = k.message_id + WHERE k.user_id = $1::uuid AND k.chat_id = $2::uuid AND k.key = $3 + ` + var storedHash string + var m domain.Message + err = r.pool.QueryRow(ctx, selectStored, msg.SenderID, msg.ChatID, key). + Scan(&storedHash, &m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt) + if err != nil { + return nil, false, fmt.Errorf("select stored message: %w", err) + } + if storedHash != requestHash { + return nil, false, repository.ErrConflict + } + return &m, false, nil +} + +// DeleteExpiredKeys удаляет ключи старше TTL. Безопасно выполнять с любой реплики. +func (r *MessageRepository) DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error) { + const q = `DELETE FROM idempotency_keys WHERE created_at < now() - make_interval(secs => $1)` + tag, err := r.pool.Exec(ctx, q, ttl.Seconds()) + if err != nil { + return 0, fmt.Errorf("delete expired keys: %w", err) + } + return tag.RowsAffected(), nil +} + +func (r *MessageRepository) ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) { + const q = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1::uuid + AND (created_at, id) > ($2::timestamptz, $3::uuid) + ORDER BY created_at, id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, q, chatID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list messages: %w", err) + } + defer rows.Close() + msgs := []*domain.Message{} + for rows.Next() { + var m domain.Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, fmt.Errorf("scan message: %w", err) + } + msgs = append(msgs, &m) + } + return msgs, rows.Err() +} diff --git a/internal/repository/postgres/pool.go b/internal/repository/postgres/pool.go new file mode 100644 index 0000000..67c329f --- /dev/null +++ b/internal/repository/postgres/pool.go @@ -0,0 +1,39 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// NewPool создаёт пул соединений с PostgreSQL. +// Параметры ограничены, чтобы не перегрузить БД. +func NewPool(ctx context.Context, dsn string, maxConns int32) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + return nil, fmt.Errorf("parse dsn: %w", err) + } + + cfg.MaxConns = maxConns + cfg.MinConns = min(2, maxConns) + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.MaxConnLifetime = 30 * time.Minute + cfg.HealthCheckPeriod = 30 * time.Second + + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, fmt.Errorf("create pool: %w", err) + } + + // Проверяем, что соединение работает. + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping: %w", err) + } + + return pool, nil +} diff --git a/internal/repository/postgres/user.go b/internal/repository/postgres/user.go new file mode 100644 index 0000000..c18f403 --- /dev/null +++ b/internal/repository/postgres/user.go @@ -0,0 +1,77 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type UserRepository struct { + pool *pgxpool.Pool +} + +func NewUserRepository(pool *pgxpool.Pool) *UserRepository { + return &UserRepository{pool: pool} +} + +func (r *UserRepository) Create(ctx context.Context, user *domain.User, passwordHash string) error { + const q = ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1::uuid, $2, $3, $4, $5) + ` + _, err := r.pool.Exec(ctx, q, user.ID, user.Username, user.DisplayName, passwordHash, user.CreatedAt) + if err != nil { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { + return repository.ErrConflict + } + return fmt.Errorf("insert user: %w", err) + } + return nil +} + +func (r *UserRepository) GetByID(ctx context.Context, id string) (*domain.User, error) { + const q = `SELECT id, username, display_name, created_at FROM users WHERE id = $1::uuid` + var u domain.User + err := r.pool.QueryRow(ctx, q, id).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by id: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + const q = `SELECT id, username, display_name, created_at FROM users WHERE username = $1` + var u domain.User + err := r.pool.QueryRow(ctx, q, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by username: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetPasswordHash(ctx context.Context, userID string) (string, error) { + const q = `SELECT password_hash FROM users WHERE id = $1::uuid` + var hash string + err := r.pool.QueryRow(ctx, q, userID).Scan(&hash) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return "", repository.ErrNotFound + } + return "", fmt.Errorf("select password hash: %w", err) + } + return hash, nil +} diff --git a/internal/repository/redis/message_cache.go b/internal/repository/redis/message_cache.go new file mode 100644 index 0000000..f1cb7b0 --- /dev/null +++ b/internal/repository/redis/message_cache.go @@ -0,0 +1,111 @@ +package redis + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/domain" +) + +// Режимы инвалидации кэша истории (CACHE_INVALIDATION): +// - "scan" (поведение lab2): ключ без версии; запись делает INCR версии и +// удаляет ключи чата через SCAN — O(размер keyspace) запросов к Redis на запись; +// - "version": версия чата входит в ключ; запись делает только INCR, старые +// ключи становятся недостижимыми и истекают по TTL. O(1) на запись. +const ( + InvalidationScan = "scan" + InvalidationVersion = "version" +) + +type MessageCache struct { + client *redis.Client + versionedKeys bool +} + +func NewMessageCache(client *redis.Client, mode string) *MessageCache { + return &MessageCache{client: client, versionedKeys: mode != InvalidationScan} +} + +type cacheEntry struct { + Items []*domain.Message `json:"items"` + NextCursor string `json:"next_cursor"` +} + +func (c *MessageCache) cacheKey(chatID string, version int64, cursor string, limit int) string { + if c.versionedKeys { + return fmt.Sprintf("messages:%s:v%d:%s:%d", chatID, version, cursor, limit) + } + return fmt.Sprintf("messages:%s:%s:%d", chatID, cursor, limit) +} + +func versionKey(chatID string) string { + return "chat_version:" + chatID +} + +// GetVersion возвращает текущую версию чата. 0, если ключа нет. +func (c *MessageCache) GetVersion(ctx context.Context, chatID string) int64 { + v, err := c.client.Get(ctx, versionKey(chatID)).Int64() + if err != nil { + return 0 + } + return v +} + +// IncrVersion увеличивает версию чата. Используется в Send для инвалидации. +func (c *MessageCache) IncrVersion(ctx context.Context, chatID string) int64 { + v, err := c.client.Incr(ctx, versionKey(chatID)).Result() + if err != nil { + slog.Warn("redis incr version failed", "chat_id", chatID, "err", err) + return 0 + } + return v +} + +func (c *MessageCache) Get(ctx context.Context, chatID string, version int64, cursor string, limit int) ([]*domain.Message, string, bool) { + raw, err := c.client.Get(ctx, c.cacheKey(chatID, version, cursor, limit)).Bytes() + if err != nil { + return nil, "", false + } + var e cacheEntry + if err := json.Unmarshal(raw, &e); err != nil { + return nil, "", false + } + return e.Items, e.NextCursor, true +} + +func (c *MessageCache) Set(ctx context.Context, chatID string, version int64, cursor string, limit int, items []*domain.Message, next string) { + e := cacheEntry{Items: items, NextCursor: next} + raw, err := json.Marshal(e) + if err != nil { + slog.Warn("marshal cache entry failed", "err", err) + return + } + if err := c.client.Set(ctx, c.cacheKey(chatID, version, cursor, limit), raw, 30*time.Second).Err(); err != nil { + // Redis недоступен — не падаем, работаем без кэша. + slog.Warn("redis set failed", "chat_id", chatID, "err", err) + } +} + +// OnWrite вызывается после успешной записи сообщения, до ответа клиенту. +// Ошибки Redis игнорируются — при недоступности кэш устареет по TTL. +func (c *MessageCache) OnWrite(ctx context.Context, chatID string) { + c.IncrVersion(ctx, chatID) + if !c.versionedKeys { + _ = c.Invalidate(ctx, chatID) + } +} + +// Invalidate удаляет все ключи messages:{chatID}:* через SCAN. +func (c *MessageCache) Invalidate(ctx context.Context, chatID string) error { + pattern := fmt.Sprintf("messages:%s:*", chatID) + iter := c.client.Scan(ctx, 0, pattern, 100).Iterator() + for iter.Next(ctx) { + _ = c.client.Del(ctx, iter.Val()).Err() + } + return iter.Err() +} diff --git a/internal/repository/redis/session.go b/internal/repository/redis/session.go new file mode 100644 index 0000000..892070a --- /dev/null +++ b/internal/repository/redis/session.go @@ -0,0 +1,73 @@ +package redis + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type SessionRepository struct { + client *redis.Client +} + +func NewSessionRepository(client *redis.Client) *SessionRepository { + return &SessionRepository{client: client} +} + +func (r *SessionRepository) Create(ctx context.Context, s *domain.Session) error { + key := "session:" + s.Token + ttl := time.Until(s.ExpiresAt) + if ttl <= 0 { + return fmt.Errorf("session already expired") + } + if err := r.client.Set(ctx, key, s.UserID, ttl).Err(); err != nil { + return fmt.Errorf("set session: %w", err) + } + return nil +} + +func (r *SessionRepository) GetByToken(ctx context.Context, token string) (*domain.Session, error) { + key := "session:" + token + userID, err := r.client.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("get session: %w", err) + } + ttl, err := r.client.TTL(ctx, key).Result() + if err != nil { + return nil, fmt.Errorf("ttl: %w", err) + } + return &domain.Session{ + Token: token, + UserID: userID, + ExpiresAt: time.Now().UTC().Add(ttl), + }, nil +} + +func (r *SessionRepository) Delete(ctx context.Context, token string) error { + return r.client.Del(ctx, "session:"+token).Err() +} + +func (r *SessionRepository) DeleteExpired(ctx context.Context) error { + return nil +} + +func NewClient(ctx context.Context, url string) (*redis.Client, error) { + opts, err := redis.ParseURL(url) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + client := redis.NewClient(opts) + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("ping redis: %w", err) + } + return client, nil +} diff --git a/internal/repository/repository.go b/internal/repository/repository.go new file mode 100644 index 0000000..0baad7b --- /dev/null +++ b/internal/repository/repository.go @@ -0,0 +1,55 @@ +package repository + +import ( + "context" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" +) + +var ErrNotFound = errNotFound{} + +type errNotFound struct{} + +func (errNotFound) Error() string { return "not found" } + +var ErrConflict = errConflict{} + +type errConflict struct{} + +func (errConflict) Error() string { return "conflict" } + +// UserRepository +type UserRepository interface { + Create(ctx context.Context, user *domain.User, passwordHash string) error + GetByID(ctx context.Context, id string) (*domain.User, error) + GetByUsername(ctx context.Context, username string) (*domain.User, error) + GetPasswordHash(ctx context.Context, userID string) (string, error) +} + +// ChatRepository +type ChatRepository interface { + Create(ctx context.Context, chat *domain.Chat) error + GetByID(ctx context.Context, id string) (*domain.Chat, error) + IsMember(ctx context.Context, chatID, userID string) (bool, error) + ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) +} + +// MessageRepository +type MessageRepository interface { + Create(ctx context.Context, msg *domain.Message) error + // CreateIdempotent атомарно создаёт сообщение и запись ключа идемпотентности. + // Если ключ уже есть с тем же requestHash — возвращает ранее созданное сообщение + // и created=false; с другим requestHash — ErrConflict. + CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (stored *domain.Message, created bool, err error) + DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error) + ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) +} + +// SessionRepository +type SessionRepository interface { + Create(ctx context.Context, s *domain.Session) error + GetByToken(ctx context.Context, token string) (*domain.Session, error) + Delete(ctx context.Context, token string) error + DeleteExpired(ctx context.Context) error +} diff --git a/internal/service/auth.go b/internal/service/auth.go new file mode 100644 index 0000000..f04d6e1 --- /dev/null +++ b/internal/service/auth.go @@ -0,0 +1,99 @@ +package service + +import ( + "context" + "crypto/rand" + "encoding/base64" + "errors" + "fmt" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type AuthService struct { + users repository.UserRepository + sessions repository.SessionRepository + ttl time.Duration +} + +func NewAuthService(users repository.UserRepository, sessions repository.SessionRepository, ttl time.Duration) *AuthService { + return &AuthService{users: users, sessions: sessions, ttl: ttl} +} + +func (s *AuthService) Login(ctx context.Context, username, password string) (*domain.Session, *domain.User, error) { + u, err := s.users.GetByUsername(ctx, username) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + _, _ = hashPassword("dummy-password-for-timing") + return nil, nil, ErrUnauthorized + } + return nil, nil, err + } + + hash, err := s.users.GetPasswordHash(ctx, u.ID) + if err != nil { + return nil, nil, err + } + + if err := verifyPassword(password, hash); err != nil { + if errors.Is(err, ErrPasswordMismatch) { + return nil, nil, ErrUnauthorized + } + return nil, nil, fmt.Errorf("verify password: %w", err) + } + + token, err := generateToken() + if err != nil { + return nil, nil, fmt.Errorf("generate token: %w", err) + } + + now := nowUTC() + sess := &domain.Session{ + Token: token, + UserID: u.ID, + ExpiresAt: now.Add(s.ttl), + CreatedAt: now, + } + if err := s.sessions.Create(ctx, sess); err != nil { + return nil, nil, err + } + return sess, u, nil +} + +func (s *AuthService) ValidateSession(ctx context.Context, token string) (*domain.User, error) { + sess, err := s.sessions.GetByToken(ctx, token) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + // Redis недоступен — возвращаем 401, чтобы клиент перелогинился, + // либо 503, если хотим явно показать проблему зависимости. + return nil, ErrUnauthorized // ← было: return nil, err + } + if nowUTC().After(sess.ExpiresAt) { + _ = s.sessions.Delete(ctx, token) + return nil, ErrUnauthorized + } + u, err := s.users.GetByID(ctx, sess.UserID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + return nil, err + } + return u, nil +} + +func (s *AuthService) Logout(ctx context.Context, token string) error { + return s.sessions.Delete(ctx, token) +} + +func generateToken() (string, error) { + b := make([]byte, 32) + if _, err := rand.Read(b); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(b), nil +} diff --git a/internal/service/chat.go b/internal/service/chat.go new file mode 100644 index 0000000..ce9bc8f --- /dev/null +++ b/internal/service/chat.go @@ -0,0 +1,138 @@ +package service + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type ChatService struct { + chats repository.ChatRepository + users repository.UserRepository +} + +func NewChatService(chats repository.ChatRepository, users repository.UserRepository) *ChatService { + return &ChatService{chats: chats, users: users} +} + +func (s *ChatService) Create(ctx context.Context, callerID, title string, memberIDs []string) (*domain.Chat, error) { + if !validateTitle(title) { + return nil, ErrInvalidInput + } + if len(memberIDs) == 0 || len(memberIDs) > 100 { + return nil, ErrInvalidInput + } + + // Нормализация UUID: убираем разницу регистра. + normalized := make([]string, 0, len(memberIDs)) + seen := make(map[string]struct{}, len(memberIDs)) + callerFound := false + callerParsed, err := uuid.Parse(callerID) + if err != nil { + return nil, ErrInvalidInput + } + callerID = callerParsed.String() + + for _, id := range memberIDs { + parsed, err := uuid.Parse(id) + if err != nil { + return nil, ErrInvalidInput + } + id = parsed.String() + if _, dup := seen[id]; dup { + return nil, ErrInvalidInput + } + seen[id] = struct{}{} + normalized = append(normalized, id) + if id == callerID { + callerFound = true + } + } + if !callerFound { + return nil, ErrInvalidInput + } + + for id := range seen { + if _, err := s.users.GetByID(ctx, id); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrInvalidInput + } + return nil, err + } + } + + c := &domain.Chat{ + ID: newID(), + Title: title, + MemberIDs: normalized, + CreatedAt: nowUTC(), + } + if err := s.chats.Create(ctx, c); err != nil { + return nil, err + } + return c, nil +} + +func (s *ChatService) Get(ctx context.Context, callerID, chatID string) (*domain.Chat, error) { + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, ErrInvalidInput + } + chatID = parsed.String() + + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + c, err := s.chats.GetByID(ctx, chatID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return c, nil +} + +func (s *ChatService) List(ctx context.Context, callerID, cursor string, limit int) ([]*domain.Chat, string, error) { + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, callerID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.chats.ListByMember(ctx, callerID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + if items == nil { + items = []*domain.Chat{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(callerID, last.CreatedAt, last.ID) + } + return items, next, nil +} diff --git a/internal/service/cursor.go b/internal/service/cursor.go new file mode 100644 index 0000000..6839197 --- /dev/null +++ b/internal/service/cursor.go @@ -0,0 +1,39 @@ +package service + +import ( + "encoding/base64" + "strings" + "time" + + "github.com/google/uuid" +) + +func encodeCursor(scope string, createdAt time.Time, id string) string { + raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +func decodeCursor(cursor, expectedScope string) (time.Time, string, error) { + raw, err := base64.RawURLEncoding.DecodeString(cursor) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + parts := strings.SplitN(string(raw), "|", 3) + if len(parts) != 3 { + return time.Time{}, "", ErrInvalidInput + } + if _, err := uuid.Parse(parts[0]); err != nil { + return time.Time{}, "", ErrInvalidInput + } + if parts[0] != expectedScope { + return time.Time{}, "", ErrInvalidInput + } + t, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + if _, err := uuid.Parse(parts[2]); err != nil { + return time.Time{}, "", ErrInvalidInput + } + return t, parts[2], nil +} diff --git a/internal/service/errors.go b/internal/service/errors.go new file mode 100644 index 0000000..6ea9c84 --- /dev/null +++ b/internal/service/errors.go @@ -0,0 +1,12 @@ +package service + +import "errors" + +var ( + ErrInvalidInput = errors.New("invalid input") + ErrUnauthorized = errors.New("unauthorized") + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrUnavailable = errors.New("unavailable") + ErrPasswordMismatch = errors.New("password mismatch") +) diff --git a/internal/service/id.go b/internal/service/id.go new file mode 100644 index 0000000..34874b4 --- /dev/null +++ b/internal/service/id.go @@ -0,0 +1,23 @@ +package service + +import ( + "crypto/rand" + "fmt" + "time" +) + +func newID() string { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + b[6] = (b[6] & 0x0f) | 0x40 + b[8] = (b[8] & 0x3f) | 0x80 + return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) +} + +// nowUTC возвращает время UTC с точностью до секунд. +// PostgreSQL и Python-клиент тестов ожидают формат без наносекунд. +func nowUTC() time.Time { + return time.Now().UTC().Truncate(time.Second) +} diff --git a/internal/service/message.go b/internal/service/message.go new file mode 100644 index 0000000..9c04bcc --- /dev/null +++ b/internal/service/message.go @@ -0,0 +1,161 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "regexp" + "time" + + "github.com/google/uuid" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" + redisrepo "github.com/charawein/mtusi2026lab3/internal/repository/redis" +) + +type MessageService struct { + messages repository.MessageRepository + chats repository.ChatRepository + cache *redisrepo.MessageCache + idempotencyTTL time.Duration +} + +func NewMessageService(messages repository.MessageRepository, chats repository.ChatRepository, cache *redisrepo.MessageCache, idempotencyTTL time.Duration) *MessageService { + return &MessageService{messages: messages, chats: chats, cache: cache, idempotencyTTL: idempotencyTTL} +} + +var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +// requestHash — отпечаток семантики тела запроса. Хешируем уже разобранные поля, +// а не сырые байты, поэтому порядок ключей и пробелы в JSON не влияют на результат. +func requestHash(text string) string { + raw, _ := json.Marshal(struct { + Text string `json:"text"` + }{Text: text}) + sum := sha256.Sum256(raw) + return hex.EncodeToString(sum[:]) +} + +// Send создаёт сообщение с обязательным Idempotency-Key. Повтор с тем же ключом +// и телом возвращает исходное сообщение, с другим телом — ErrConflict. +// Доступ к чату проверяется при каждом повторе. +func (s *MessageService) Send(ctx context.Context, senderID, chatID, text, idempotencyKey string) (*domain.Message, error) { + if !idempotencyKeyRe.MatchString(idempotencyKey) { + return nil, ErrInvalidInput + } + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, ErrInvalidInput + } + chatID = parsed.String() + + if !validateText(text) { + return nil, ErrInvalidInput + } + ok, err := s.chats.IsMember(ctx, chatID, senderID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + + m := &domain.Message{ + ID: newID(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: nowUTC(), + } + stored, created, err := s.messages.CreateIdempotent(ctx, m, idempotencyKey, requestHash(text), s.idempotencyTTL) + if err != nil { + if errors.Is(err, repository.ErrConflict) { + return nil, ErrConflict + } + return nil, err + } + if !created { + return stored, nil + } + + // Инвалидация: увеличение версии чата (+ SCAN-удаление в режиме scan). + if s.cache != nil { + s.cache.OnWrite(ctx, chatID) + } + return m, nil +} + +func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) { + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, "", ErrInvalidInput + } + chatID = parsed.String() + + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, "", ErrNotFound + } + return nil, "", err + } + if !ok { + return nil, "", ErrNotFound + } + + // Проверяем кэш. Если версия изменилась между GetVersion и Get — не используем. + var versionBefore int64 + if s.cache != nil { + versionBefore = s.cache.GetVersion(ctx, chatID) // ← GetVersion не возвращает ошибку, ок + if items, next, hit := s.cache.Get(ctx, chatID, versionBefore, cursor, limit); hit { // ← Get: при ошибке false + // Проверяем, что версия не изменилась с момента Set + if s.cache.GetVersion(ctx, chatID) == versionBefore { + return items, next, nil + } + } + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, chatID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.messages.ListByChat(ctx, chatID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + if items == nil { + items = []*domain.Message{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(chatID, last.CreatedAt, last.ID) + } + + // Записываем в кэш только если версия не изменилась за время чтения БД. + if s.cache != nil { + versionAfter := s.cache.GetVersion(ctx, chatID) + if versionBefore == versionAfter { + s.cache.Set(ctx, chatID, versionBefore, cursor, limit, items, next) + } + } + return items, next, nil +} diff --git a/internal/service/password.go b/internal/service/password.go new file mode 100644 index 0000000..f722a92 --- /dev/null +++ b/internal/service/password.go @@ -0,0 +1,66 @@ +package service + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + argonTime = 1 + argonMemory = 64 * 1024 + argonThreads = 4 + argonKeyLen = 32 + argonSaltLen = 16 +) + +func hashPassword(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("generate salt: %w", err) + } + hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, argonMemory, argonTime, argonThreads, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(hash), + ), nil +} + +func verifyPassword(password, encoded string) error { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return fmt.Errorf("invalid hash format") + } + var version int + if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil { + return fmt.Errorf("parse version: %w", err) + } + if version != argon2.Version { + return fmt.Errorf("incompatible version: %d", version) + } + var mem uint32 + var iters uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &iters, &threads); err != nil { + return fmt.Errorf("parse params: %w", err) + } + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return fmt.Errorf("decode salt: %w", err) + } + want, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return fmt.Errorf("decode hash: %w", err) + } + got := argon2.IDKey([]byte(password), salt, iters, mem, threads, uint32(len(want))) + if subtle.ConstantTimeCompare(got, want) != 1 { + return ErrPasswordMismatch + } + return nil +} diff --git a/internal/service/user.go b/internal/service/user.go new file mode 100644 index 0000000..4c60c47 --- /dev/null +++ b/internal/service/user.go @@ -0,0 +1,64 @@ +package service + +import ( + "context" + "errors" + "fmt" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type UserService struct { + users repository.UserRepository +} + +func NewUserService(users repository.UserRepository) *UserService { + return &UserService{users: users} +} + +// Register создаёт нового пользователя. Возвращает ErrInvalidInput при невалидных +// данных и ErrConflict, если username занят. +func (s *UserService) Register(ctx context.Context, username, displayName, password string) (*domain.User, error) { + if !validateUsername(username) { + return nil, ErrInvalidInput + } + if !validateDisplayName(displayName) { + return nil, ErrInvalidInput + } + if !validatePassword(password) { + return nil, ErrInvalidInput + } + + hash, err := hashPassword(password) + if err != nil { + return nil, fmt.Errorf("hash password: %w", err) + } + + u := &domain.User{ + ID: newID(), + Username: username, + DisplayName: displayName, + CreatedAt: nowUTC(), + } + if err := s.users.Create(ctx, u, hash); err != nil { + if errors.Is(err, repository.ErrConflict) { + return nil, ErrConflict + } + return nil, err + } + return u, nil +} + +// GetByID возвращает пользователя. Возвращает ErrNotFound, если такого нет. +// Используется middleware аутентификации для проверки X-User-Id. +func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) { + u, err := s.users.GetByID(ctx, id) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return u, nil +} diff --git a/internal/service/validate.go b/internal/service/validate.go new file mode 100644 index 0000000..854c09d --- /dev/null +++ b/internal/service/validate.go @@ -0,0 +1,48 @@ +package service + +import ( + "regexp" + "strings" + "unicode/utf8" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func validatePassword(s string) bool { + n := utf8.RuneCountInString(s) + return n >= 12 && n <= 128 +} + +// validateUsername проверяет формат username по README: строго [a-z0-9_]{3,32}. +func validateUsername(s string) bool { + return usernameRe.MatchString(s) +} + +// validateDisplayName проверяет display_name: 1–100 Unicode code points, +// не состоит только из пробельных символов. +func validateDisplayName(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateTitle проверяет title чата: 1–100 code points, не только пробелы. +func validateTitle(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateText проверяет text сообщения: 1–4000 code points, не только пробелы. +// В lab4 появится возможность отправить пустой text, если есть attachment_ids. +func validateText(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 4000 +} diff --git a/internal/transport/http/auth.go b/internal/transport/http/auth.go new file mode 100644 index 0000000..fff964e --- /dev/null +++ b/internal/transport/http/auth.go @@ -0,0 +1,92 @@ +package http + +import ( + "encoding/base64" + "net/http" + "strings" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type AuthHandler struct { + auth *service.AuthService +} + +func NewAuthHandler(auth *service.AuthService) *AuthHandler { + return &AuthHandler{auth: auth} +} + +type sessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User *domain.User `json:"user"` +} + +func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) { + username, password, ok := parseBasicAuth(r.Header.Get("Authorization")) + if !ok { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + sess, u, err := h.auth.Login(r.Context(), username, password) + if err != nil { + if err == service.ErrUnauthorized { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + } + httputil.WriteError(w, r, err) + return + } + + // Формат RFC3339 без микросекунд: "2026-10-09T19:00:36Z". + // Python-клиент тестов ожидает 'Z' в конце строки. + httputil.WriteJSON(w, r, http.StatusCreated, sessionResponse{ + Token: sess.Token, + TokenType: "Bearer", + ExpiresAt: sess.ExpiresAt.UTC().Truncate(time.Second).Format(time.RFC3339), + User: u, + }) +} + +func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) { + token := bearerToken(r) + if token == "" { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + if err := h.auth.Logout(r.Context(), token); err != nil { + httputil.WriteError(w, r, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func parseBasicAuth(h string) (string, string, bool) { + const prefix = "Basic " + if !strings.HasPrefix(h, prefix) { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(h[len(prefix):]) + if err != nil { + return "", "", false + } + parts := strings.SplitN(string(raw), ":", 2) + if len(parts) != 2 { + return "", "", false + } + return parts[0], parts[1], true +} + +func bearerToken(r *http.Request) string { + h := r.Header.Get("Authorization") + if !strings.HasPrefix(h, "Bearer ") { + return "" + } + return strings.TrimPrefix(h, "Bearer ") +} diff --git a/internal/transport/http/chat.go b/internal/transport/http/chat.go new file mode 100644 index 0000000..4897179 --- /dev/null +++ b/internal/transport/http/chat.go @@ -0,0 +1,86 @@ +package http + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type ChatHandler struct { + chats *service.ChatService +} + +func NewChatHandler(chats *service.ChatService) *ChatHandler { + return &ChatHandler{chats: chats} +} + +func (h *ChatHandler) CreateChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + var body struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + c, err := h.chats.Create(r.Context(), uid, body.Title, body.MemberIDs) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, c) +} + +func (h *ChatHandler) ListChats(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.chats.List(r.Context(), uid, cursor, limit) + if err != nil { + // ВРЕМЕННО: логируем точную ошибку + slog.Error("ListChats failed", "err", err, "uid", uid, "cursor", cursor, "limit", limit) + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} + +func (h *ChatHandler) GetChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + c, err := h.chats.Get(r.Context(), uid, chatID) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, c) +} diff --git a/internal/transport/http/health.go b/internal/transport/http/health.go new file mode 100644 index 0000000..393eede --- /dev/null +++ b/internal/transport/http/health.go @@ -0,0 +1,54 @@ +package http + +import ( + "context" + "net/http" + "sync/atomic" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type HealthHandler struct { + pool *pgxpool.Pool + redis *redis.Client + draining *atomic.Bool +} + +func NewHealthHandler(pool *pgxpool.Pool, redisClient *redis.Client, draining *atomic.Bool) *HealthHandler { + return &HealthHandler{pool: pool, redis: redisClient, draining: draining} +} + +// Live проверяет только жизнь процесса. +func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) { + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +// Ready проверяет доступность PostgreSQL и Redis. +// После SIGTERM возвращает 503, чтобы LB исключил реплику до закрытия listener. +func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) { + if h.draining.Load() { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + + if err := h.pool.Ping(ctx); err != nil { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + if err := h.redis.Ping(ctx).Err(); err != nil { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +type healthResponse struct { + Status string `json:"status"` +} diff --git a/internal/transport/http/internal_stats.go b/internal/transport/http/internal_stats.go new file mode 100644 index 0000000..e53c274 --- /dev/null +++ b/internal/transport/http/internal_stats.go @@ -0,0 +1,39 @@ +package http + +import ( + "encoding/json" + "net/http" + "runtime" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/config" +) + +// NewInternalStatsHandler отдаёт счётчики пула PostgreSQL и рантайма Go. +// Нужен для поиска точки насыщения пула в экспериментах трека 1: +// рост empty_acquire_count/acquire_duration означает ожидание свободного соединения. +func NewInternalStatsHandler(pool *pgxpool.Pool, cfg config.Config) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("GET /internal/stats", func(w http.ResponseWriter, r *http.Request) { + st := pool.Stat() + body := map[string]any{ + "instance_id": cfg.InstanceID, + "cache_invalidation": cfg.CacheInvalidation, + "pool": map[string]any{ + "max_conns": st.MaxConns(), + "total_conns": st.TotalConns(), + "acquired_conns": st.AcquiredConns(), + "idle_conns": st.IdleConns(), + "acquire_count": st.AcquireCount(), + "empty_acquire_count": st.EmptyAcquireCount(), + "canceled_acquire_count": st.CanceledAcquireCount(), + "acquire_duration_ms": st.AcquireDuration().Milliseconds(), + }, + "goroutines": runtime.NumGoroutine(), + } + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(body) + }) + return mux +} diff --git a/internal/transport/http/message.go b/internal/transport/http/message.go new file mode 100644 index 0000000..c812ebe --- /dev/null +++ b/internal/transport/http/message.go @@ -0,0 +1,75 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type MessageHandler struct { + messages *service.MessageService +} + +func NewMessageHandler(messages *service.MessageService) *MessageHandler { + return &MessageHandler{messages: messages} +} + +func (h *MessageHandler) SendMessage(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + var body struct { + Text string `json:"text"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + // Повтор с тем же ключом возвращает тот же 201 и то же сообщение. + key := r.Header.Get("Idempotency-Key") + m, err := h.messages.Send(r.Context(), uid, chatID, body.Text, key) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, m) +} + +func (h *MessageHandler) ListMessages(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.messages.List(r.Context(), uid, chatID, cursor, limit) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} diff --git a/internal/transport/http/middleware/auth.go b/internal/transport/http/middleware/auth.go new file mode 100644 index 0000000..40040e6 --- /dev/null +++ b/internal/transport/http/middleware/auth.go @@ -0,0 +1,48 @@ +package middleware + +import ( + "errors" + "log/slog" + "net/http" + "strings" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +// Auth проверяет Authorization: Bearer через AuthService. +func Auth(auth *service.AuthService) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + header := r.Header.Get("Authorization") + if !strings.HasPrefix(header, "Bearer ") { + writeUnauthorized(w, r) + return + } + token := strings.TrimPrefix(header, "Bearer ") + if token == "" { + writeUnauthorized(w, r) + return + } + + u, err := auth.ValidateSession(r.Context(), token) + if err != nil { + if errors.Is(err, service.ErrUnauthorized) { + writeUnauthorized(w, r) + return + } + slog.Error("auth: unexpected", "err", err) + httputil.WriteError(w, r, nil) + return + } + + ctx := httputil.ContextWithUserID(r.Context(), u.ID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +func writeUnauthorized(w http.ResponseWriter, r *http.Request) { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) +} diff --git a/internal/transport/http/middleware/instance.go b/internal/transport/http/middleware/instance.go new file mode 100644 index 0000000..46849b1 --- /dev/null +++ b/internal/transport/http/middleware/instance.go @@ -0,0 +1,14 @@ +package middleware + +import "net/http" + +// InstanceID добавляет X-Instance-Id ко всем ответам API, включая ошибки и health. +// Значение задаётся один раз при старте процесса и не меняется до его завершения. +func InstanceID(id string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Instance-Id", id) + next.ServeHTTP(w, r) + }) + } +} diff --git a/internal/transport/http/middleware/logging.go b/internal/transport/http/middleware/logging.go new file mode 100644 index 0000000..71174d1 --- /dev/null +++ b/internal/transport/http/middleware/logging.go @@ -0,0 +1,34 @@ +package middleware + +import ( + "log/slog" + "net/http" + "time" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type statusRecorder struct { + http.ResponseWriter + status int +} + +func (r *statusRecorder) WriteHeader(code int) { + r.status = code + r.ResponseWriter.WriteHeader(code) +} + +func Logging(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK} + next.ServeHTTP(rec, r) + slog.Info("http request", + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + "status", rec.status, + "duration_ms", time.Since(start).Milliseconds(), + ) + }) +} diff --git a/internal/transport/http/middleware/recovery.go b/internal/transport/http/middleware/recovery.go new file mode 100644 index 0000000..586f817 --- /dev/null +++ b/internal/transport/http/middleware/recovery.go @@ -0,0 +1,25 @@ +package middleware + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +func Recovery(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer func() { + if rec := recover(); rec != nil { + slog.Error("panic in handler", + "panic", rec, + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + ) + httputil.WriteError(w, r, nil) + } + }() + next.ServeHTTP(w, r) + }) +} diff --git a/internal/transport/http/middleware/request_id.go b/internal/transport/http/middleware/request_id.go new file mode 100644 index 0000000..cda3ba6 --- /dev/null +++ b/internal/transport/http/middleware/request_id.go @@ -0,0 +1,29 @@ +package middleware + +import ( + "crypto/rand" + "fmt" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = newRequestID() + } + w.Header().Set("X-Request-Id", id) + ctx := httputil.ContextWithRequestID(r.Context(), id) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func newRequestID() string { + var b [12]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + return fmt.Sprintf("%x", b[:]) +} diff --git a/internal/transport/http/middleware/timeout.go b/internal/transport/http/middleware/timeout.go new file mode 100644 index 0000000..037d59b --- /dev/null +++ b/internal/transport/http/middleware/timeout.go @@ -0,0 +1,18 @@ +package middleware + +import ( + "context" + "net/http" + "time" +) + +// Timeout ограничивает время выполнения запроса. +func Timeout(d time.Duration) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + ctx, cancel := context.WithTimeout(r.Context(), d) + defer cancel() + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} diff --git a/internal/transport/http/router.go b/internal/transport/http/router.go new file mode 100644 index 0000000..90a069c --- /dev/null +++ b/internal/transport/http/router.go @@ -0,0 +1,54 @@ +package http + +import ( + "net/http" + "sync/atomic" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/http/middleware" +) + +func NewRouter( + users *service.UserService, + chats *service.ChatService, + messages *service.MessageService, + auth *service.AuthService, + pool *pgxpool.Pool, + redisClient *redis.Client, + instanceID string, + draining *atomic.Bool, +) http.Handler { + userH := NewUserHandler(users) + chatH := NewChatHandler(chats) + msgH := NewMessageHandler(messages) + authH := NewAuthHandler(auth) + healthH := NewHealthHandler(pool, redisClient, draining) + + mux := http.NewServeMux() + + mux.HandleFunc("GET /health/live", healthH.Live) + mux.HandleFunc("GET /health/ready", healthH.Ready) + mux.HandleFunc("POST /api/v1/users", userH.CreateUser) + mux.HandleFunc("POST /api/v1/auth/sessions", authH.CreateSession) + + authMW := middleware.Auth(auth) + + mux.Handle("DELETE /api/v1/auth/sessions/current", authMW(http.HandlerFunc(authH.RevokeSession))) + mux.Handle("GET /api/v1/users/me", authMW(http.HandlerFunc(userH.CurrentUser))) + mux.Handle("POST /api/v1/chats", authMW(http.HandlerFunc(chatH.CreateChat))) + mux.Handle("GET /api/v1/chats", authMW(http.HandlerFunc(chatH.ListChats))) + mux.Handle("GET /api/v1/chats/{chat_id}", authMW(http.HandlerFunc(chatH.GetChat))) + mux.Handle("POST /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.SendMessage))) + mux.Handle("GET /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.ListMessages))) + + handler := middleware.Logging(mux) + handler = middleware.Recovery(handler) + handler = middleware.Timeout(5 * time.Second)(handler) + handler = middleware.RequestID(handler) + handler = middleware.InstanceID(instanceID)(handler) + return handler +} diff --git a/internal/transport/http/user.go b/internal/transport/http/user.go new file mode 100644 index 0000000..3180e9d --- /dev/null +++ b/internal/transport/http/user.go @@ -0,0 +1,49 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type UserHandler struct { + users *service.UserService +} + +func NewUserHandler(users *service.UserService) *UserHandler { + return &UserHandler{users: users} +} + +func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) { + var body struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + u, err := h.users.Register(r.Context(), body.Username, body.DisplayName, body.Password) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, u) +} + +func (h *UserHandler) CurrentUser(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + u, err := h.users.GetByID(r.Context(), uid) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, u) +} diff --git a/internal/transport/httputil/response.go b/internal/transport/httputil/response.go new file mode 100644 index 0000000..0dbf4bf --- /dev/null +++ b/internal/transport/httputil/response.go @@ -0,0 +1,158 @@ +package httputil + +import ( + "context" + "encoding/json" + "errors" + "log/slog" + "net/http" + "strconv" + + "github.com/charawein/mtusi2026lab3/internal/service" +) + +// requestIDKey — ключ контекста для X-Request-Id. +type requestIDKey struct{} + +// ContextWithRequestID кладёт request_id в контекст. Используется middleware.RequestID. +func ContextWithRequestID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, requestIDKey{}, id) +} + +// RequestIDFrom извлекает request_id из контекста. +func RequestIDFrom(ctx context.Context) string { + if v, ok := ctx.Value(requestIDKey{}).(string); ok { + return v + } + return "" +} + +// userIDKey — ключ контекста для аутентифицированного user_id. +type userIDKey struct{} + +// ContextWithUserID кладёт user_id в контекст. Используется middleware.Auth. +func ContextWithUserID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, userIDKey{}, id) +} + +// UserIDFromContext извлекает user_id из контекста. +func UserIDFromContext(ctx context.Context) string { + if v, ok := ctx.Value(userIDKey{}).(string); ok { + return v + } + return "" +} + +// errorBody — формат тела ошибки по contracts/openapi.json. +type errorBody struct { + Error errorDetail `json:"error"` +} + +type errorDetail struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +// WriteJSON пишет JSON-ответ с заданным статусом. +func WriteJSON(w http.ResponseWriter, r *http.Request, status int, v any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + if v == nil { + return + } + if err := json.NewEncoder(w).Encode(v); err != nil { + slog.Error("failed to encode response", "err", err, "request_id", RequestIDFrom(r.Context())) + } +} + +// WriteError мапит доменную ошибку в HTTP-статус и пишет тело в формате контракта. +func WriteError(w http.ResponseWriter, r *http.Request, err error) { + status, code := mapError(err) + reqID := RequestIDFrom(r.Context()) + if reqID == "" { + reqID = "missing-request-id" + } + body := errorBody{Error: errorDetail{ + Code: code, + Message: messageFor(code), + RequestID: reqID, + }} + WriteJSON(w, r, status, body) +} + +func mapError(err error) (int, string) { + switch { + case errors.Is(err, service.ErrInvalidInput): + return http.StatusBadRequest, "invalid_request" + case errors.Is(err, service.ErrUnauthorized): + return http.StatusUnauthorized, "unauthorized" + case errors.Is(err, service.ErrNotFound): + return http.StatusNotFound, "not_found" + case errors.Is(err, service.ErrConflict): + return http.StatusConflict, "conflict" + case errors.Is(err, service.ErrUnavailable): + return http.StatusServiceUnavailable, "unavailable" + default: + return http.StatusInternalServerError, "internal_error" + } +} + +func messageFor(code string) string { + switch code { + case "invalid_request": + return "Неверный запрос" + case "unauthorized": + return "Требуется аутентификация" + case "not_found": + return "Объект не найден" + case "conflict": + return "Конфликт" + case "internal_error": + return "Внутренняя ошибка" + case "unavailable": + return "Сервис недоступен" + default: + return "Ошибка" + } +} + +// DecodeJSON парсит тело запроса в v, строго запрещая неизвестные поля. +func DecodeJSON(r *http.Request, v any) error { + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(v); err != nil { + return service.ErrInvalidInput + } + if dec.More() { + return service.ErrInvalidInput + } + return nil +} + +// ParseLimit читает query-параметр limit с дефолтом и границами по контракту. +func ParseLimit(r *http.Request) (int, error) { + s := r.URL.Query().Get("limit") + if s == "" { + return 50, nil + } + n, err := strconv.Atoi(s) + if err != nil || n < 1 || n > 100 { + return 0, service.ErrInvalidInput + } + return n, nil +} + +// PageResponse — универсальный ответ пагинации. +type PageResponse struct { + Items any `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +// NextOrNull превращает пустую строку в nil (для сериализации в null). +func NextOrNull(s string) *string { + if s == "" { + return nil + } + return &s +} diff --git a/migrations/0001_init.down.sql b/migrations/0001_init.down.sql new file mode 100644 index 0000000..99dada2 --- /dev/null +++ b/migrations/0001_init.down.sql @@ -0,0 +1,6 @@ +-- Откат миграции 0001 +DROP TABLE IF EXISTS sessions; +DROP TABLE IF EXISTS messages; +DROP TABLE IF EXISTS chat_members; +DROP TABLE IF EXISTS chats; +DROP TABLE IF EXISTS users; \ No newline at end of file diff --git a/migrations/0001_init.up.sql b/migrations/0001_init.up.sql new file mode 100644 index 0000000..9875ce6 --- /dev/null +++ b/migrations/0001_init.up.sql @@ -0,0 +1,50 @@ +-- migrations/0001_init.sql + +-- Пользователи +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Чаты +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Членство +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members(user_id); + +-- Сообщения +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Главный индекс для пагинации +CREATE INDEX messages_chat_created_id_idx + ON messages (chat_id, created_at, id); + +-- Сессии (если SESSION_STORE=postgres) +CREATE TABLE sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX sessions_expires_idx ON sessions(expires_at); +CREATE INDEX sessions_user_idx ON sessions(user_id); \ No newline at end of file diff --git a/migrations/0002_idempotency.down.sql b/migrations/0002_idempotency.down.sql new file mode 100644 index 0000000..1cf0d86 --- /dev/null +++ b/migrations/0002_idempotency.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS idempotency_keys; diff --git a/migrations/0002_idempotency.up.sql b/migrations/0002_idempotency.up.sql new file mode 100644 index 0000000..767c263 --- /dev/null +++ b/migrations/0002_idempotency.up.sql @@ -0,0 +1,18 @@ +-- migrations/0002_idempotency.sql + +-- Ключи идемпотентности отправки сообщения (lab3). +-- Область уникальности: пользователь + метод + путь чата + ключ. +-- Метод всегда POST, путь однозначно задаётся chat_id, поэтому храним chat_id. +-- Запись создаётся в одной транзакции с сообщением: либо есть обе, либо ни одной. +CREATE TABLE idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + key TEXT NOT NULL, + request_hash TEXT NOT NULL, + message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, chat_id, key) +); + +-- Для периодической очистки ключей старше IDEMPOTENCY_TTL_SECONDS. +CREATE INDEX idempotency_keys_created_idx ON idempotency_keys(created_at); diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh new file mode 100755 index 0000000..134fd64 --- /dev/null +++ b/scripts/collect-evidence.sh @@ -0,0 +1,67 @@ +#!/bin/sh +set -eu +# Прогоняет все проверки lab3 на запущенном Docker-стенде и сохраняет вывод в evidence/. +# Токены и секреты не печатаются (тесты держат их в памяти). +# Linux/macOS/WSL: sh scripts/collect-evidence.sh +# Windows (Git Bash): PYTHON=python STOP=scripts/win/stop-one.cmd RESTART=scripts/win/restart.cmd sh scripts/collect-evidence.sh +cd "$(dirname "$0")/.." +PY=${PYTHON:-python3} +STOP=${STOP:-scripts/stop-one.sh} +RESTART=${RESTART:-scripts/restart.sh} +BASE=${BASE_URL:-http://localhost:8080} +export PYTHONUTF8=1 +mkdir -p evidence + +step() { echo "== $*"; } + +step "состояние стенда" +{ date -u +%Y-%m-%dT%H:%M:%SZ; docker compose version; docker compose ps; } > evidence/docker_ps.txt + +step "X-Instance-Id через LB" +$PY - "$BASE" > evidence/instances.txt <<'EOF' +import sys, urllib.request, collections +seen = collections.Counter() +for _ in range(20): + with urllib.request.urlopen(sys.argv[1] + '/health/ready') as r: + seen[r.headers['X-Instance-Id']] += 1 +for k, v in sorted(seen.items()): + print(k, v) +EOF +cat evidence/instances.txt + +step "smoke" +$PY tests/smoke.py --base-url "$BASE" | tee evidence/smoke.txt + +step "конкурентная идемпотентность" +$PY tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1 + +step "публичный failover (2 прогона, между ними restore)" +for n in 1 2; do + { $PY tests/resilience.py --mode failover --action-script "$STOP" --base-url "$BASE" || echo "FAILED"; \ + echo "-- контейнеры api после stop-one:"; docker compose ps -a api --format '{{.Name}} {{.ID}} {{.Status}}'; } \ + > evidence/failover_$n.txt 2>&1 + cat evidence/failover_$n.txt + sh scripts/restore.sh >> evidence/failover_$n.txt +done + +step "persistence (restart всего стенда с volumes)" +{ echo "-- до:"; docker compose ps --format '{{.Name}} {{.Status}}'; \ + $PY tests/resilience.py --mode persistence --action-script "$RESTART" --base-url "$BASE" || echo "FAILED"; \ + echo "-- после:"; docker compose ps --format '{{.Name}} {{.Status}}'; } > evidence/persistence.txt 2>&1 +cat evidence/persistence.txt + +step "серия отказов каждой реплики под нагрузкой (уровень 4)" +$PY tests/failover_series.py --base-url "$BASE" --output evidence/failover_series.json | tail -1 + +step "rolling update под нагрузкой (уровень 4)" +$PY tests/load.py --base-url "$BASE" --duration 60 --concurrency 4 --output evidence/rolling_update_load.json > /dev/null & +LOAD=$! +sleep 5 +sh scripts/rolling-update.sh > evidence/rolling_update.txt 2>&1 +wait $LOAD +cat evidence/rolling_update.txt evidence/rolling_update_load.json + +step "базовая нагрузка без отказов" +$PY tests/load.py --base-url "$BASE" --duration 30 --concurrency 4 --output evidence/load_baseline.json > /dev/null +cat evidence/load_baseline.json +docker stats --no-stream --format '{{.Name}} {{.CPUPerc}} {{.MemUsage}}' > evidence/docker_stats.txt diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 0000000..815654a --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +# Создаёт локальные .env и secrets/ для учебного стенда. Повторный запуск ничего +# не перезаписывает (иначе пароль разойдётся с уже инициализированным volume). +cd "$(dirname "$0")/.." +[ -f .env ] || cp .env.example .env +mkdir -p secrets +if [ ! -f secrets/postgres_password ]; then + # 32 случайных байта в hex — без символов, требующих экранирования в URL. + pw=$(od -An -N32 -tx1 /dev/urandom | tr -d ' \n') + printf '%s' "$pw" > secrets/postgres_password + printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$pw" > secrets/database_url +fi +[ -f secrets/cache_url ] || printf '%s' 'redis://redis:6379/0' > secrets/cache_url +chmod 600 secrets/* 2>/dev/null || true +echo "secrets ready in ./secrets (values not printed)" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..32494e3 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +# Перезапускает API, LB и все хранилища (PostgreSQL, Redis) с сохранением volumes. +# Никаких down -v / FLUSH / повторного seed. +cd "$(dirname "$0")/.." +docker compose stop lb api +docker compose restart postgres redis + +until docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; do + sleep 1 +done +until docker compose exec -T redis redis-cli ping >/dev/null 2>&1; do + sleep 1 +done + +docker compose start api lb diff --git a/scripts/restore.sh b/scripts/restore.sh new file mode 100755 index 0000000..eec5b32 --- /dev/null +++ b/scripts/restore.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +# Запускает остановленные stop-one.sh API-реплики и ждёт их готовности. +cd "$(dirname "$0")/.." +docker compose start api >/dev/null +deadline=$(( $(date +%s) + 60 )) +while :; do + bad=0 + for cid in $(docker compose ps -aq api); do + st=$(docker inspect -f '{{.State.Health.Status}}' "$cid") + [ "$st" = healthy ] || bad=1 + done + [ $bad -eq 0 ] && break + [ "$(date +%s)" -lt $deadline ] || { echo "api replicas not healthy in 60s" >&2; exit 1; } + sleep 1 +done +docker compose ps api --format '{{.Name}} {{.Status}}' diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 0000000..a935189 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,35 @@ +#!/bin/sh +set -eu +# Поочерёдная замена API-реплик без остановки сервиса (Compose). +# Для каждой старой реплики: поднять одну новую → дождаться healthy (LB сам +# найдёт её через DNS) → остановить старую (drain) → удалить. +# Миграции выполняются ДО замены отдельным сервисом migrate и должны быть +# совместимы со старой версией (expand → contract). +cd "$(dirname "$0")/.." +docker compose build api +docker compose run --rm migrate >/dev/null + +wait_healthy() { + want=$1; deadline=$(( $(date +%s) + 90 )) + while :; do + n=0 + for cid in $(docker compose ps -q api); do + [ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] && n=$((n+1)) + done + [ $n -ge "$want" ] && return 0 + [ "$(date +%s)" -lt $deadline ] || { echo "new replica not healthy in 90s" >&2; return 1; } + sleep 1 + done +} + +old=$(docker compose ps -q api) +for cid in $old; do + cur=$(docker compose ps -q api | wc -l | tr -d ' ') + docker compose up -d --no-deps --no-recreate --scale api=$((cur + 1)) api + wait_healthy $((cur + 1)) + name=$(docker inspect -f '{{.Name}}' "$cid") + docker stop -t 15 "$cid" >/dev/null + docker rm "$cid" >/dev/null + echo "replaced $name" +done +docker compose ps api --format '{{.Name}} {{.Image}} {{.Status}}' diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 0000000..1fb7770 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,25 @@ +#!/bin/sh +set -eu +# Останавливает ОДНУ API-реплику, чей X-Instance-Id передан в TARGET_INSTANCE_ID, +# и оставляет её остановленной. X-Instance-Id = hostname контейнера = префикс его ID. +# БД, Redis, LB и volumes не трогаются. Восстановление: scripts/restore.sh. +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +cd "$(dirname "$0")/.." +case "$TARGET_INSTANCE_ID" in + *[!0-9a-f]*) echo "unexpected instance id format" >&2; exit 2 ;; +esac +[ ${#TARGET_INSTANCE_ID} -ge 12 ] || { echo "instance id too short" >&2; exit 2; } +for cid in $(docker compose ps -q api); do + case "$cid" in + "$TARGET_INSTANCE_ID"*) + name=$(docker inspect -f '{{.Name}}' "$cid") + # SIGTERM → API отвечает 503 на /health/ready (DRAIN_DELAY), LB исключает её, + # затем http.Server.Shutdown дожидается текущих запросов. + docker stop -t 15 "$cid" >/dev/null + echo "stopped $name ($TARGET_INSTANCE_ID)" + exit 0 + ;; + esac +done +echo "no running api container matches $TARGET_INSTANCE_ID" >&2 +exit 1 diff --git a/scripts/track1.py b/scripts/track1.py new file mode 100644 index 0000000..9c22447 --- /dev/null +++ b/scripts/track1.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Оркестратор экспериментов трека 1 (цена масштабирования). + +Для каждой серии/конфигурации из experiments/track1.json: + 1. поднимает отдельный compose-проект (по умолчанию mtusi2026lab3-bench, порт 18080) + с переменными конфигурации (число реплик, CPU/RAM, пул, LB, режим кэша); + 2. ждёт, пока через LB видны все N реплик; + 3. для каждого уровня нагрузки и повтора запускает bin/bench (Go), параллельно + раз в ~1 s снимает docker stats всех контейнеров и pg_stat_activity, до и + после — счётчики пула pgx каждой реплики (внутренний :9090, через docker exec); + 4. дописывает одну JSON-строку на прогон в evidence/track1/raw.jsonl. + +Анализ и графики: scripts/track1_report.py. Только stdlib + docker CLI + go. + +Примеры: + python scripts/track1.py --quick # быстрый прогон всех серий + python scripts/track1.py --series A_fixed_total # одна серия, полная методика + python scripts/track1.py --resume # продолжить после обрыва + python scripts/track1.py --cleanup # в конце удалить bench-проект с volumes +""" +import argparse +import json +import os +from pathlib import Path +import statistics +import subprocess +import sys +import threading +import time +import urllib.request + +ROOT = Path(__file__).resolve().parents[1] +BENCH = ROOT / 'bin' / ('bench.exe' if os.name == 'nt' else 'bench') + + +def sh(args, env=None, check=True, capture=True, timeout=600): + r = subprocess.run(args, cwd=ROOT, env=env, capture_output=capture, text=True, timeout=timeout) + if check and r.returncode != 0: + raise SystemExit('command failed: %s\n%s' % (' '.join(args[:6]), (r.stderr or '')[-2000:])) + return (r.stdout or '').strip() + + +class Stack: + def __init__(self, project, port): + self.project, self.port = project, port + self.base = 'http://127.0.0.1:%d' % port + + def compose(self, *args, env=None, **kw): + return sh(['docker', 'compose', '-p', self.project, *args], env=env, **kw) + + def up(self, env, build): + args = ['up', '-d', '--wait', '--remove-orphans'] + if build: + args.append('--build') + n = env['API_REPLICAS'] + self.compose(*args, '--scale', 'api=' + n, env=env, timeout=900) + + def containers(self): + out = {} + for cid in self.compose('ps', '-q').split(): + svc = sh(['docker', 'inspect', '-f', '{{index .Config.Labels "com.docker.compose.service"}}', cid]) + out[cid[:12]] = svc + return out + + def instances_via_lb(self, tries): + seen = set() + for _ in range(tries): + try: + with urllib.request.urlopen(self.base + '/health/ready', timeout=2) as r: + seen.add(r.headers.get('X-Instance-Id')) + except OSError: + pass + return seen + + def wait_balanced(self, n, timeout=90): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if len(self.instances_via_lb(4 * n + 4)) >= n: + return + time.sleep(1) + raise SystemExit('LB does not route to %s replicas' % n) + + def pool_stats(self, containers): + res = {} + for cid, svc in containers.items(): + if svc != 'api': + continue + out = sh(['docker', 'exec', cid, 'wget', '-qO-', 'http://127.0.0.1:9090/internal/stats'], check=False) + try: + res[cid] = json.loads(out)['pool'] + except (ValueError, KeyError): + pass + return res + + def pad_redis(self, keys): + if keys <= 0: + return + have = int(self.compose('exec', '-T', 'redis', 'redis-cli', 'EVAL', + "return #redis.call('KEYS','pad:*')", '0') or 0) + if have >= keys: + return + # Фоновый keyspace (имитация активных сессий/прочих ключей). Только синтетика. + self.compose('exec', '-T', 'redis', 'redis-cli', 'EVAL', + "for i=1,tonumber(ARGV[1]) do redis.call('SET','pad:'..i,'x','EX',604800) end return 1", + '0', str(keys)) + + +class Sampler(threading.Thread): + """docker stats + pg_stat_activity примерно раз в секунду.""" + + def __init__(self, stack, containers): + super().__init__(daemon=True) + self.stack, self.containers = stack, containers + self.samples, self.pg = [], [] + self.stop = threading.Event() + + def run(self): + ids = list(self.containers) + while not self.stop.is_set(): + t = time.monotonic() + out = sh(['docker', 'stats', '--no-stream', '--format', '{{.ID}} {{.CPUPerc}} {{.MemUsage}}', *ids], check=False) + for line in out.splitlines(): + parts = line.split() + if len(parts) < 2: + continue + try: + cpu = float(parts[1].rstrip('%')) + except ValueError: + continue + mem = parts[2] if len(parts) > 2 else '' + self.samples.append((t, parts[0][:12], cpu, mem)) + q = ("select count(*) filter (where state='active'), count(*) " + "from pg_stat_activity where datname='messenger' and pid<>pg_backend_pid()") + pg = self.stack.compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', + '-tAc', q, check=False) + try: + a, total = pg.split('|') + self.pg.append((t, int(a), int(total))) + except ValueError: + pass + + +def mem_mib(s): + s = s.strip() + for unit, k in (('GiB', 1024), ('MiB', 1), ('KiB', 1 / 1024), ('B', 1 / 1024 / 1024)): + if s.endswith(unit): + try: + return float(s[:-len(unit)]) * k + except ValueError: + return None + return None + + +def summarize_resources(sampler, containers, env, t_from, t_to): + limits = {'api': float(env['API_CPUS']), 'postgres': float(env['PG_CPUS']), + 'lb': float(env['LB_CPUS']), 'redis': float(env['REDIS_CPUS'])} + per = {} + for t, cid, cpu, mem in sampler.samples: + if t_from <= t <= t_to and cid in containers: + per.setdefault(cid, []).append((cpu, mem_mib(mem))) + roles = {} + for cid, vals in per.items(): + svc = containers[cid] + cpus = [v[0] for v in vals] + mems = [v[1] for v in vals if v[1] is not None] + roles.setdefault(svc, []).append({'cpu_mean': statistics.mean(cpus), 'cpu_max': max(cpus), + 'mem_max_mib': max(mems) if mems else None}) + out = {} + for svc, items in roles.items(): + lim = limits.get(svc) + mean = statistics.mean(i['cpu_mean'] for i in items) + out[svc] = { + 'containers': len(items), + 'cpu_pct_mean_per_container': round(mean, 1), + 'cpu_pct_max_per_container': round(max(i['cpu_max'] for i in items), 1), + # 100% = весь лимит контейнера; ≥85% считаем насыщением. + 'cpu_utilization_of_limit': round(mean / (lim * 100), 3) if lim else None, + 'mem_max_mib': round(max((i['mem_max_mib'] or 0) for i in items), 1), + } + pg = [x for x in sampler.pg if t_from <= x[0] <= t_to] + if pg: + out['postgres_connections'] = {'active_max': max(x[1] for x in pg), + 'active_mean': round(statistics.mean(x[1] for x in pg), 1), + 'total_max': max(x[2] for x in pg)} + return out + + +def pool_delta(before, after): + acq = empty = dur = 0 + max_conns = 0 + for cid, a in after.items(): + b = before.get(cid, {}) + acq += a['acquire_count'] - b.get('acquire_count', 0) + empty += a['empty_acquire_count'] - b.get('empty_acquire_count', 0) + dur += a['acquire_duration_ms'] - b.get('acquire_duration_ms', 0) + max_conns += a['max_conns'] + return {'acquires': acq, 'empty_acquire_ratio': round(empty / acq, 4) if acq else None, + 'avg_acquire_wait_ms': round(dur / acq, 3) if acq else None, 'pool_max_conns_total': max_conns} + + +def done_keys(path): + keys = set() + if path.exists(): + for line in path.read_text(encoding='utf-8').splitlines(): + try: + r = json.loads(line) + keys.add((r['series'], r['config'], r['concurrency'], r['repeat'])) + except (ValueError, KeyError): + pass + return keys + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('--experiments', default='experiments/track1.json') + p.add_argument('--series', default='', help='comma-separated series names; default all') + p.add_argument('--output', default='evidence/track1/raw.jsonl') + p.add_argument('--quick', action='store_true', help='levels 4,16,64; 15s; 1 repeat') + p.add_argument('--resume', action='store_true') + p.add_argument('--configs', default='', help='comma-separated config labels to run; default all') + p.add_argument('--levels', default='', help='override levels, e.g. 4,16,64') + p.add_argument('--duration', default='', help='override measured duration, e.g. 15s') + p.add_argument('--warmup', default='', help='override warmup, e.g. 3s') + p.add_argument('--repeats', type=int, default=0, help='override repeats') + p.add_argument('--cleanup', action='store_true', help='docker compose down -v for the bench project at the end') + args = p.parse_args() + + exp = json.loads((ROOT / args.experiments).read_text(encoding='utf-8')) + out = ROOT / args.output + out.parent.mkdir(parents=True, exist_ok=True) + skip = done_keys(out) if args.resume else set() + wanted = {s for s in args.series.split(',') if s} + stack = Stack(exp['project'], exp['lb_port']) + + probe = subprocess.run(['docker', 'version', '--format', '{{.Server.Version}}'], capture_output=True, text=True) + if probe.returncode != 0: + raise SystemExit('Docker Engine недоступен (docker version: %s). ' + 'Запустите Docker Desktop и дождитесь "Engine running"; ' + 'на Windows нужны включённая виртуализация и WSL2.' % (probe.stderr.strip().splitlines() or ['?'])[-1]) + sh(['go', 'build', '-o', str(BENCH), './cmd/bench']) + host = {'host_cpus': os.cpu_count(), 'docker': sh(['docker', 'version', '--format', '{{.Server.Version}}'], check=False), + 'docker_cpus': sh(['docker', 'info', '--format', '{{.NCPU}}'], check=False), + 'docker_mem_bytes': sh(['docker', 'info', '--format', '{{.MemTotal}}'], check=False)} + print('host:', json.dumps(host)) + built = False + + for series in exp['series']: + if wanted and series['name'] not in wanted: + continue + load = dict(exp['load']) + load['levels'] = series.get('levels', load['levels']) + load['repeats'] = series.get('repeats', load['repeats']) + if args.quick: + load.update(levels=[4, 16, 64] if series['name'] != 'D_improvement' else [32], duration='15s', + warmup='3s', repeats=1) + if args.levels: + load['levels'] = [int(x) for x in args.levels.split(',')] + for k in ('duration', 'warmup', 'repeats'): + if getattr(args, k): + load[k] = getattr(args, k) + only = {c for c in args.configs.split(',') if c} + for cfg in series['configs']: + if only and cfg['label'] not in only: + continue + env = dict(os.environ) + env.update(exp['base_env']) + env.update({k: v for k, v in cfg.items() if k != 'label'}) + env.setdefault('API_MEMORY', '256M') + env['LB_PORT'] = str(exp['lb_port']) + env['LB_STATS_PORT'] = str(exp['lb_port'] + 324) + todo = [(lvl, rep) for lvl in load['levels'] for rep in range(load['repeats']) + if (series['name'], cfg['label'], lvl, rep) not in skip] + if not todo: + continue + print('== %s / %s' % (series['name'], cfg['label']), flush=True) + stack.up(env, build=not built) + built = True + n = int(env['API_REPLICAS']) + stack.wait_balanced(n) + stack.pad_redis(exp.get('redis_padding_keys', 0)) + containers = stack.containers() + config_env = {k: env[k] for k in ('API_REPLICAS', 'API_CPUS', 'API_MEMORY', 'PG_CPUS', 'LB_CPUS', + 'REDIS_CPUS', 'DB_POOL_MAX', 'CACHE_INVALIDATION', 'LB_BALANCE')} + for lvl, rep in todo: + before = stack.pool_stats(containers) + sampler = Sampler(stack, containers) + sampler.start() + t_start = time.monotonic() + warm = float(load['warmup'].rstrip('s')) + dur = float(load['duration'].rstrip('s')) + line = sh([str(BENCH), '-base-url', stack.base, '-concurrency', str(lvl), + '-duration', load['duration'], '-warmup', load['warmup'], + '-write-ratio', str(load['write_ratio']), '-chats', str(load['chats']), + '-label', '%s/%s' % (series['name'], cfg['label'])], timeout=dur + warm + 300) + sampler.stop.set() + sampler.join(timeout=30) + after = stack.pool_stats(containers) + bench = json.loads(line.splitlines()[-1]) + rec = {'series': series['name'], 'config': cfg['label'], 'concurrency': lvl, 'repeat': rep, + 'load': {k: load[k] for k in ('duration', 'warmup', 'write_ratio', 'chats')}, + 'env': config_env, 'host': host, 'bench': bench, + 'resources': summarize_resources(sampler, containers, env, t_start + warm, t_start + warm + dur), + 'pool': pool_delta(before, after)} + with out.open('a', encoding='utf-8') as f: + f.write(json.dumps(rec, ensure_ascii=False) + '\n') + print(' c=%-3d rep=%d ok_rps=%.1f p95=%.1fms err=%.4f' % ( + lvl, rep, bench['ok_rps'], bench['latency_ms']['p95'], bench['error_ratio']), flush=True) + + if args.cleanup: + # Удаляет ТОЛЬКО bench-проект и его синтетические volumes. + stack.compose('down', '-v') + print('raw results:', out) + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/track1_report.py b/scripts/track1_report.py new file mode 100644 index 0000000..533dbb9 --- /dev/null +++ b/scripts/track1_report.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +"""Анализ трека 1: evidence/track1/raw.jsonl → summary.csv, summary.md, report.html. + +Правила анализа (фиксированы заранее, чтобы не подгонять выводы под данные): + * агрегат по повторам — медиана; разброс — min..max; + * точка насыщения конфигурации — первый уровень параллелизма, на котором + медианный ok_rps вырос меньше чем на 10% относительно предыдущего уровня; + * узкое место — роль (api/postgres/redis/lb) с наибольшей утилизацией CPU + от своего лимита на уровне насыщения; ≥0.85 — «насыщена»; дополнительно + признак пула: доля acquire без свободного соединения и среднее ожидание; + * улучшение «подтверждено», если на уровне хотя бы одного параллелизма ≥ уровня + насыщения baseline min(ok_rps кандидата) > max(ok_rps baseline) по всем повторам, + медиана p95 не хуже и доля ошибок не выше. +Только stdlib. +""" +import argparse +import csv +import html +import json +from pathlib import Path +import statistics + +ROOT = Path(__file__).resolve().parents[1] +ROLES = ('api', 'postgres', 'redis', 'lb') +SAT_GAIN = 0.10 +SAT_UTIL = 0.85 + + +def load(path): + rows = [] + for line in path.read_text(encoding='utf-8').splitlines(): + if line.strip(): + rows.append(json.loads(line)) + return rows + + +def med(xs): + xs = [x for x in xs if x is not None] + return statistics.median(xs) if xs else None + + +def aggregate(rows): + groups = {} + for r in rows: + groups.setdefault((r['series'], r['config'], r['concurrency']), []).append(r) + agg = {} + for key, rs in groups.items(): + b = [r['bench'] for r in rs] + a = { + 'repeats': len(rs), + 'env': rs[0]['env'], + 'ok_rps': med(x['ok_rps'] for x in b), + 'ok_rps_min': min(x['ok_rps'] for x in b), + 'ok_rps_max': max(x['ok_rps'] for x in b), + 'write_rps': med(x['ok_write_rps'] for x in b), + 'read_rps': med(x['ok_read_rps'] for x in b), + 'p50': med(x['latency_ms']['p50'] for x in b), + 'p95': med(x['latency_ms']['p95'] for x in b), + 'p99': med(x['latency_ms']['p99'] for x in b), + 'write_p95': med(x['write_ms']['p95'] for x in b), + 'error_ratio': med(x['error_ratio'] for x in b), + 'empty_acquire_ratio': med(r['pool'].get('empty_acquire_ratio') for r in rs), + 'acquire_wait_ms': med(r['pool'].get('avg_acquire_wait_ms') for r in rs), + 'pg_active_max': med(r['resources'].get('postgres_connections', {}).get('active_max') for r in rs), + } + for role in ROLES: + a['util_' + role] = med(r['resources'].get(role, {}).get('cpu_utilization_of_limit') for r in rs) + agg[key] = a + return agg + + +def series_order(rows): + seen, order = set(), [] + for r in rows: + k = (r['series'], r['config']) + if k not in seen: + seen.add(k) + order.append(k) + return order + + +def configs_of(order, series): + return [c for s, c in order if s == series] + + +def levels_of(agg, series, config): + return sorted(l for s, c, l in agg if s == series and c == config) + + +def saturation(agg, series, config): + lv = levels_of(agg, series, config) + peak_l = max(lv, key=lambda l: agg[(series, config, l)]['ok_rps']) + knee = lv[-1] + for prev, cur in zip(lv, lv[1:]): + if agg[(series, config, cur)]['ok_rps'] < agg[(series, config, prev)]['ok_rps'] * (1 + SAT_GAIN): + knee = cur + break + a = agg[(series, config, knee)] + utils = {r: a['util_' + r] for r in ROLES if a['util_' + r] is not None} + bottleneck = max(utils, key=utils.get) if utils else None + return {'peak_level': peak_l, 'peak_rps': agg[(series, config, peak_l)]['ok_rps'], 'knee_level': knee, + 'bottleneck': bottleneck, 'bottleneck_util': utils.get(bottleneck), + 'saturated': bool(bottleneck and utils[bottleneck] >= SAT_UTIL), 'utils': utils, + 'pool_empty_ratio': a['empty_acquire_ratio'], 'pool_wait_ms': a['acquire_wait_ms']} + + +def improvement(rows, agg, series, baseline, candidate, from_level): + res = [] + for l in levels_of(agg, series, baseline): + if l < from_level or (series, candidate, l) not in agg: + continue + b = [r['bench'] for r in rows if (r['series'], r['config'], r['concurrency']) == (series, baseline, l)] + c = [r['bench'] for r in rows if (r['series'], r['config'], r['concurrency']) == (series, candidate, l)] + ab, ac = agg[(series, baseline, l)], agg[(series, candidate, l)] + confirmed = (min(x['ok_rps'] for x in c) > max(x['ok_rps'] for x in b) + and ac['p95'] <= ab['p95'] and ac['error_ratio'] <= ab['error_ratio']) + res.append({'level': l, 'rps_delta_pct': 100 * (ac['ok_rps'] / ab['ok_rps'] - 1) if ab['ok_rps'] else None, + 'p95_delta_pct': 100 * (ac['p95'] / ab['p95'] - 1) if ab['p95'] else None, + 'repeats': (len(b), len(c)), 'confirmed': confirmed}) + return res + + +def fmt(x, nd=1): + return '—' if x is None else ('%.*f' % (nd, x)) + + +# ---------- SVG ---------- +COLORS = ['--series-1', '--series-2', '--series-3', '--series-4'] +DASH = ['', '6 3', '2 3', '8 3 2 3'] + + +def line_chart(title, xlabels, series, ylabel): + """series: [(name, [y or None per x])]. Категориальная ось X (уровни параллелизма).""" + W, H, L, R, T, B = 640, 300, 56, 120, 16, 40 + pw, ph = W - L - R, H - T - B + ys = [y for _, vals in series for y in vals if y is not None] + ymax = max(ys) * 1.1 if ys else 1 + step = 10 ** max(0, len(str(int(ymax))) - 1) + for m in (1, 2, 5, 10): + if ymax / (step * m) <= 6: + step *= m + break + xs = [L + (pw * i / (len(xlabels) - 1) if len(xlabels) > 1 else pw / 2) for i in range(len(xlabels))] + yv = lambda v: T + ph - ph * v / ymax + o = ['' % (W, H, html.escape(title))] + v = 0 + while v <= ymax: + o.append('' % (L, L + pw, yv(v), yv(v))) + o.append('%g' % (L - 6, yv(v), v)) + v += step + o.append('' % (L, L + pw, T + ph, T + ph)) + for x, lab in zip(xs, xlabels): + o.append('%s' % (x, T + ph + 16, lab)) + o.append('параллелизм (closed-loop воркеры)' % (L + pw / 2, H - 4)) + o.append('%s' % (L, T - 4 if T > 12 else 10, html.escape(ylabel))) + for i, (name, vals) in enumerate(series): + col, dash = COLORS[i % 4], DASH[i % 4] + pts = [(x, yv(y), y, lab) for x, y, lab in zip(xs, vals, xlabels) if y is not None] + if not pts: + continue + d = ' '.join(('M' if j == 0 else 'L') + '%.1f %.1f' % (p[0], p[1]) for j, p in enumerate(pts)) + o.append('' % (d, col, dash)) + for x, y, val, lab in pts: + tip = '%s · c=%s · %s' % (name, lab, fmt(val)) + o.append('' % (x, y, col, html.escape(tip))) + o.append('' % (x, y, html.escape(tip))) + lx, ly = pts[-1][0], pts[-1][1] + o.append('%s' % (lx + 8, ly + (i - 1.5) * 3, html.escape(name))) + o.append('') + legend = ''.join('%s' % (COLORS[i % 4], DASH[i % 4], html.escape(n)) + for i, (n, _) in enumerate(series)) + return '
%s
%s
%s
' % (html.escape(title), legend, ''.join(o)) + + +CSS = ''' +.viz-root{color-scheme:light;--surface-1:#fcfcfb;--page:#f9f9f7;--text-primary:#0b0b0b;--text-secondary:#52514e; +--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--border:rgba(11,11,11,.10); +--series-1:#2a78d6;--series-2:#eb6834;--series-3:#1baf7a;--series-4:#eda100} +@media (prefers-color-scheme:dark){:root:where(:not([data-theme="light"])) .viz-root{color-scheme:dark;--surface-1:#1a1a19; +--page:#0d0d0d;--text-primary:#f0efec;--text-secondary:#c3c2b7;--grid:#2c2c2a;--axis:#383835;--border:rgba(255,255,255,.10); +--series-1:#3987e5;--series-2:#d95926;--series-3:#199e70;--series-4:#c98500}} +:root[data-theme="dark"] .viz-root{color-scheme:dark;--surface-1:#1a1a19;--page:#0d0d0d;--text-primary:#f0efec; +--text-secondary:#c3c2b7;--grid:#2c2c2a;--axis:#383835;--border:rgba(255,255,255,.10); +--series-1:#3987e5;--series-2:#d95926;--series-3:#199e70;--series-4:#c98500} +body{margin:0;background:var(--page)} +.viz-root{font:14px/1.45 system-ui,sans-serif;color:var(--text-primary);background:var(--page);padding:16px;max-width:1100px;margin:auto} +h1{font-size:22px}h2{font-size:18px;margin-top:32px}p,li{color:var(--text-secondary)} +.charts{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(320px,100%),1fr));gap:16px} +figure{margin:0;min-width:0;background:var(--surface-1);border:1px solid var(--border);border-radius:8px;padding:12px} +figcaption{font-weight:600;margin-bottom:6px}svg{width:100%;height:auto;display:block} +.legend{display:flex;flex-wrap:wrap;gap:12px;font-size:12px;color:var(--text-secondary);margin-bottom:4px} +.key{display:inline-flex;align-items:center;gap:4px} +.grid{stroke:var(--grid);stroke-width:1}.axis{stroke:var(--axis);stroke-width:1} +.tick{fill:var(--muted);font-size:11px}.dlabel{fill:var(--text-secondary);font-size:11px} +.pt{stroke:var(--surface-1);stroke-width:2}.hit{fill:transparent;cursor:default} +table{border-collapse:collapse;width:100%;font-size:12px;background:var(--surface-1);font-variant-numeric:tabular-nums} +th,td{border-bottom:1px solid var(--grid);padding:4px 6px;text-align:right}th:first-child,td:first-child{text-align:left} +.wrap{overflow-x:auto} +#tip{position:fixed;pointer-events:none;background:var(--surface-1);color:var(--text-primary);border:1px solid var(--border); +border-radius:6px;padding:4px 8px;font-size:12px;display:none;box-shadow:0 2px 8px rgba(0,0,0,.15)} +''' +JS = ''' +const tip=document.getElementById('tip'); +document.querySelectorAll('[data-tip]').forEach(el=>{ + el.addEventListener('mousemove',e=>{tip.textContent=el.dataset.tip;tip.style.display='block'; + tip.style.left=Math.min(e.clientX+12,innerWidth-220)+'px';tip.style.top=(e.clientY+12)+'px'}); + el.addEventListener('mouseleave',()=>tip.style.display='none')}); +''' + + +def table(headers, rows): + h = ''.join('%s' % html.escape(x) for x in headers) + b = ''.join('%s' % ''.join('%s' % html.escape(str(c)) for c in r) for r in rows) + return '
%s%s
' % (h, b) + + +def main(): + p = argparse.ArgumentParser() + p.add_argument('--input', default='evidence/track1/raw.jsonl') + p.add_argument('--experiments', default='experiments/track1.json') + p.add_argument('--outdir', default='evidence/track1') + args = p.parse_args() + src = ROOT / args.input + if not src.exists() or not src.read_text(encoding='utf-8').strip(): + raise SystemExit('Нет данных: %s отсутствует или пуст. Сначала успешно выполните scripts/track1.py ' + '(его вывод должен содержать строки "c=... ok_rps=...").' % src) + rows = load(src) + exp = json.loads((ROOT / args.experiments).read_text(encoding='utf-8')) + titles = {s['name']: s for s in exp['series']} + agg = aggregate(rows) + order = series_order(rows) + outdir = ROOT / args.outdir + outdir.mkdir(parents=True, exist_ok=True) + + headers = ['series', 'config', 'c', 'repeats', 'ok_rps', 'rps_min', 'rps_max', 'write_rps', 'read_rps', 'p50_ms', + 'p95_ms', 'p99_ms', 'err', 'util_api', 'util_pg', 'util_redis', 'util_lb', 'pool_empty', 'pool_wait_ms', 'pg_active'] + csv_rows = [] + for s, c in order: + for l in levels_of(agg, s, c): + a = agg[(s, c, l)] + csv_rows.append([s, c, l, a['repeats'], fmt(a['ok_rps']), fmt(a['ok_rps_min']), fmt(a['ok_rps_max']), + fmt(a['write_rps']), fmt(a['read_rps']), fmt(a['p50'], 2), fmt(a['p95'], 2), fmt(a['p99'], 2), + fmt(a['error_ratio'], 4), fmt(a['util_api'], 2), fmt(a['util_postgres'], 2), + fmt(a['util_redis'], 2), fmt(a['util_lb'], 2), fmt(a['empty_acquire_ratio'], 3), + fmt(a['acquire_wait_ms'], 2), fmt(a['pg_active_max'], 0)]) + with (outdir / 'summary.csv').open('w', newline='', encoding='utf-8') as f: + csv.writer(f).writerows([headers] + csv_rows) + + md = ['# Трек 1 — сводка (сгенерировано scripts/track1_report.py)', '', + 'Медианы по повторам; util_* — доля CPU-лимита контейнера роли; pool_empty — доля acquire без свободного соединения.', ''] + body = ['

Трек 1 — цена масштабирования

', + '

Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.

'] + for name in dict.fromkeys(s for s, _ in order): + meta = titles.get(name, {'title': name, 'hypothesis': ''}) + cfgs = configs_of(order, name) + lv = sorted({l for c in cfgs for l in levels_of(agg, name, c)}) + xl = [str(l) for l in lv] + get = lambda c, k: [agg[(name, c, l)][k] if (name, c, l) in agg else None for l in lv] + body.append('

%s — %s

Гипотеза: %s

' % (name, html.escape(meta['title']), html.escape(meta['hypothesis']))) + body.append('
%s%s
' % ( + line_chart('Успешные RPS', xl, [(c, get(c, 'ok_rps')) for c in cfgs[:4]], 'ok RPS'), + line_chart('p95 задержки, мс', xl, [(c, get(c, 'p95')) for c in cfgs[:4]], 'мс'))) + sat_rows = [] + md += ['## %s — %s' % (name, meta['title']), '', '**Гипотеза:** ' + meta['hypothesis'], '', + '| config | пик RPS | c пика | c насыщения | узкое место (util) | pool empty / wait ms |', '|---|---|---|---|---|---|'] + base_peak = None + for c in cfgs: + st = saturation(agg, name, c) + base_peak = base_peak or st['peak_rps'] + bn = '%s (%s)%s' % (st['bottleneck'], fmt(st['bottleneck_util'], 2), ' — насыщена' if st['saturated'] else '') + pool = '%s / %s' % (fmt(st['pool_empty_ratio'], 3), fmt(st['pool_wait_ms'], 2)) + md.append('| %s | %s | %s | %s | %s | %s |' % (c, fmt(st['peak_rps']), st['peak_level'], st['knee_level'], bn, pool)) + sat_rows.append([c, fmt(st['peak_rps']), '%.2f×' % (st['peak_rps'] / base_peak) if base_peak else '—', + st['peak_level'], st['knee_level'], bn, pool]) + body.append(table(['config', 'пик RPS', 'к первой', 'c пика', 'c насыщения', 'узкое место', 'pool empty / wait ms'], sat_rows)) + if name.startswith('D') and cfgs: + baseline = cfgs[0] + from_level = saturation(agg, name, baseline)['knee_level'] + imp_rows = [] + md += ['', 'Сравнение с `%s` (уровни ≥ насыщения baseline):' % baseline, '', + '| кандидат | c | ΔRPS % | Δp95 % | повторы b/c | подтверждено |', '|---|---|---|---|---|---|'] + for c in cfgs[1:]: + for r in improvement(rows, agg, name, baseline, c, min(from_level, max(levels_of(agg, name, baseline)))): + row = [c, r['level'], fmt(r['rps_delta_pct']), fmt(r['p95_delta_pct']), '%d/%d' % r['repeats'], + 'да' if r['confirmed'] else 'нет'] + imp_rows.append(row) + md.append('| %s |' % ' | '.join(str(x) for x in row)) + body.append('

Кандидаты против %s

' % html.escape(baseline)) + body.append(table(['кандидат', 'c', 'ΔRPS %', 'Δp95 %', 'повторы b/c', 'подтверждено'], imp_rows)) + md.append('') + series_rows = [r for r in csv_rows if r[0] == name] + body.append('
Все точки серии%s
' % table(headers[1:], [r[1:] for r in series_rows])) + (outdir / 'summary.md').write_text('\n'.join(md) + '\n', encoding='utf-8') + page = ('' + 'Трек 1 отчёт
%s
' + '') % (CSS, ''.join(body), JS) + (outdir / 'report.html').write_text(page, encoding='utf-8') + print('written:', outdir / 'summary.csv', outdir / 'summary.md', outdir / 'report.html') + + +if __name__ == '__main__': + main() diff --git a/scripts/win/restart.cmd b/scripts/win/restart.cmd new file mode 100644 index 0000000..c633b51 --- /dev/null +++ b/scripts/win/restart.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\restart.sh" %* diff --git a/scripts/win/restore.cmd b/scripts/win/restore.cmd new file mode 100644 index 0000000..f5cf5c8 --- /dev/null +++ b/scripts/win/restore.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\restore.sh" %* diff --git a/scripts/win/stop-one.cmd b/scripts/win/stop-one.cmd new file mode 100644 index 0000000..fe8f128 --- /dev/null +++ b/scripts/win/stop-one.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\stop-one.sh" %* diff --git a/tests/failover_series.py b/tests/failover_series.py new file mode 100644 index 0000000..dcb4752 --- /dev/null +++ b/tests/failover_series.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Серия отказов под нагрузкой (уровень 4): поочерёдно останавливает КАЖДУЮ +API-реплику (docker stop → SIGTERM → drain), восстанавливает её и переходит +к следующей. Во время всей серии идёт closed-loop нагрузка через LB: +POST сообщения (при ошибке повтор с тем же Idempotency-Key) и GET истории. + +Измеряется на каждую реплику: RPS до/во время/после, число ошибок, время от +начала остановки до последней ошибки (recovery), время до исчезновения реплики +из ответов LB и время восстановления реплики после docker start. +В конце проверяется: все подтверждённые сообщения на месте, дублей нет. + +Скрипт сам вызывает docker CLI (это не публичный тест), запускать из корня репозитория. +""" +from concurrent.futures import ThreadPoolExecutor +import json +from pathlib import Path +import subprocess +import threading +import time +import uuid +from client import Client, Failure, arguments, check, run +from resilience import history + +ROOT = Path(__file__).resolve().parents[1] + + +def docker(*args): + return subprocess.run(['docker', *args], cwd=ROOT, check=True, capture_output=True, text=True).stdout.strip() + + +def api_containers(): + return docker('compose', 'ps', '-q', 'api').split() + + +def health(cid): + return docker('inspect', '-f', '{{.State.Health.Status}}', cid) + + +class Load: + def __init__(self, args, actor, reader, chat, concurrency): + self.args, self.actor, self.reader, self.chat = args, actor, reader, chat + self.concurrency = concurrency + self.events = [] # (t, kind, ok, instance) + self.confirmed = [] # подтверждённые Message + self.lock = threading.Lock() + self.stop = threading.Event() + + def record(self, kind, ok, instance=None): + with self.lock: + self.events.append((time.monotonic(), kind, ok, instance)) + + def worker(self, n): + c = Client(self.args.base_url, self.args.ca_file, timeout=3) + path = '/api/v1/chats/' + self.chat['id'] + '/messages?limit=20' + key, text, i = None, None, 0 + while not self.stop.is_set(): + if key is None: + key = uuid.uuid4().hex + text = 'series-%d-%d-%s' % (n, i, key) + i += 1 + try: + r = c.message(self.actor, self.chat, text, key=key) + self.record('write', True, r['headers'].get('X-Instance-Id')) + with self.lock: + self.confirmed.append(r['json']) + key = None + except Failure: + self.record('write', False) # неопределённый результат: тот же ключ + try: + r = c.call('GET', path, actor=self.reader, schema='MessagePage') + self.record('read', True, r['headers'].get('X-Instance-Id')) + except Failure: + self.record('read', False) + + def __enter__(self): + self.pool = ThreadPoolExecutor(max_workers=self.concurrency) + self.futures = [self.pool.submit(self.worker, n) for n in range(self.concurrency)] + return self + + def __exit__(self, *exc): + self.stop.set() + for f in self.futures: + f.result() + self.pool.shutdown() + + def window(self, a, b): + with self.lock: + ev = [e for e in self.events if a <= e[0] < b] + ok = sum(1 for e in ev if e[2]) + return {'seconds': round(b - a, 2), 'ok': ok, 'errors': len(ev) - ok, + 'ok_rps': round(ok / (b - a), 1) if b > a else None} + + +def main(): + def configure(p): + p.add_argument('--concurrency', type=int, default=4) + p.add_argument('--warmup', type=float, default=5) + p.add_argument('--observe', type=float, default=15) + p.add_argument('--output', default=None) + args = arguments('Stop each API replica in turn under load; collect RPS/errors/recovery', configure) + c = Client(args.base_url, args.ca_file) + alice, bob, _, chat = c.bootstrap() + replicas = api_containers() + check(len(replicas) >= 2, 'need at least 2 api containers') + results = [] + with Load(args, alice, bob, chat, args.concurrency) as load: + time.sleep(args.warmup) + for cid in replicas: + target = cid[:12] + before_start = time.monotonic() - args.warmup + t0 = time.monotonic() + docker('stop', '-t', '15', cid) + stop_seconds = time.monotonic() - t0 + time.sleep(max(0.0, args.observe - stop_seconds)) + t_end = time.monotonic() + with load.lock: + after = [e for e in load.events if e[0] >= t0] + errs = [e[0] for e in after if not e[2]] + served = [e[0] for e in after if e[2] and e[3] == target] + row = { + 'target_instance': target, + 'docker_stop_seconds': round(stop_seconds, 2), + 'before': load.window(before_start, t0), + 'during_stop_and_observe': load.window(t0, t_end), + 'errors_after_stop': len(errs), + 'recovery_seconds': round(max(errs) - t0, 2) if errs else 0.0, + 'target_last_served_after_stop_seconds': round(max(served) - t0, 2) if served else None, + 'other_instances_after': sorted({e[3] for e in after if e[2] and e[3] != target}), + } + # Восстановление реплики и её возврат в балансировку. + r0 = time.monotonic() + docker('start', cid) + while health(cid) != 'healthy': + check(time.monotonic() - r0 < 60, 'replica did not become healthy') + time.sleep(0.5) + healthy_at = time.monotonic() - r0 + while True: + with load.lock: + seen = any(e[0] > r0 and e[2] and e[3] == target for e in load.events) + if seen: + break + check(time.monotonic() - r0 < 60, 'replica not seen behind LB after restore') + time.sleep(0.2) + row['restore_healthy_seconds'] = round(healthy_at, 2) + row['restore_serving_via_lb_seconds'] = round(time.monotonic() - r0, 2) + results.append(row) + print(json.dumps(row, ensure_ascii=False)) + time.sleep(3) + total = load.window(load.events[0][0], time.monotonic()) + confirmed = list(load.confirmed) + + messages = history(c, bob, chat) + ids = [m['id'] for m in messages] + texts = [m['text'] for m in messages] + check(len(ids) == len(set(ids)), 'duplicated message IDs') + check(len(texts) == len(set(texts)), 'retry with same key created a duplicate') + by_id = {m['id']: m for m in messages} + lost = [m for m in confirmed if by_id.get(m['id']) != m] + check(not lost, '%d confirmed messages lost/changed' % len(lost)) + summary = {'concurrency': args.concurrency, 'replicas': len(replicas), 'total': total, + 'confirmed_writes': len(confirmed), 'stored_messages': len(messages), + 'duplicates': 0, 'lost_confirmed': 0, 'per_replica': results} + text = json.dumps(summary, ensure_ascii=False, indent=2) + if args.output: + Path(args.output).write_text(text + '\n', encoding='utf-8') + print(text) + print('PASS: every replica stopped and restored under load; no lost or duplicated messages.') + + +if __name__ == '__main__': + run(main) diff --git a/tests/idempotency_concurrent.py b/tests/idempotency_concurrent.py new file mode 100644 index 0000000..90d71d2 --- /dev/null +++ b/tests/idempotency_concurrent.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +"""Конкурентный повтор POST сообщения с одним Idempotency-Key через LB (lab3). + +Каждый раунд: N потоков (каждый со своим соединением) по барьеру одновременно +отправляют одинаковый body с одинаковым ключом. Ожидаем: все ответы 201 с одним +и тем же Message, запросы обслужены ≥2 репликами, в истории ровно одно сообщение. +Затем тот же ключ с другим body — 409; тот же ключ в другом чате — новое сообщение. +""" +from concurrent.futures import ThreadPoolExecutor +import json +import threading +import uuid +from client import Client, Failure, arguments, check, run +from resilience import history + + +def main(): + def configure(p): + p.add_argument('--rounds', type=int, default=10) + p.add_argument('--parallel', type=int, default=16) + p.add_argument('--output', default=None) + args = arguments('Concurrent Idempotency-Key replay across replicas', configure) + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + other = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Второй чат', 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json'] + + rounds = [] + all_instances = set() + for r in range(args.rounds): + key = 'conc-' + uuid.uuid4().hex + text = 'Конкурентный повтор %d %s' % (r, key) + barrier = threading.Barrier(args.parallel) + + def worker(_): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier.wait() + try: + resp = local.message(alice, chat, text, key=key) + return resp['status'], resp['json'], resp['headers'].get('X-Instance-Id') + except Failure as exc: + return 'fail', str(exc), None + + with ThreadPoolExecutor(max_workers=args.parallel) as pool: + results = list(pool.map(worker, range(args.parallel))) + statuses = [s for s, _, _ in results] + check(all(s == 201 for s in statuses), 'round %d: not all 201: %s' % (r, statuses)) + bodies = {json.dumps(b, sort_keys=True) for _, b, _ in results} + check(len(bodies) == 1, 'round %d: replays returned different messages' % r) + instances = {i for _, _, i in results} + all_instances |= instances + stored = [m for m in history(c, bob, chat) if m['text'] == text] + check(len(stored) == 1, 'round %d: %d messages stored for one key' % (r, len(stored))) + # Другой body с тем же ключом — 409, не новое сообщение. + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, + body={'text': text + ' (изменён)'}, headers={'Idempotency-Key': key}) + rounds.append({'round': r, 'requests': args.parallel, 'status_201': statuses.count(201), + 'distinct_messages': len(bodies), 'stored': len(stored), 'instances': len(instances)}) + + # Ключ уникален в пределах чата: тот же ключ в другом чате создаёт своё сообщение. + key = 'scope-' + uuid.uuid4().hex + a = c.message(alice, chat, 'scope', key=key)['json'] + b = c.message(alice, other, 'scope', key=key)['json'] + check(a['id'] != b['id'], 'key leaked across chats') + # Другой пользователь с тем же ключом — тоже независим. + d = c.message(bob, chat, 'scope', key=key)['json'] + check(d['id'] != a['id'], 'key leaked across users') + # Без ключа и с неверным ключом — 400. + path = '/api/v1/chats/' + chat['id'] + '/messages' + c.call('POST', path, 400, actor=alice, body={'text': 'x'}) + c.call('POST', path, 400, actor=alice, body={'text': 'x'}, headers={'Idempotency-Key': 'bad key!'}) + c.call('POST', path, 400, actor=alice, body={'text': 'x'}, headers={'Idempotency-Key': 'k' * 129}) + # Повтор проверяет доступ: посторонний с тем же ключом получает 404. + c.call('POST', path, 404, actor=eve, body={'text': 'scope'}, headers={'Idempotency-Key': key}) + + check(len(all_instances) >= 2, 'concurrent requests were served by fewer than 2 replicas') + summary = {'rounds': args.rounds, 'parallel_per_round': args.parallel, + 'distinct_instances_seen': len(all_instances), + 'duplicates_found': sum(x['stored'] - 1 for x in rounds), 'per_round': rounds} + text = json.dumps(summary, ensure_ascii=False, indent=2) + if args.output: + with open(args.output, 'w', encoding='utf-8') as f: + f.write(text + '\n') + print(text) + print('PASS: concurrent Idempotency-Key replay produced exactly one message per key.') + + +if __name__ == '__main__': + run(main) diff --git a/tests/negative.py b/tests/negative.py new file mode 100644 index 0000000..5cb2028 --- /dev/null +++ b/tests/negative.py @@ -0,0 +1,58 @@ +import base64 +import json +import sys +import urllib.request +import urllib.error + +BASE = (sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080").rstrip("/") +PASSWORD = "Example-only-not-a-real-secret-123" + +def post(path, body, headers=None): + req = urllib.request.Request(BASE + path, method="POST", + data=json.dumps(body).encode(), + headers={"Content-Type": "application/json", **(headers or {})}) + try: + with urllib.request.urlopen(req) as r: + return r.status, json.loads(r.read()) + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read()) + +def get(path, headers=None): + req = urllib.request.Request(BASE + path, headers=headers or {}) + try: + with urllib.request.urlopen(req) as r: + return r.status, json.loads(r.read()) + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read()) + +def main(): + failures = [] + + # 1. Неверный JSON → 400 + status, _ = post("/api/v1/users", "not-json") + if status != 400: + failures.append(f"invalid JSON: expected 400, got {status}") + + # 2. Невалидный username → 400 + status, _ = post("/api/v1/users", {"username": "AB", "display_name": "Test", "password": PASSWORD}) + if status != 400: + failures.append(f"invalid username: expected 400, got {status}") + + # 3. Отсутствие Bearer на /users/me → 401 + status, _ = get("/api/v1/users/me") + if status != 401: + failures.append(f"no auth: expected 401, got {status}") + + # 4. X-User-Id не даёт доступ → 401 + status, _ = get("/api/v1/users/me", {"X-User-Id": "00000000-0000-0000-0000-000000000000"}) + if status != 401: + failures.append(f"X-User-Id bypass: expected 401, got {status}") + + if failures: + for f in failures: + print(f"FAIL: {f}") + sys.exit(1) + print("PASS: negative checks") + +if __name__ == "__main__": + main() \ No newline at end of file