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:
@@ -18,3 +18,5 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
bin
|
||||
experiments
|
||||
|
||||
+12
-1
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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")
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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.
|
||||
@@ -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"}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
)
|
||||
@@ -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=
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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:"-"`
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
)
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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 ")
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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"`
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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))
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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);
|
||||
@@ -0,0 +1 @@
|
||||
DROP TABLE IF EXISTS idempotency_keys;
|
||||
@@ -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);
|
||||
Executable
+67
@@ -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
|
||||
Executable
+16
@@ -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)"
|
||||
Executable
+16
@@ -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
|
||||
Executable
+17
@@ -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}}'
|
||||
Executable
+35
@@ -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}}'
|
||||
Executable
+25
@@ -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
|
||||
@@ -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())
|
||||
@@ -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()
|
||||
@@ -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" %*
|
||||
@@ -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" %*
|
||||
@@ -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" %*
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user