lab3: балансировка, идемпотентность, отказ реплики, трек 1

- 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 <noreply@anthropic.com>
This commit is contained in:
2026-10-23 17:24:54 +03:00
co-authored by Claude Opus 5.5
parent 0ab3a341aa
commit 2e7a80be92
68 changed files with 4747 additions and 17 deletions
+2
View File
@@ -18,3 +18,5 @@ __pycache__
node_modules
evidence
.DS_Store
bin
experiments
+12 -1
View File
@@ -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
+91
View File
@@ -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/
+54
View File
@@ -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"]
+27 -1
View File
@@ -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
+178 -15
View File
@@ -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` и заполнить таблицы.
+151
View File
@@ -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")
}
+328
View File
@@ -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
}
+131
View File
@@ -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:
@@ -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
}
]
}
+15
View File
@@ -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.
+72
View File
@@ -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"}
]
}
]
}
+21
View File
@@ -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
)
+43
View File
@@ -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=
+59
View File
@@ -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
+113
View File
@@ -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
}
+30
View File
@@ -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),
})
}
+25
View File
@@ -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),
})
}
+10
View File
@@ -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:"-"`
}
+25
View File
@@ -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),
})
}
+159
View File
@@ -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
}
+135
View File
@@ -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()
}
+39
View File
@@ -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
}
+77
View File
@@ -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
}
+111
View File
@@ -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()
}
+73
View File
@@ -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
}
+55
View File
@@ -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
}
+99
View File
@@ -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
}
+138
View File
@@ -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
}
+39
View File
@@ -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
}
+12
View File
@@ -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")
)
+23
View File
@@ -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)
}
+161
View File
@@ -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
}
+66
View File
@@ -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
}
+64
View File
@@ -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
}
+48
View File
@@ -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
}
+92
View File
@@ -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 ")
}
+86
View File
@@ -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)
}
+54
View File
@@ -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"`
}
+39
View File
@@ -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
}
+75
View File
@@ -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)})
}
@@ -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 <token> через 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)
}
@@ -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)
})
}
}
@@ -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(),
)
})
}
@@ -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)
})
}
@@ -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[:])
}
@@ -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))
})
}
}
+54
View File
@@ -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
}
+49
View File
@@ -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)
}
+158
View File
@@ -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
}
+6
View File
@@ -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;
+50
View File
@@ -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);
+1
View File
@@ -0,0 +1 @@
DROP TABLE IF EXISTS idempotency_keys;
+18
View File
@@ -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);
+67
View File
@@ -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
+16
View File
@@ -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)"
+16
View File
@@ -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
+17
View File
@@ -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}}'
+35
View File
@@ -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}}'
+25
View File
@@ -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
+316
View File
@@ -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())
+304
View File
@@ -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 = ['<svg viewBox="0 0 %d %d" role="img" aria-label="%s">' % (W, H, html.escape(title))]
v = 0
while v <= ymax:
o.append('<line class="grid" x1="%d" x2="%d" y1="%.1f" y2="%.1f"/>' % (L, L + pw, yv(v), yv(v)))
o.append('<text class="tick" x="%d" y="%.1f" text-anchor="end" dy="4">%g</text>' % (L - 6, yv(v), v))
v += step
o.append('<line class="axis" x1="%d" x2="%d" y1="%d" y2="%d"/>' % (L, L + pw, T + ph, T + ph))
for x, lab in zip(xs, xlabels):
o.append('<text class="tick" x="%.1f" y="%d" text-anchor="middle">%s</text>' % (x, T + ph + 16, lab))
o.append('<text class="tick" x="%d" y="%d" text-anchor="middle">параллелизм (closed-loop воркеры)</text>' % (L + pw / 2, H - 4))
o.append('<text class="tick" x="%d" y="%d">%s</text>' % (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('<path d="%s" fill="none" stroke="var(%s)" stroke-width="2" stroke-dasharray="%s" '
'stroke-linejoin="round" stroke-linecap="round"/>' % (d, col, dash))
for x, y, val, lab in pts:
tip = '%s · c=%s · %s' % (name, lab, fmt(val))
o.append('<circle class="pt" cx="%.1f" cy="%.1f" r="4" fill="var(%s)" data-tip="%s"/>' % (x, y, col, html.escape(tip)))
o.append('<circle class="hit" cx="%.1f" cy="%.1f" r="12" data-tip="%s"/>' % (x, y, html.escape(tip)))
lx, ly = pts[-1][0], pts[-1][1]
o.append('<text class="dlabel" x="%.1f" y="%.1f" dy="4">%s</text>' % (lx + 8, ly + (i - 1.5) * 3, html.escape(name)))
o.append('</svg>')
legend = ''.join('<span class="key"><svg width="22" height="10"><line x1="1" x2="21" y1="5" y2="5" stroke="var(%s)" '
'stroke-width="2" stroke-dasharray="%s"/></svg>%s</span>' % (COLORS[i % 4], DASH[i % 4], html.escape(n))
for i, (n, _) in enumerate(series))
return '<figure><figcaption>%s</figcaption><div class="legend">%s</div>%s</figure>' % (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('<th>%s</th>' % html.escape(x) for x in headers)
b = ''.join('<tr>%s</tr>' % ''.join('<td>%s</td>' % html.escape(str(c)) for c in r) for r in rows)
return '<div class="wrap"><table><thead><tr>%s</tr></thead><tbody>%s</tbody></table></div>' % (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 = ['<h1>Трек 1 — цена масштабирования</h1>',
'<p>Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.</p>']
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('<h2>%s — %s</h2><p><b>Гипотеза:</b> %s</p>' % (name, html.escape(meta['title']), html.escape(meta['hypothesis'])))
body.append('<div class="charts">%s%s</div>' % (
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('<h3>Кандидаты против %s</h3>' % 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('<details><summary>Все точки серии</summary>%s</details>' % table(headers[1:], [r[1:] for r in series_rows]))
(outdir / 'summary.md').write_text('\n'.join(md) + '\n', encoding='utf-8')
page = ('<!doctype html><html lang="ru"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">'
'<title>Трек 1 отчёт</title><style>%s</style></head><body><div class="viz-root">%s<div id="tip"></div></div>'
'<script>%s</script></body></html>') % (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()
+3
View File
@@ -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" %*
+3
View File
@@ -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" %*
+3
View File
@@ -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" %*
+171
View File
@@ -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)
+89
View File
@@ -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)
+58
View File
@@ -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()