From bd28f1ae263f8d8c0eac9e1c8208949fd48c4f8a Mon Sep 17 00:00:00 2001 From: d1frend Date: Wed, 21 Oct 2026 13:51:35 +0300 Subject: [PATCH] =?UTF-8?q?=D0=BD=D0=B0=20=D0=BE=D1=86=D0=B5=D0=BD=D0=BA?= =?UTF-8?q?=D1=83=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 4 +- REPORT.md | 125 ++++++-- cmd/server/main.go | 14 +- compose.yaml | 31 +- evidence/lab3-summary.md | 83 ++++++ infrastructure/nginx/nginx.conf | 41 +++ internal/adapter/memory/repository.go | 73 ++++- internal/adapter/postgres/messages.go | 181 ++++++++++-- internal/application/commands.go | 9 +- internal/application/errors.go | 9 +- internal/application/messages.go | 27 +- internal/application/ports.go | 13 +- internal/application/service.go | 44 ++- internal/config/config.go | 49 +++- internal/config/instance_id_test.go | 35 +++ .../transport/http/handlers/create_message.go | 27 +- .../transport/http/middleware/instance_id.go | 15 + .../http/middleware/instance_id_test.go | 50 ++++ .../000002_message_idempotency.down.sql | 5 + migrations/000002_message_idempotency.up.sql | 54 ++++ scripts/restart.sh | 17 +- scripts/stop-one.sh | 32 ++ student_tests/idempotency_test.go | 275 ++++++++++++++++++ student_tests/messenger_test.go | 8 + 24 files changed, 1130 insertions(+), 91 deletions(-) create mode 100644 evidence/lab3-summary.md create mode 100644 infrastructure/nginx/nginx.conf create mode 100644 internal/config/instance_id_test.go create mode 100644 internal/transport/http/middleware/instance_id.go create mode 100644 internal/transport/http/middleware/instance_id_test.go create mode 100644 migrations/000002_message_idempotency.down.sql create mode 100644 migrations/000002_message_idempotency.up.sql create mode 100755 scripts/stop-one.sh create mode 100644 student_tests/idempotency_test.go diff --git a/.env.example b/.env.example index 4e64314..7a28197 100644 --- a/.env.example +++ b/.env.example @@ -1,9 +1,11 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# The transferred lab2 baseline still needs its Compose topology adapted to lab3. +# Compose publishes only the load balancer; API replicas stay on its network. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +# INSTANCE_ID is intentionally unset: each container uses its own hostname. +# INSTANCE_ID=api-replica-01 POSTGRES_USER=messenger POSTGRES_DB=messenger diff --git a/REPORT.md b/REPORT.md index 70ab308..2cea2d6 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,9 +1,13 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Чурилин, БВТ2301 +- Текущий завершённый уровень: оценка «3» +- Итоговая цель: оценка «5»; трек будет выбран после реализации уровня «4» +- Commit/PR: заполняется автором после локального коммита и публикации +- Использованные источники и библиотеки: преподавательские README/OpenAPI/tests, + документация Go, pgx, PostgreSQL, Docker Compose и Nginx. Для разбора + архитектуры, рефакторинга, реализации и проверок использовался OpenAI Codex; + решения проверены тестами и описанными ниже воспроизводимыми сценариями. ## Запуск из чистого clone @@ -23,8 +27,32 @@ chmod 600 secrets/*.txt cp .env.example .env ``` -Полная последовательность запуска, проверки LB и безопасной остановки будет -зафиксирована после завершения новой Compose-топологии lab3. +Единственная публичная точка входа — `http://localhost:8080`; контейнеры API не +публикуют порты на host. Последовательность запуска и проверки: + +```bash +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +make test +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +docker compose --env-file .env up -d --wait api +make test-persistence ACTION_SCRIPT=./scripts/restart.sh +``` + +`stop-one.sh` оставляет выбранную тестом реплику остановленной. Команда `up` в +примере явно возвращает желаемые две реплики перед следующей проверкой. +Обычная остановка не удаляет named volumes: + +```bash +docker compose --env-file .env down +``` + +Для демонстрации балансировки одним и тем же клиентом можно многократно вызвать +любой API endpoint через `localhost:8080` и сравнить `X-Instance-Id`. В проверке +20 последовательных health-запросов наблюдались оба процесса: 10 ответов от +одной реплики и 10 от другой. Запрос `/health/ready` непосредственно из Windows +PowerShell вернул HTTP 200 и `X-Instance-Id`, поэтому браузер Windows и будущий +frontend смогут использовать тот же `http://localhost:8080`. ## Архитектура и решения @@ -45,6 +73,18 @@ PostgreSQL остаётся источником истины для польз чата; его отказ не делает API неготовым и не отменяет подтверждённую запись в PostgreSQL. +Compose запускает один сервис `api` с `API_REPLICAS=2`. Реплики не имеют host +ports и разделяют PostgreSQL, включая таблицу сессий. Nginx — единственная +публичная точка входа; он использует `least_conn` и Docker DNS resolver с +повторным разрешением имени `api` раз в секунду. Sticky sessions не применяются. +Безопасные методы могут быть перенаправлены на другую реплику при сетевой ошибке. +Произвольные POST балансировщик автоматически не повторяет: после +неопределённого результата повтор сообщения выполняет клиент с тем же +`Idempotency-Key`, а создание пользователя/чата контрактом не идемпотентно. + +Миграции вынесены в одноразовый сервис `migrate`, завершение которого является +предусловием запуска API. Поэтому две реплики не конкурируют за изменение схемы. + Пагинационный курсор теперь формируется в application-слое из канонических полей границы `(created_at, id, scope_id)` и подписывается HMAC-SHA-256. Подпись не скрывает payload, но обнаруживает подмену. В scope входит пользователь для @@ -54,29 +94,78 @@ secret `cursor_signing_key`. Репозитории получают тольк типизированную границу и ничего не знают о формате HTTP-курсора. `.env.example` перечисляет реально читаемые приложением параметры PostgreSQL, -пула, readiness/shutdown, Redis-кэша и ключа курсора. `API_REPLICAS` и -`IDEMPOTENCY_TTL_SECONDS` зарезервированы для следующих этапов lab3. Секретных -значений в шаблоне нет: там указаны только пути внутри контейнера. +пула, readiness/shutdown, Redis-кэша, числа реплик, TTL идемпотентности и ключа +курсора. `API_REPLICAS` используется Compose, а `IDEMPOTENCY_TTL_SECONDS` читает +Go-приложение и не допускает значение меньше 86400 секунд. Секретных значений в +шаблоне нет: там указаны только пути внутри контейнера. + +Каждый процесс определяет стабильный `instance_id` один раз при загрузке +конфигурации. По умолчанию используется hostname контейнера; это одновременно +даёт уникальность между Compose-репликами и позволяет инфраструктурному hook +сопоставить `X-Instance-Id` с конкретным контейнером. Опциональный `INSTANCE_ID` +проверяется по безопасному для HTTP-заголовка шаблону. Сам middleware является +внешним относительно router/recovery, поэтому заголовок присутствует также на +health, 404/405 и восстановленных 500-ответах. + +POST сообщения принимает только ASCII-ключ по шаблону +`[A-Za-z0-9._:-]{1,128}`. HTTP-слой нормализует UUID чата и формирует канонический +path, application-слой хэширует SHA-256 не исходные bytes JSON, а типизированное +семантическое представление запроса. Поэтому форматирование и порядок JSON-полей +не влияют на повтор; задел под `attachment_ids` уже канонизирует отсутствующий +список как пустой. + +Область уникальности в `message_idempotency` состоит из пользователя, метода, +канонического пути и ключа. В одной PostgreSQL-транзакции сначала захватывается +эта область через primary key, затем создаётся Message. Отложенный foreign key +позволяет заранее записать будущий `message_id`, но проверяется при commit. При +гонке вторая реплика ждёт разрешения уникального конфликта и затем либо возвращает +то же сообщение, либо отвечает 409 при другом request hash. Любая ошибка до +commit откатывает и бизнес-эффект, и запись ключа, поэтому transient 5xx не +фиксируется как успешный результат. Перед replay снова выполняются обычная +проверка bearer-сессии и проверка членства в чате. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Воспроизводимая конфигурация и качество Go | `make check && make go-check && make validate PYTHON=../mtusi2026lab2/.venv/bin/python` | форматирование, tests, race detector, vet, Compose config и OpenAPI validation завершились без ошибок | `evidence/lab3-summary.md` | +| Две API-реплики за одним LB | `docker compose --env-file .env up -d --build --wait`; 20 health-запросов через `:8080` | наружу опубликован только Nginx; два разных `X-Instance-Id`, по 10 ответов от каждого | `compose.yaml`, `infrastructure/nginx/nginx.conf`, `evidence/lab3-summary.md` | +| Публичный smoke lab3 | `make test` | `tests/smoke.py` завершился `PASS: lab3 public API scenario` | `evidence/lab3-summary.md` | +| Общая сессия без sticky routing | smoke, затем failover и persistence через тот же bearer token | обе реплики обслуживали запросы; сессия работает после остановки API и рестартов | `evidence/lab3-summary.md` | +| Идемпотентность сообщения | `go test ./student_tests -run Idempotency`; 32 конкурентных POST с одним ключом через LB | один Message и ровно одна строка в PostgreSQL; другой payload даёт 409 | `student_tests/idempotency_test.go`, `evidence/lab3-summary.md` | +| Failover каждой API-реплики | два последовательных запуска `make test-failover ACTION_SCRIPT=./scripts/stop-one.sh` с восстановлением между ними | реально остановлены `api-2`, затем `api-1`; получено 142/143 успешных записи, 0 ошибок, восстановление 0.963/0.750 с | `scripts/stop-one.sh`, `evidence/lab3-summary.md` | +| Persistence после рестартов | `make test-persistence ACTION_SCRIPT=./scripts/restart.sh` | PASS; прежняя сессия и данные доступны после рестарта PostgreSQL, Redis, API и LB | `scripts/restart.sh`, `evidence/lab3-summary.md` | +| Миграции перед API | `docker compose --env-file .env ps -a` и логи `migrate` | миграции 1 и 2 применены; one-shot контейнер завершился с кодом 0; API healthy | `migrations/000002_message_idempotency.up.sql`, `evidence/lab3-summary.md` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Проведены функциональные эксперименты устойчивости, а не capacity benchmark. +Окружение: Windows + WSL2, Docker Engine 29.7.2, Docker Compose 5.5.0, две +API-реплики; лимиты CPU/RAM пока не задавались, максимальный пул БД — +10 соединений на реплику. Использовались синтетические данные; отдельного прогрева +и серии повторов не было. Поэтому результаты подтверждают корректность failover, +идемпотентности и сохранности данных, но не предельный RPS или p50/p95/p99. +Нагрузочный профиль с лимитами и повторами относится к следующему уровню. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Последовательная остановка `api-2` и `api-1` с восстановлением между тестами | LB обслуживает через оставшуюся реплику не позднее 10 с | 142 и 143 успешные записи; в обоих запусках 0 ошибок | первое восстановление 0.963 и 0.750 с; подтверждённой потери или дублей нет | +| Рестарт PostgreSQL, Redis, API и LB без удаления volumes | прежний token и данные сохраняются | `test-persistence` завершился PASS | уложилось в тайм-аут 90 с; потери данных нет | +| 32 одновременных POST с одним `Idempotency-Key` | один бизнес-эффект | 32 ответа 201 с одним Message ID; в БД одно сообщение | дубли отсутствуют | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Топология однохостовая: Nginx и PostgreSQL остаются single points of failure. + Репликация БД и несколько балансировщиков в требования уровня «3» не входят. +- Redis содержит только кэш, поэтому его потеря допустима. Отдельная + персистентность Redis для корректности API не требуется. +- Истёкшие записи идемпотентности удаляются лениво при повторном обращении к той + же области ключа. Индекс по `expires_at` оставлен для будущей периодической + очистки без изменения схемы. +- Resource limits, количественный нагрузочный эксперимент и сценарий rolling + update ещё не реализованы; это следующий этап уровня «4». +- Frontend на React + TypeScript + Vite будет отдельным этапом и отдельным + коммитом после фиксации уровня «3». Тогда же будет спроектирована cookie-based + авторизация с учётом текущего bearer-контракта API. +- Трек уровня «5» пока не заявлен: сначала необходимо завершить и измерить + обязательный уровень «4». diff --git a/cmd/server/main.go b/cmd/server/main.go index 342f6d0..4a1fca8 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -85,7 +85,12 @@ func main() { log.Fatalf("[FATAL] Invalid cursor configuration: %v", err) } - service, err := application.NewService(applicationStore, cursorCodec, cfg.SessionTTL) + service, err := application.NewService( + applicationStore, + cursorCodec, + cfg.SessionTTL, + application.WithIdempotencyTTL(cfg.IdempotencyTTL), + ) if err != nil { log.Fatalf("[FATAL] Application initialization failed: %v", err) } @@ -149,6 +154,7 @@ func main() { rootHandler = middleware.Recovery(rootHandler) rootHandler = middleware.Logger(rootHandler) rootHandler = middleware.RequestID(rootHandler) + rootHandler = middleware.InstanceID(cfg.InstanceID, rootHandler) server := &http.Server{ Addr: cfg.HTTPAddress(), @@ -161,7 +167,11 @@ func main() { serverErrors := make(chan error, 1) go func() { - log.Printf("[INFO] Server starting on %s", server.Addr) + log.Printf( + "[INFO] Server instance %s starting on %s", + cfg.InstanceID, + server.Addr, + ) serverErrors <- server.ListenAndServe() }() diff --git a/compose.yaml b/compose.yaml index 55036c4..e854ed5 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,4 +1,26 @@ services: + load-balancer: + image: nginx:1.30.6-alpine@sha256:970364228b1e4f932abc22d321932816782cca8a20b85a77552a7cfe9acfb3b5 + ports: + - "127.0.0.1:${APP_PORT:-8080}:8080" + volumes: + - ./infrastructure/nginx/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + api: + condition: service_healthy + healthcheck: + test: + [ + "CMD-SHELL", + "wget -qO- http://127.0.0.1:8080/health/ready || exit 1", + ] + interval: 5s + timeout: 3s + retries: 10 + start_period: 3s + stop_grace_period: 10s + restart: unless-stopped + postgres: image: postgres:16.15-alpine3.24@sha256:721873c34ceb9f8d8fc265984940dc982404c105f19ad51be9fdc5970a6080ea environment: @@ -72,6 +94,7 @@ services: APP_ENV: ${APP_ENV:-lab} SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} SESSION_STORE: ${SESSION_STORE:-postgres} CURSOR_SIGNING_KEY_FILE: ${CURSOR_SIGNING_KEY_FILE:-/run/secrets/cursor_signing_key} @@ -95,13 +118,17 @@ services: secrets: - database_url - cursor_signing_key - ports: - - "${APP_PORT:-8080}:${APP_PORT:-8080}" + expose: + - "8080" depends_on: postgres: condition: service_healthy + redis: + condition: service_healthy migrate: condition: service_completed_successfully + deploy: + replicas: ${API_REPLICAS:-2} healthcheck: test: [ diff --git a/evidence/lab3-summary.md b/evidence/lab3-summary.md new file mode 100644 index 0000000..ac79263 --- /dev/null +++ b/evidence/lab3-summary.md @@ -0,0 +1,83 @@ +# Lab 3 verification summary + +Дата проверки: 2026-10-20. + +Файл содержит обезличенную сводку воспроизводимых проверок. Bearer tokens, +пароли, ключи идемпотентности, UUID пользователей/чатов/сообщений и содержимое +локальных Docker secrets намеренно не сохранены. + +## Окружение + +- Windows + WSL2; +- Docker Engine 29.7.2; +- Docker Compose 5.5.0; +- две Compose-реплики сервиса `api`; +- единственный опубликованный endpoint: Nginx на `127.0.0.1:8080`; +- PostgreSQL и Redis доступны только внутри Compose network. + +## Статические проверки + +```text +go test ./... PASS +go test -race ./... PASS +go vet ./... PASS +make check PASS +make validate PASS +docker compose config PASS +shell syntax for hooks PASS +``` + +`make validate` запускался с Python virtual environment, где установлены +зависимости преподавательского validator. + +## Топология и smoke + +- migration 1 and migration 2 applied successfully; +- one-shot service `migrate` exited with code 0; +- оба API-контейнера перешли в `healthy`; +- 20 последовательных запросов к health через LB вернули два разных + `X-Instance-Id`: распределение 10/10; +- Windows PowerShell получил HTTP 200 и `X-Instance-Id` с + `http://localhost:8080/health/ready`; +- преподавательский `python3 tests/smoke.py` завершился строкой + `PASS: lab3 public API scenario`. + +## Failover API + +Команда: + +```bash +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +``` + +Наблюдение преподавательского теста: + +```text +run 1: + stopped container: api-2 + observed instances before action: 2 + successful writes / failures: 142 / 0 + first recovery: 0.963 seconds +run 2, after restoring api-2: + stopped container: api-1 + observed instances before action: 2 + successful writes / failures: 143 / 0 + first recovery: 0.750 seconds +both results: PASS +``` + +После первого запуска реплика была восстановлена; один health-запрос сдвинул +очередь LB, чтобы следующий synthetic message выбрал второй target. Hook +сопоставил `TARGET_INSTANCE_ID` с hostname контейнера и в каждом запуске +остановил только выбранную API-реплику. После тестов желаемое число +реплик было восстановлено командой `docker compose up -d --wait api`. + +## Persistence и идемпотентность + +- `make test-persistence ACTION_SCRIPT=./scripts/restart.sh`: PASS; после + рестарта PostgreSQL, Redis, всех API-реплик и Nginx прежние bearer session и + созданные данные сохранились; +- 32 конкурентных POST сообщения с одинаковыми semantic payload и + `Idempotency-Key` через Nginx вернули один Message ID; +- прямой запрос PostgreSQL подтвердил ровно одну строку сообщения; +- повтор с тем же scope/key и другим payload возвращает HTTP 409. diff --git a/infrastructure/nginx/nginx.conf b/infrastructure/nginx/nginx.conf new file mode 100644 index 0000000..2bde5a9 --- /dev/null +++ b/infrastructure/nginx/nginx.conf @@ -0,0 +1,41 @@ +worker_processes auto; + +events { + worker_connections 1024; +} + +http { + resolver 127.0.0.11 valid=1s ipv6=off; + + upstream api_backend { + zone api_backend 64k; + least_conn; + server api:8080 resolve max_fails=1 fail_timeout=1s; + } + + server { + listen 8080; + server_name _; + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_set_header Connection ""; + + proxy_connect_timeout 1s; + proxy_send_timeout 20s; + proxy_read_timeout 20s; + + # Safe methods may transparently move to another healthy peer. + # Nginx deliberately does not retry non-idempotent POST requests: + # the client retries message POSTs with its Idempotency-Key. + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + } + } +} diff --git a/internal/adapter/memory/repository.go b/internal/adapter/memory/repository.go index ad11c60..d2b6877 100644 --- a/internal/adapter/memory/repository.go +++ b/internal/adapter/memory/repository.go @@ -15,21 +15,36 @@ type memorySession struct { expiresAt time.Time } +type memoryIdempotencyScope struct { + actorID string + method string + canonicalPath string + key string +} + +type memoryIdempotencyResult struct { + requestHash [32]byte + message domain.Message + expiresAt time.Time +} + type MemoryRepository struct { legacy *MemoryStore - mu sync.RWMutex - passwordByUserID map[string]string - userIDByUsername map[string]string - sessionsByHashKey map[[32]byte]memorySession + mu sync.RWMutex + passwordByUserID map[string]string + userIDByUsername map[string]string + sessionsByHashKey map[[32]byte]memorySession + idempotencyByScope map[memoryIdempotencyScope]memoryIdempotencyResult } func NewMemoryRepository(legacy *MemoryStore) *MemoryRepository { return &MemoryRepository{ - legacy: legacy, - passwordByUserID: make(map[string]string), - userIDByUsername: make(map[string]string), - sessionsByHashKey: make(map[[32]byte]memorySession), + legacy: legacy, + passwordByUserID: make(map[string]string), + userIDByUsername: make(map[string]string), + sessionsByHashKey: make(map[[32]byte]memorySession), + idempotencyByScope: make(map[memoryIdempotencyScope]memoryIdempotencyResult), } } @@ -129,17 +144,49 @@ func (r *MemoryRepository) GetChatsForUser( return r.legacy.GetChatsForUser(userID, limit, cursor) } -func (r *MemoryRepository) CreateMessage( +func (r *MemoryRepository) CreateMessageIdempotently( ctx context.Context, - chatID string, - senderID string, - text string, + write application.IdempotentMessageWrite, ) (domain.Message, error) { if err := ctx.Err(); err != nil { return domain.Message{}, err } - return r.legacy.CreateMessage(chatID, senderID, text) + scope := memoryIdempotencyScope{ + actorID: write.ActorID, + method: write.Method, + canonicalPath: write.CanonicalPath, + key: write.Key, + } + now := time.Now().UTC() + + r.mu.Lock() + defer r.mu.Unlock() + + if _, err := r.legacy.GetChatByID(write.ChatID, write.ActorID); err != nil { + return domain.Message{}, err + } + + if stored, exists := r.idempotencyByScope[scope]; exists { + if stored.expiresAt.After(now) { + if stored.requestHash != write.RequestHash { + return domain.Message{}, application.ErrIdempotencyConflict + } + return stored.message, nil + } + delete(r.idempotencyByScope, scope) + } + + message, err := r.legacy.CreateMessage(write.ChatID, write.ActorID, write.Text) + if err != nil { + return domain.Message{}, err + } + r.idempotencyByScope[scope] = memoryIdempotencyResult{ + requestHash: write.RequestHash, + message: message, + expiresAt: now.Add(write.TTL), + } + return message, nil } func (r *MemoryRepository) GetMessages( diff --git a/internal/adapter/postgres/messages.go b/internal/adapter/postgres/messages.go index f988e2a..92fd97c 100644 --- a/internal/adapter/postgres/messages.go +++ b/internal/adapter/postgres/messages.go @@ -1,33 +1,172 @@ package postgres import ( + "bytes" "context" "errors" "fmt" + "time" + "mtusi2026lab3/internal/application" "mtusi2026lab3/internal/domain" "github.com/google/uuid" "github.com/jackc/pgx/v5" ) -func (s *PostgreSQLStore) CreateMessage( +func (s *PostgreSQLStore) CreateMessageIdempotently( ctx context.Context, - chatID string, - senderID string, - text string, + write application.IdempotentMessageWrite, ) (domain.Message, error) { queryContext, cancel := s.withTimeout(ctx) defer cancel() - message := domain.Message{ - ID: uuid.NewString(), - ChatID: chatID, - SenderID: senderID, - Text: text, + transaction, err := s.pool.BeginTx(queryContext, pgx.TxOptions{}) + if err != nil { + return domain.Message{}, fmt.Errorf("begin idempotent message transaction: %w", err) + } + defer func() { _ = transaction.Rollback(queryContext) }() + + var isMember bool + err = transaction.QueryRow( + queryContext, + ` + SELECT EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $1 + AND user_id = $2 + ) + `, + write.ChatID, + write.ActorID, + ).Scan(&isMember) + if err != nil { + return domain.Message{}, fmt.Errorf("check chat membership: %w", err) + } + if !isMember { + return domain.Message{}, ErrNotFound } - err := s.pool.QueryRow( + _, err = transaction.Exec( + queryContext, + ` + DELETE FROM message_idempotency + WHERE user_id = $1 + AND method = $2 + AND canonical_path = $3 + AND idempotency_key = $4 + AND expires_at <= CURRENT_TIMESTAMP + `, + write.ActorID, + write.Method, + write.CanonicalPath, + write.Key, + ) + if err != nil { + return domain.Message{}, fmt.Errorf("delete expired idempotency key: %w", err) + } + + message := domain.Message{ + ID: uuid.NewString(), + ChatID: write.ChatID, + SenderID: write.ActorID, + Text: write.Text, + } + + var storedHash []byte + var storedMessageID string + err = transaction.QueryRow( + queryContext, + ` + INSERT INTO message_idempotency ( + user_id, + method, + canonical_path, + idempotency_key, + request_hash, + message_id, + expires_at + ) + VALUES ( + $1, + $2, + $3, + $4, + $5, + $6, + CURRENT_TIMESTAMP + $7 * INTERVAL '1 second' + ) + ON CONFLICT DO NOTHING + RETURNING request_hash, message_id::text + `, + write.ActorID, + write.Method, + write.CanonicalPath, + write.Key, + write.RequestHash[:], + message.ID, + int64(write.TTL/time.Second), + ).Scan(&storedHash, &storedMessageID) + + if errors.Is(err, pgx.ErrNoRows) { + err = transaction.QueryRow( + queryContext, + ` + SELECT request_hash, message_id::text + FROM message_idempotency + WHERE user_id = $1 + AND method = $2 + AND canonical_path = $3 + AND idempotency_key = $4 + `, + write.ActorID, + write.Method, + write.CanonicalPath, + write.Key, + ).Scan(&storedHash, &storedMessageID) + if err != nil { + return domain.Message{}, fmt.Errorf("read idempotency result: %w", err) + } + + if !bytes.Equal(storedHash, write.RequestHash[:]) { + return domain.Message{}, application.ErrIdempotencyConflict + } + + err = transaction.QueryRow( + queryContext, + ` + SELECT + id::text, + chat_id::text, + sender_id::text, + text, + created_at + FROM messages + WHERE id = $1 + `, + storedMessageID, + ).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if err != nil { + return domain.Message{}, fmt.Errorf("read idempotent message: %w", err) + } + + if err = transaction.Commit(queryContext); err != nil { + return domain.Message{}, fmt.Errorf("commit idempotency replay: %w", err) + } + return message, nil + } + if err != nil { + return domain.Message{}, fmt.Errorf("claim idempotency key: %w", err) + } + + err = transaction.QueryRow( queryContext, ` INSERT INTO messages ( @@ -36,14 +175,7 @@ func (s *PostgreSQLStore) CreateMessage( sender_id, text ) - SELECT - $1, - $2, - $3, - $4 - FROM chat_members - WHERE chat_id = $2 - AND user_id = $3 + VALUES ($1, $2, $3, $4) RETURNING created_at `, message.ID, @@ -51,18 +183,15 @@ func (s *PostgreSQLStore) CreateMessage( message.SenderID, message.Text, ).Scan(&message.CreatedAt) - - if err == nil { - return message, nil + if err != nil { + return domain.Message{}, fmt.Errorf("insert message: %w", err) } - // INSERT ... SELECT возвращает zero rows, если отправитель - // не является участником указанного чата. - if errors.Is(err, pgx.ErrNoRows) { - return domain.Message{}, ErrNotFound + if err = transaction.Commit(queryContext); err != nil { + return domain.Message{}, fmt.Errorf("commit idempotent message: %w", err) } - return domain.Message{}, fmt.Errorf("insert message: %w", err) + return message, nil } func (s *PostgreSQLStore) GetMessages( diff --git a/internal/application/commands.go b/internal/application/commands.go index eeb369e..e63e11e 100644 --- a/internal/application/commands.go +++ b/internal/application/commands.go @@ -18,7 +18,10 @@ type CreateChatCommand struct { } type SendMessageCommand struct { - ActorID string - ChatID string - Text string + ActorID string + ChatID string + Text string + Method string + CanonicalPath string + IdempotencyKey string } diff --git a/internal/application/errors.go b/internal/application/errors.go index d042742..9009c36 100644 --- a/internal/application/errors.go +++ b/internal/application/errors.go @@ -3,8 +3,9 @@ package application import "errors" var ( - ErrInvalidCursor = errors.New("invalid cursor") - ErrInvalidCredentials = errors.New("invalid credentials") - ErrInvalidInput = errors.New("invalid input") - ErrCredentialState = errors.New("invalid stored credential state") + ErrInvalidCursor = errors.New("invalid cursor") + ErrInvalidCredentials = errors.New("invalid credentials") + ErrInvalidInput = errors.New("invalid input") + ErrCredentialState = errors.New("invalid stored credential state") + ErrIdempotencyConflict = errors.New("idempotency key is already used for another request") ) diff --git a/internal/application/messages.go b/internal/application/messages.go index 256fa45..8070325 100644 --- a/internal/application/messages.go +++ b/internal/application/messages.go @@ -2,16 +2,41 @@ package application import ( "context" + "crypto/sha256" + "encoding/json" "fmt" "mtusi2026lab3/internal/domain" ) +type canonicalMessageRequest struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` +} + func (s *Service) SendMessage(ctx context.Context, command SendMessageCommand) (domain.Message, error) { if err := domain.ValidateMessageText(command.Text); err != nil { return domain.Message{}, fmt.Errorf("%w: %v", ErrInvalidInput, err) } - return s.repository.CreateMessage(ctx, command.ChatID, command.ActorID, command.Text) + + canonicalBody, err := json.Marshal(canonicalMessageRequest{ + Text: command.Text, + AttachmentIDs: make([]string, 0), + }) + if err != nil { + return domain.Message{}, fmt.Errorf("canonicalize message request: %w", err) + } + + return s.repository.CreateMessageIdempotently(ctx, IdempotentMessageWrite{ + ActorID: command.ActorID, + ChatID: command.ChatID, + Text: command.Text, + Method: command.Method, + CanonicalPath: command.CanonicalPath, + Key: command.IdempotencyKey, + RequestHash: sha256.Sum256(canonicalBody), + TTL: s.idempotencyTTL, + }) } func (s *Service) ListMessages( diff --git a/internal/application/ports.go b/internal/application/ports.go index e866cd6..cfd5c1c 100644 --- a/internal/application/ports.go +++ b/internal/application/ports.go @@ -24,8 +24,19 @@ type ChatRepository interface { GetChatsForUser(ctx context.Context, userID string, limit int, cursor *domain.ChatCursor) ([]domain.Chat, bool, error) } +type IdempotentMessageWrite struct { + ActorID string + ChatID string + Text string + Method string + CanonicalPath string + Key string + RequestHash [32]byte + TTL time.Duration +} + type MessageRepository interface { - CreateMessage(ctx context.Context, chatID, senderID, text string) (domain.Message, error) + CreateMessageIdempotently(ctx context.Context, write IdempotentMessageWrite) (domain.Message, error) GetMessages(ctx context.Context, chatID, callerID string, limit int, cursor *domain.MessageCursor) ([]domain.Message, bool, error) } diff --git a/internal/application/service.go b/internal/application/service.go index 35a3251..f66ea99 100644 --- a/internal/application/service.go +++ b/internal/application/service.go @@ -5,14 +5,19 @@ import ( "time" ) +const MinimumIdempotencyTTL = 24 * time.Hour + +type ServiceOption func(*Service) error + type Service struct { - repository Repository - cursors *CursorCodec - sessionTTL time.Duration - now func() time.Time + repository Repository + cursors *CursorCodec + sessionTTL time.Duration + idempotencyTTL time.Duration + now func() time.Time } -func NewService(repository Repository, cursors *CursorCodec, sessionTTL time.Duration) (*Service, error) { +func NewService(repository Repository, cursors *CursorCodec, sessionTTL time.Duration, options ...ServiceOption) (*Service, error) { if repository == nil { return nil, fmt.Errorf("repository is required") } @@ -22,10 +27,27 @@ func NewService(repository Repository, cursors *CursorCodec, sessionTTL time.Dur if sessionTTL <= 0 { return nil, fmt.Errorf("session TTL must be positive") } - return &Service{ - repository: repository, - cursors: cursors, - sessionTTL: sessionTTL, - now: func() time.Time { return time.Now().UTC() }, - }, nil + service := &Service{ + repository: repository, + cursors: cursors, + sessionTTL: sessionTTL, + idempotencyTTL: MinimumIdempotencyTTL, + now: func() time.Time { return time.Now().UTC() }, + } + for _, option := range options { + if err := option(service); err != nil { + return nil, err + } + } + return service, nil +} + +func WithIdempotencyTTL(ttl time.Duration) ServiceOption { + return func(service *Service) error { + if ttl < MinimumIdempotencyTTL { + return fmt.Errorf("idempotency TTL must be at least %s", MinimumIdempotencyTTL) + } + service.idempotencyTTL = ttl + return nil + } } diff --git a/internal/config/config.go b/internal/config/config.go index 9b10852..cd4edd4 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -5,16 +5,19 @@ import ( "fmt" "net" "os" + "regexp" "strconv" "strings" "time" ) type Config struct { - HTTPHost string - HTTPPort string + HTTPHost string + HTTPPort string + InstanceID string SessionTTL time.Duration + IdempotencyTTL time.Duration CursorSigningKey string DatabaseURL string @@ -36,6 +39,11 @@ type Config struct { } func Load() (Config, error) { + instanceID, err := instanceIDFromEnv() + if err != nil { + return Config{}, err + } + sessionTTL, err := secondsDurationFromEnv( "SESSION_TTL_SECONDS", 3600, @@ -44,6 +52,14 @@ func Load() (Config, error) { return Config{}, err } + idempotencyTTL, err := secondsDurationFromEnv( + "IDEMPOTENCY_TTL_SECONDS", + 86400, + ) + if err != nil { + return Config{}, err + } + databaseURL, err := requiredValueOrFile( "DATABASE_URL", "DATABASE_URL_FILE", @@ -158,10 +174,18 @@ func Load() (Config, error) { ) } + if idempotencyTTL < 24*time.Hour { + return Config{}, errors.New( + "IDEMPOTENCY_TTL_SECONDS must be at least 86400", + ) + } + return Config{ HTTPHost: envOrDefault("APP_HOST", "0.0.0.0"), HTTPPort: envOrDefault("APP_PORT", "8080"), + InstanceID: instanceID, SessionTTL: sessionTTL, + IdempotencyTTL: idempotencyTTL, CursorSigningKey: cursorSigningKey, DatabaseURL: databaseURL, @@ -183,6 +207,27 @@ func Load() (Config, error) { }, nil } +var instanceIDPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$`) + +func instanceIDFromEnv() (string, error) { + instanceID := strings.TrimSpace(os.Getenv("INSTANCE_ID")) + if instanceID == "" { + hostname, err := os.Hostname() + if err != nil { + return "", fmt.Errorf("resolve instance id from hostname: %w", err) + } + instanceID = hostname + } + + if !instanceIDPattern.MatchString(instanceID) { + return "", errors.New( + "INSTANCE_ID or hostname must match [A-Za-z0-9][A-Za-z0-9._-]{0,127}", + ) + } + + return instanceID, nil +} + func (c Config) HTTPAddress() string { return net.JoinHostPort(c.HTTPHost, c.HTTPPort) } diff --git a/internal/config/instance_id_test.go b/internal/config/instance_id_test.go new file mode 100644 index 0000000..58ff56e --- /dev/null +++ b/internal/config/instance_id_test.go @@ -0,0 +1,35 @@ +package config + +import "testing" + +func TestInstanceIDFromEnvironment(t *testing.T) { + t.Setenv("INSTANCE_ID", "api-replica_01") + + instanceID, err := instanceIDFromEnv() + if err != nil { + t.Fatal(err) + } + if instanceID != "api-replica_01" { + t.Fatalf("got %q, want api-replica_01", instanceID) + } +} + +func TestInstanceIDRejectsUnsafeHeaderValue(t *testing.T) { + t.Setenv("INSTANCE_ID", "api-1\r\nX-Forged: true") + + if _, err := instanceIDFromEnv(); err == nil { + t.Fatal("expected unsafe instance ID to be rejected") + } +} + +func TestInstanceIDFallsBackToHostname(t *testing.T) { + t.Setenv("INSTANCE_ID", "") + + instanceID, err := instanceIDFromEnv() + if err != nil { + t.Fatal(err) + } + if instanceID == "" { + t.Fatal("hostname fallback returned an empty instance ID") + } +} diff --git a/internal/transport/http/handlers/create_message.go b/internal/transport/http/handlers/create_message.go index 636b1d9..33aa426 100644 --- a/internal/transport/http/handlers/create_message.go +++ b/internal/transport/http/handlers/create_message.go @@ -3,6 +3,7 @@ package handlers import ( "errors" "net/http" + "regexp" "strings" "mtusi2026lab3/internal/application" @@ -14,15 +15,25 @@ import ( "github.com/google/uuid" ) +var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) { requestID := middleware.GetRequestID(r.Context()) currentUser := middleware.GetCurrentUser(r.Context()) - chatID := r.PathValue("chat_id") - if _, err := uuid.Parse(chatID); err != nil { + parsedChatID, err := uuid.Parse(r.PathValue("chat_id")) + if err != nil { response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", requestID) return } + chatID := parsedChatID.String() + + idempotencyKey := r.Header.Get("Idempotency-Key") + if !idempotencyKeyPattern.MatchString(idempotencyKey) { + response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, + "Idempotency-Key must match [A-Za-z0-9._:-]{1,128}", requestID) + return + } var request dto.CreateMessageRequest if err := decodeJSON(r, &request); err != nil { @@ -30,8 +41,18 @@ func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) { return } message, err := h.service.SendMessage(r.Context(), application.SendMessageCommand{ - ActorID: currentUser.ID, ChatID: chatID, Text: request.Text, + ActorID: currentUser.ID, + ChatID: chatID, + Text: request.Text, + Method: http.MethodPost, + CanonicalPath: "/api/v1/chats/" + chatID + "/messages", + IdempotencyKey: idempotencyKey, }) + if errors.Is(err, application.ErrIdempotencyConflict) { + response.WriteError(w, http.StatusConflict, response.CodeConflict, + "Idempotency-Key is already used for another request", requestID) + return + } if errors.Is(err, application.ErrInvalidInput) { response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, strings.TrimPrefix(err.Error(), application.ErrInvalidInput.Error()+": "), requestID) diff --git a/internal/transport/http/middleware/instance_id.go b/internal/transport/http/middleware/instance_id.go new file mode 100644 index 0000000..0688487 --- /dev/null +++ b/internal/transport/http/middleware/instance_id.go @@ -0,0 +1,15 @@ +package middleware + +import "net/http" + +const InstanceIDHeader = "X-Instance-Id" + +// InstanceID identifies the process that actually produced the response. +// It must wrap recovery and routing so even errors, health checks and 404/405 +// responses carry the same stable process identifier. +func InstanceID(instanceID string, next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set(InstanceIDHeader, instanceID) + next.ServeHTTP(w, r) + }) +} diff --git a/internal/transport/http/middleware/instance_id_test.go b/internal/transport/http/middleware/instance_id_test.go new file mode 100644 index 0000000..5ec5827 --- /dev/null +++ b/internal/transport/http/middleware/instance_id_test.go @@ -0,0 +1,50 @@ +package middleware + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func TestInstanceIDOnSuccessfulAndNotFoundResponses(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /ok", func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusNoContent) + }) + handler := InstanceID("api-01", mux) + + for _, test := range []struct { + path string + wantStatus int + }{ + {path: "/ok", wantStatus: http.StatusNoContent}, + {path: "/missing", wantStatus: http.StatusNotFound}, + } { + recorder := httptest.NewRecorder() + handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, test.path, nil)) + + if recorder.Code != test.wantStatus { + t.Fatalf("%s: got status %d, want %d", test.path, recorder.Code, test.wantStatus) + } + if got := recorder.Header().Get(InstanceIDHeader); got != "api-01" { + t.Fatalf("%s: got instance ID %q, want api-01", test.path, got) + } + } +} + +func TestInstanceIDSurvivesRecoveredPanic(t *testing.T) { + panicking := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { + panic("test panic") + }) + handler := InstanceID("api-panic", Recovery(panicking)) + recorder := httptest.NewRecorder() + + handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/panic", nil)) + + if recorder.Code != http.StatusInternalServerError { + t.Fatalf("got status %d, want 500", recorder.Code) + } + if got := recorder.Header().Get(InstanceIDHeader); got != "api-panic" { + t.Fatalf("got instance ID %q, want api-panic", got) + } +} diff --git a/migrations/000002_message_idempotency.down.sql b/migrations/000002_message_idempotency.down.sql new file mode 100644 index 0000000..36e3467 --- /dev/null +++ b/migrations/000002_message_idempotency.down.sql @@ -0,0 +1,5 @@ +BEGIN; + +DROP TABLE IF EXISTS message_idempotency; + +COMMIT; diff --git a/migrations/000002_message_idempotency.up.sql b/migrations/000002_message_idempotency.up.sql new file mode 100644 index 0000000..d83ceea --- /dev/null +++ b/migrations/000002_message_idempotency.up.sql @@ -0,0 +1,54 @@ +BEGIN; + +CREATE TABLE message_idempotency ( + user_id UUID NOT NULL, + method VARCHAR(8) NOT NULL, + canonical_path TEXT NOT NULL, + idempotency_key VARCHAR(128) NOT NULL, + request_hash BYTEA NOT NULL, + message_id UUID NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP, + expires_at TIMESTAMPTZ NOT NULL, + + CONSTRAINT message_idempotency_primary_key + PRIMARY KEY ( + user_id, + method, + canonical_path, + idempotency_key + ), + + CONSTRAINT message_idempotency_user_foreign_key + FOREIGN KEY (user_id) + REFERENCES users (id) + ON DELETE RESTRICT, + + CONSTRAINT message_idempotency_message_foreign_key + FOREIGN KEY (message_id) + REFERENCES messages (id) + ON DELETE RESTRICT + DEFERRABLE INITIALLY DEFERRED, + + CONSTRAINT message_idempotency_message_unique + UNIQUE (message_id), + + CONSTRAINT message_idempotency_method_format + CHECK (method = 'POST'), + + CONSTRAINT message_idempotency_key_format + CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'), + + CONSTRAINT message_idempotency_path_not_blank + CHECK (btrim(canonical_path) <> ''), + + CONSTRAINT message_idempotency_request_hash_length + CHECK (octet_length(request_hash) = 32), + + CONSTRAINT message_idempotency_expiry_after_creation + CHECK (expires_at >= created_at + INTERVAL '24 hours') +); + +CREATE INDEX message_idempotency_expires_at_idx + ON message_idempotency (expires_at); + +COMMIT; diff --git a/scripts/restart.sh b/scripts/restart.sh index 8ecf62c..80ea344 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -5,11 +5,20 @@ project_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) cd "$project_root" env_file=${ENV_FILE:-.env} +compose() { + docker compose --env-file "$env_file" "$@" +} # PostgreSQL хранит все обязательные данные и сессии в named volume. # Redis содержит только восстанавливаемый кеш и намеренно не имеет volume. -docker compose --env-file "$env_file" restart postgres redis -docker compose --env-file "$env_file" up -d --wait postgres redis +compose restart postgres redis +compose up -d --wait postgres redis -# API перезапускается после восстановления обязательной БД и кеша. -docker compose --env-file "$env_file" restart api +# up восстанавливает желаемое число реплик, включая ранее вручную остановленную. +compose up -d --no-deps api +compose restart api +compose up -d --wait --no-deps api + +# Публичная точка входа перезапускается последней, когда API уже готовы. +compose restart load-balancer +compose up -d --wait --no-deps load-balancer diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 0000000..931cccc --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,32 @@ +#!/bin/sh +set -eu + +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +project_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) +cd "$project_root" + +env_file=${ENV_FILE:-.env} +matched_container= + +for container_id in $(docker compose --env-file "$env_file" ps -a -q api); do + instance_id=$(docker inspect --format '{{.Config.Hostname}}' "$container_id") + if [ "$instance_id" = "$TARGET_INSTANCE_ID" ]; then + if [ -n "$matched_container" ]; then + printf '%s\n' "multiple API containers match instance $TARGET_INSTANCE_ID" >&2 + exit 1 + fi + matched_container=$container_id + fi +done + +if [ -z "$matched_container" ]; then + printf '%s\n' "API instance not found: $TARGET_INSTANCE_ID" >&2 + exit 1 +fi + +# A manual docker stop suppresses the container restart policy until the next +# explicit start, so the selected replica remains down for the whole test. +docker stop --time 5 "$matched_container" >/dev/null + +printf '%s\n' "stopped API instance $TARGET_INSTANCE_ID" diff --git a/student_tests/idempotency_test.go b/student_tests/idempotency_test.go new file mode 100644 index 0000000..18f3715 --- /dev/null +++ b/student_tests/idempotency_test.go @@ -0,0 +1,275 @@ +package student_tests + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "sync" + "testing" + + store "mtusi2026lab3/internal/adapter/memory" + "mtusi2026lab3/internal/domain" + "mtusi2026lab3/internal/transport/http/dto" +) + +func sendMessageRequest( + t *testing.T, + serverURL string, + chatID string, + actorID string, + key string, + body string, +) (int, []byte) { + t.Helper() + + request, err := http.NewRequest( + http.MethodPost, + fmt.Sprintf("%s/api/v1/chats/%s/messages", serverURL, chatID), + bytes.NewBufferString(body), + ) + if err != nil { + t.Fatalf("create message request: %v", err) + } + request.Header.Set("Content-Type", "application/json") + request.Header.Set("X-User-Id", actorID) + if key != "" { + request.Header.Set("Idempotency-Key", key) + } + + response, err := http.DefaultClient.Do(request) + if err != nil { + t.Fatalf("send message request: %v", err) + } + defer response.Body.Close() + + payload, err := io.ReadAll(response.Body) + if err != nil { + t.Fatalf("read message response: %v", err) + } + return response.StatusCode, payload +} + +func decodeMessageResponse(t *testing.T, payload []byte) dto.MessageResponse { + t.Helper() + + var message dto.MessageResponse + if err := json.Unmarshal(payload, &message); err != nil { + t.Fatalf("decode message response: %v; body=%s", err, payload) + } + return message +} + +func createMessageFixture(t *testing.T) (*store.MemoryStore, string, domain.User, string) { + t.Helper() + + server, memoryStore := setupTestServer() + t.Cleanup(server.Close) + + user, err := memoryStore.CreateUser("idempotency_user", "Idempotency User") + if err != nil { + t.Fatalf("create fixture user: %v", err) + } + chat, err := memoryStore.CreateChat("Idempotency Chat", []string{user.ID}) + if err != nil { + t.Fatalf("create fixture chat: %v", err) + } + + return memoryStore, server.URL, user, chat.ID +} + +func TestMessageIdempotencyKeyValidation(t *testing.T) { + _, serverURL, user, chatID := createMessageFixture(t) + + testCases := []struct { + name string + key string + }{ + {name: "missing", key: ""}, + {name: "space", key: "invalid key"}, + {name: "non ascii", key: "ключ"}, + {name: "too long", key: string(bytes.Repeat([]byte{'a'}, 129))}, + } + + for _, testCase := range testCases { + t.Run(testCase.name, func(t *testing.T) { + status, _ := sendMessageRequest( + t, + serverURL, + chatID, + user.ID, + testCase.key, + `{"text":"hello"}`, + ) + if status != http.StatusBadRequest { + t.Fatalf("expected 400, got %d", status) + } + }) + } +} + +func TestMessageIdempotencyReplayAndConflict(t *testing.T) { + memoryStore, serverURL, user, chatID := createMessageFixture(t) + + status, firstPayload := sendMessageRequest( + t, serverURL, chatID, user.ID, "replay-key", `{"text":"hello"}`, + ) + if status != http.StatusCreated { + t.Fatalf("first request: expected 201, got %d: %s", status, firstPayload) + } + + status, replayPayload := sendMessageRequest( + t, + serverURL, + chatID, + user.ID, + "replay-key", + "{\n \"text\": \"hello\"\n}", + ) + if status != http.StatusCreated { + t.Fatalf("replay: expected 201, got %d: %s", status, replayPayload) + } + + first := decodeMessageResponse(t, firstPayload) + replay := decodeMessageResponse(t, replayPayload) + if first != replay { + t.Fatalf("replay changed message: first=%+v replay=%+v", first, replay) + } + + status, _ = sendMessageRequest( + t, serverURL, chatID, user.ID, "replay-key", `{"text":"different"}`, + ) + if status != http.StatusConflict { + t.Fatalf("different body: expected 409, got %d", status) + } + + messages, _, err := memoryStore.GetMessages(chatID, user.ID, 10, nil) + if err != nil { + t.Fatalf("list messages: %v", err) + } + if len(messages) != 1 { + t.Fatalf("expected one stored message, got %d", len(messages)) + } +} + +func TestMessageIdempotencyScopesAreIndependent(t *testing.T) { + server, memoryStore := setupTestServer() + t.Cleanup(server.Close) + + alice, _ := memoryStore.CreateUser("scope_alice", "Alice") + bob, _ := memoryStore.CreateUser("scope_bob", "Bob") + firstChat, _ := memoryStore.CreateChat("First", []string{alice.ID, bob.ID}) + secondChat, _ := memoryStore.CreateChat("Second", []string{alice.ID, bob.ID}) + + testCases := []struct { + actorID string + chatID string + text string + }{ + {actorID: alice.ID, chatID: firstChat.ID, text: "alice first"}, + {actorID: bob.ID, chatID: firstChat.ID, text: "bob first"}, + {actorID: alice.ID, chatID: secondChat.ID, text: "alice second"}, + } + + for _, testCase := range testCases { + status, payload := sendMessageRequest( + t, + server.URL, + testCase.chatID, + testCase.actorID, + "shared-key", + fmt.Sprintf(`{"text":%q}`, testCase.text), + ) + if status != http.StatusCreated { + t.Fatalf("independent scope: expected 201, got %d: %s", status, payload) + } + } +} + +func TestConcurrentMessageIdempotencyCreatesExactlyOneMessage(t *testing.T) { + memoryStore, serverURL, user, chatID := createMessageFixture(t) + + const clients = 32 + start := make(chan struct{}) + results := make(chan dto.MessageResponse, clients) + errors := make(chan error, clients) + + var waitGroup sync.WaitGroup + for index := 0; index < clients; index++ { + waitGroup.Add(1) + go func() { + defer waitGroup.Done() + <-start + + request, err := http.NewRequest( + http.MethodPost, + fmt.Sprintf("%s/api/v1/chats/%s/messages", serverURL, chatID), + bytes.NewBufferString(`{"text":"concurrent replay"}`), + ) + if err != nil { + errors <- err + return + } + request.Header.Set("Content-Type", "application/json") + request.Header.Set("X-User-Id", user.ID) + request.Header.Set("Idempotency-Key", "one-concurrent-key") + + response, err := http.DefaultClient.Do(request) + if err != nil { + errors <- err + return + } + defer response.Body.Close() + payload, err := io.ReadAll(response.Body) + if err != nil { + errors <- err + return + } + if response.StatusCode != http.StatusCreated { + errors <- fmt.Errorf("expected 201, got %d: %s", response.StatusCode, payload) + return + } + + var message dto.MessageResponse + if err = json.Unmarshal(payload, &message); err != nil { + errors <- err + return + } + results <- message + }() + } + + close(start) + waitGroup.Wait() + close(results) + close(errors) + + for err := range errors { + if err != nil { + t.Fatal(err) + } + } + + var expected dto.MessageResponse + count := 0 + for message := range results { + if count == 0 { + expected = message + } else if message != expected { + t.Fatalf("concurrent replay returned different message: %+v != %+v", message, expected) + } + count++ + } + if count != clients { + t.Fatalf("expected %d successful responses, got %d", clients, count) + } + + messages, _, err := memoryStore.GetMessages(chatID, user.ID, clients+1, nil) + if err != nil { + t.Fatalf("list messages: %v", err) + } + if len(messages) != 1 { + t.Fatalf("expected exactly one stored message, got %d", len(messages)) + } +} diff --git a/student_tests/messenger_test.go b/student_tests/messenger_test.go index 6eedfcb..3913587 100644 --- a/student_tests/messenger_test.go +++ b/student_tests/messenger_test.go @@ -137,6 +137,7 @@ func TestEmptyMessageValidation(t *testing.T) { req, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(`{"text":""}`)) req.Header.Set("Content-Type", "application/json") req.Header.Set("X-User-Id", u.ID) + req.Header.Set("Idempotency-Key", "empty-text") res, _ := http.DefaultClient.Do(req) if res.StatusCode != http.StatusBadRequest { @@ -147,6 +148,7 @@ func TestEmptyMessageValidation(t *testing.T) { reqSpaces, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(`{"text":" "}`)) reqSpaces.Header.Set("Content-Type", "application/json") reqSpaces.Header.Set("X-User-Id", u.ID) + reqSpaces.Header.Set("Idempotency-Key", "spaces-text") resSpaces, _ := http.DefaultClient.Do(reqSpaces) if resSpaces.StatusCode != http.StatusBadRequest { @@ -494,6 +496,10 @@ func TestConcurrent100MessagesFrom10Clients(t *testing.T) { ) req.Header.Set("Content-Type", "application/json") req.Header.Set("X-User-Id", senderID) + req.Header.Set( + "Idempotency-Key", + fmt.Sprintf("concurrent-%d-%d", clientIndex, m), + ) res, err := http.DefaultClient.Do(req) if err != nil || res.StatusCode != http.StatusCreated { @@ -638,6 +644,7 @@ func TestUnicodeLimits(t *testing.T) { req1, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(bodyValid)) req1.Header.Set("Content-Type", "application/json") req1.Header.Set("X-User-Id", u.ID) + req1.Header.Set("Idempotency-Key", "unicode-valid") res1, _ := http.DefaultClient.Do(req1) if res1.StatusCode != http.StatusCreated { t.Fatalf("expected 201 for 4000 unicode runes, got %d", res1.StatusCode) @@ -652,6 +659,7 @@ func TestUnicodeLimits(t *testing.T) { req2, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(bodyTooLong)) req2.Header.Set("Content-Type", "application/json") req2.Header.Set("X-User-Id", u.ID) + req2.Header.Set("Idempotency-Key", "unicode-too-long") res2, _ := http.DefaultClient.Do(req2) if res2.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 for 4001 runes, got %d", res2.StatusCode)