From 06d47fbb5b49dc5cefc4b987eb52a41e0fceb255 Mon Sep 17 00:00:00 2001 From: Ilia Sokolov Date: Sat, 31 Oct 2026 17:15:24 +0300 Subject: [PATCH] Implement lab3 load balancing and failover --- .env.example | 9 + Dockerfile | 26 +++ Makefile | 19 +- REPORT.md | 231 +++++++++++++++++-- app_test.go | 307 +++++++++++++++++++++++++ auth.go | 110 +++++++++ compose.yaml | 125 ++++++++++ config.go | 87 +++++++ go.mod | 18 ++ go.sum | 70 ++++++ handlers.go | 405 +++++++++++++++++++++++++++++++++ httpx.go | 204 +++++++++++++++++ infra/nginx/default.conf | 36 +++ main.go | 116 ++++++++++ migrate.go | 122 ++++++++++ migrations/001_init.sql | 45 ++++ migrations/002_sessions.sql | 15 ++ migrations/003_idempotency.sql | 19 ++ scripts/init-secrets.ps1 | 25 ++ scripts/init-secrets.sh | 20 ++ scripts/restart.cmd | 25 ++ scripts/restart.sh | 23 ++ scripts/start-all.cmd | 3 + scripts/start-all.sh | 5 + scripts/stop-one.cmd | 11 + scripts/stop-one.sh | 15 ++ store.go | 372 ++++++++++++++++++++++++++++++ 27 files changed, 2438 insertions(+), 25 deletions(-) create mode 100644 Dockerfile create mode 100644 app_test.go create mode 100644 auth.go create mode 100644 compose.yaml create mode 100644 config.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 handlers.go create mode 100644 httpx.go create mode 100644 infra/nginx/default.conf create mode 100644 main.go create mode 100644 migrate.go create mode 100644 migrations/001_init.sql create mode 100644 migrations/002_sessions.sql create mode 100644 migrations/003_idempotency.sql create mode 100644 scripts/init-secrets.ps1 create mode 100644 scripts/init-secrets.sh create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/start-all.cmd create mode 100644 scripts/start-all.sh create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 store.go diff --git a/.env.example b/.env.example index d32b9be0..a54a5891 100644 --- a/.env.example +++ b/.env.example @@ -9,5 +9,14 @@ DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url +# Число реплик API (Compose deploy.replicas). API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 + +# --- добавлено в lab2/lab3 --- +PUBLISHED_PORT=8080 +POSTGRES_DB=messenger +POSTGRES_USER=messenger +DB_MAX_CONNS=10 +# Время «не готов, но ещё обслуживаю» после SIGTERM перед закрытием listener. +SHUTDOWN_DRAIN_SECONDS=1 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..62af12f1 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +# syntax=docker/dockerfile:1 +# Сборка из исходников; образ-сервер преподавателя не используется. +FROM golang:1.23.8-bookworm AS build + +WORKDIR /src +# Сначала манифесты зависимостей: слой кэшируется, пока go.mod/go.sum не менялись. +COPY go.mod go.sum ./ +RUN go mod download && go mod verify +COPY *.go ./ +COPY migrations ./migrations +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger . + +# Пустой runtime-образ: один статический бинарник, нет shell и пакетного менеджера. +FROM scratch +COPY --from=build /out/messenger /messenger + +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 +EXPOSE 8080 +# Не root: числовой UID достаточен, /etc/passwd в scratch не нужен. +USER 65532:65532 +# В scratch нет curl, поэтому проверку выполняет сам бинарник (GET /health/ready). +HEALTHCHECK --interval=10s --timeout=4s --start-period=5s --retries=3 CMD ["/messenger", "healthcheck"] +# PID 1 — сам процесс; он корректно завершается по SIGTERM (graceful shutdown). +ENTRYPOINT ["/messenger"] +CMD ["serve"] diff --git a/Makefile b/Makefile index 5d86d171..eac25c35 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover secrets up down logs go-test help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +28,20 @@ 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: единый запуск (Docker Compose v2): LB nginx + API x2 + PostgreSQL --- +secrets: + sh scripts/init-secrets.sh + +up: secrets + docker compose up -d --build + +# Остановка БЕЗ удаления volumes. Намеренное удаление учебных данных: docker compose down -v +down: + docker compose down + +logs: + docker compose logs --tail=100 lb api postgres + +go-test: + go test -count=1 ./... diff --git a/REPORT.md b/REPORT.md index c2679005..b2ee885b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,220 @@ -# Отчёт — лабораторная 3 +# Отчёт по лабораторной работе № 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Дисциплина:** Высоконагруженные системы +**Тема:** Балансировка нагрузки и отказ API-реплики +**Факультет:** Факультет ИТ +**Группа:** БВТ2302 +**Студент:** Соколов Илья Сергеевич +**Целевая оценка:** 3 +**Дата проверки:** 31.10.2026 +**Репозиторий / commit / Pull Request:** сведения о публикации не предоставлены; заполнить после отправки в GitHub. -## Запуск из чистого clone +## 1. Цель работы -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Развернуть приложение с не менее чем двумя взаимозаменяемыми экземплярами API за единой точкой входа, общим хранилищем данных и сессий. Проверить корректность работы API, сохранение данных после перезапуска компонентов, отказоустойчивость при остановке одной реплики и идемпотентность повторных запросов. -## Архитектура и решения +## 2. Используемые технологии -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +- **Go 1.23** — реализация HTTP API. +- **PostgreSQL 16.9** — общее хранилище пользователей, сообщений, сессий и ключей идемпотентности. +- **Nginx 1.27.5** — балансировщик и единая точка входа. +- **Docker Desktop / Docker Compose** — сборка, запуск и управление контейнерами. +- **Python 3.12** — выполнение публичных проверок. +- **Windows PowerShell** — запуск команд на локальной машине. -## Доказательства критериев +## 3. Архитектура приложения -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +```text +Клиент (http://localhost:18080) + | + v + Nginx (lb:80) + / \ + v v + API-1 API-2 + \ / + v v + PostgreSQL + (volume pgdata) +``` -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Стенд запускается через `compose.yaml`. Nginx публикует **только один порт на локальном компьютере** — `127.0.0.1:18080`, а обе API-реплики доступны через внутреннюю сеть Docker без отдельной публикации портов. Внутри Docker API продолжает прослушивать порт `8080`. -## Эксперименты и отказы +API не хранит критичное для корректности состояние локально: данные приложения, сессии и ключи идемпотентности находятся в общей БД PostgreSQL. Поэтому запросы одной пользовательской сессии могут обслуживаться разными репликами без повторной авторизации. Sticky sessions не используются. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Миграции выполняются отдельным одноразовым сервисом `migrate`, который стартует после готовности PostgreSQL. API начинает работу после успешного выполнения миграций. Статус `Exited (0)` для `migrate` после завершения — штатный. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +**Основные решения:** -## Ограничения и следующие шаги +- **Балансировка:** Nginx использует внутренний DNS Docker (`api`) и `resolver 127.0.0.11 valid=1s`; настроены ограничения по времени ожидания соединения и повтор при сетевых ошибках/ошибках шлюза. +- **Readiness:** endpoint `GET /health/ready` проверяет готовность сервиса. +- **Идентификация реплик:** заголовок `X-Instance-Id` позволяет наблюдать, какой экземпляр обработал запрос. +- **Graceful shutdown:** при SIGTERM сервис перестаёт считаться готовым, выдерживает период `SHUTDOWN_DRAIN_SECONDS=1` и завершает обработку текущих запросов. +- **Идемпотентность:** запрос отправки сообщения использует `Idempotency-Key`; запись ключа и сообщения выполняется в одной транзакции PostgreSQL. Повтор с тем же ключом и телом возвращает сохранённый результат, попытка использовать ключ с другим телом отклоняется. +- **Хранение данных:** Docker volume `pgdata` сохраняется при обычных перезапусках контейнеров. +- **Защита:** заданы лимиты CPU/RAM, у API включены `read_only`, `cap_drop: ALL` и запрет повышения привилегий. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +## 4. Запуск лабораторной работы + +В локальной среде Windows порт `8080` оказался недоступен для публикации Docker (`bind: An attempt was made to access a socket in a way forbidden by its access permissions`). Поэтому в локальном `.env` был установлен `PUBLISHED_PORT=18080`. Это изменяет **только внешний порт балансировщика**, а не внутренний порт API. Файл `.env`, как и файлы из `secrets/`, не включается в репозиторий. + +Использованный каталог проекта: + +```text +D:\Study\sem_7\Высоконагруженные системы\Лабы\3\mtusi2026lab3-main +``` + +**Команды для воспроизведения запуска в PowerShell:** + +```powershell +cd "D:\Study\sem_7\Высоконагруженные системы\Лабы\3\mtusi2026lab3-main" + +# Создаёт локальные secrets/ и .env, если их ещё нет. +powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1 + +# Однократно укажите в .env: PUBLISHED_PORT=18080 +# На компьютере без конфликта портов допустимо оставить 8080. + +docker compose up -d --build +docker compose ps +curl.exe http://localhost:18080/health/ready +``` + +**Фактически полученный ответ readiness:** + +```json +{"status":"ok"} +``` + +После запуска были здоровы `mtusi-lab3-postgres-1`, `mtusi-lab3-api-1` и `mtusi-lab3-api-2`; балансировщик `mtusi-lab3-lb-1` работал с привязкой `127.0.0.1:18080->80/tcp`. После проверки отказоустойчивости первая реплика была восстановлена командой `docker compose up -d`, и обе API-реплики вновь получили статус `Healthy`. + +## 5. Проверки и результаты + +Все приведённые ниже результаты получены в PowerShell **31.10.2026**. Для Python в Windows использован параметр `-X utf8`, поскольку без него чтение `lab.json` завершалось `UnicodeDecodeError` из-за системной кодировки `cp1252`. + +### 5.1. Базовый сценарий API (smoke) + +```powershell +python -X utf8 tests\smoke.py --base-url http://localhost:18080 +``` + +Результат: + +```text +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. +``` + +**Вывод:** сквозной публичный сценарий API пройден, включая стандартные проверки повторной отправки сообщения с тем же ключом, конфликт с другим телом и отсутствие обязательного ключа. Данный тест сам по себе не доказывает наличие двух работающих контейнеров или поведение системы при отказе. + +### 5.2. Сохранность данных и сессии (persistence) + +```powershell +python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:18080 +``` + +Результат: + +```text +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +``` + +**Вывод:** после выполнения `restart.cmd` подтверждённые данные сохранились, а существующий токен сессии остался действительным. Скрипт перезапускает LB, API и PostgreSQL без удаления volume. Для доказательства реального объёма перезапуска дополнительно требуются состояния контейнеров до/после выполнения скрипта. + +### 5.3. Остановка одной реплики (failover) + +```powershell +python -X utf8 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://localhost:18080 +``` + +Результат: + +```text +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 8, "failed_attempts": 0, "first_recovery_seconds": 4.203} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +``` + +| Показатель | Полученное значение | +| --- | ---: | +| Различных API-реплик до отказа | **2** | +| Успешных записей во время теста | **8** | +| Неудачных попыток | **0** | +| Время до первой успешной записи после начала отказа | **4,203 с** | +| Допустимое время восстановления записи по критерию лабораторной | **не более 10 с** | +| Результат теста | **PASS** | + +Дополнительно выполнена команда: + +```powershell +docker ps -a --filter label=com.docker.compose.service=api +``` + +Состояние непосредственно после теста: + +```text +mtusi-lab3-api-2 Up (healthy) +mtusi-lab3-api-1 Exited (0) +``` + +Таким образом, одна реплика (`api-1`) была действительно остановлена, вторая (`api-2`) осталась работоспособной, а проверка сохранности данных и прежней сессии завершилась успешно. После эксперимента выполнено: + +```powershell +docker compose up -d +``` + +После восстановления обе API-реплики получили статус `Healthy`. + +## 6. Соответствие критериям лабораторной + +| Критерий | Подтверждение | Статус | +| --- | --- | --- | +| Запуск через Docker Compose, одна точка входа | `docker compose up -d --build`, опубликован только порт LB | Подтверждено | +| Не менее двух API-реплик и общее хранилище | Две здоровые API-реплики; `observed_instances_before: 2` | Подтверждено | +| Работа одного пользователя через разные реплики | `resilience.py` наблюдал два `X-Instance-Id` | Подтверждено тестом | +| Публичный сквозной сценарий API | `smoke.py` — PASS | Подтверждено | +| Сохранность данных после рестарта | `persistence` — PASS | Подтверждено тестом | +| Работа при остановке одной реплики, восстановление записи за ≤10 с | `failover` — PASS; 4,203 с; 0 ошибок | Подтверждено для `api-1` | +| Сохранность данных и прежнего токена при отказе | `failover` — PASS | Подтверждено тестом | +| Идемпотентные повторы запроса | Публичный smoke проверяет повтор и конфликты; failover проверяет безопасность неопределённого повтора | Базовые проверки пройдены | +| Одновременные POST с одним ключом через разные реплики | Отдельного протокола параллельных запросов пока нет | Требует отдельного доказательства | +| Остановка второй реплики при работающей первой | Повторный независимый опыт не зафиксирован | Требует отдельного доказательства | +| Commit / PR и приложенные артефакты evidence | Ссылки и файлы не предоставлены | Требует оформления | + +## 7. Особенности эксперимента и ограничения + +1. **PostgreSQL и Nginx остаются единичными точками отказа.** Данный эксперимент подтверждает устойчивость к отказу одной API-реплики, а не отказоустойчивость всех компонентов или физического узла. +2. **Замер 4,203 с** — время до первой успешной записи после начала failover hook, а не полное время перезапуска приложения или узла. +3. **Автоматические проверки не заменяют доказательства действий оператора.** Для защиты полезно сохранить вывод `docker compose ps`, состояния конкретной реплики до/после остановки и доказательства восстановления. +4. **Эксперимент с остановкой второй реплики отдельно не зафиксирован.** Повторить его после восстановления первой, если это требуется преподавателем. +5. **Конкурентные запросы с одним Idempotency-Key через разные реплики отдельно не измерялись.** Корректность базовой идемпотентности подтверждена smoke-тестом, но вывод о самостоятельной конкурентной проверке не делается. +6. **Внешний порт `18080`** относится к конкретному Windows-стенду. Для запуска на другой машине допустим стандартный порт `8080`, если он свободен. + +## 8. Доказательства для репозитория + +В каталоге `evidence/` рекомендуется сохранить небольшие обезличенные текстовые журналы: + +- `smoke.txt` — вывод `smoke.py`; +- `persistence.txt` — вывод проверки сохранности; +- `failover.txt` — вывод проверки отказа и её метрики; +- `containers.txt` — перечень контейнеров и их состояний до отказа; +- `api-after-failover.txt` — состояния API-контейнеров после остановки; +- `api-after-restore.txt` — состояния после восстановления; +- отдельный протокол остановки второй реплики и конкурентных запросов, если выполнены. + +**Примечание:** перечисленные имена — рекомендуемые артефакты. Наличие этих файлов в репозитории на момент составления отчёта не подтверждено. Секреты, `.env`, токены сессий, пароли и полные дампы БД сохранять в доказательства нельзя. + +## 9. Вывод + +В ходе лабораторной работы № 3 развернут стенд с балансировщиком Nginx, двумя взаимозаменяемыми API-репликами и общей PostgreSQL. Публичная проверка API, тест сохранности данных после перезапуска и тест отказа одной API-реплики **завершились успешно (PASS)**. + +В тесте отказоустойчивости до остановки наблюдались две реплики. После остановки `api-1` система выполнила **8 успешных записей без зарегистрированных ошибок**, а первая успешная запись после начала отказа была зафиксирована через **4,203 секунды**, что удовлетворяет требованию восстановления не позднее 10 секунд. Подтверждённые сообщения и прежняя сессия сохранились, после чего остановленная реплика была восстановлена. + +**Основные автоматические тесты пройдены.** Для полного комплекта материалов на защиту остаётся приложить журналы экспериментов, проверить отказ второй реплики, отдельно зафиксировать конкурентную идемпотентность и добавить ссылку на GitHub Pull Request. + +## 10. Использованные материалы и помощь ИИ + +- Исходное задание, API-контракт и публичные тесты лабораторной № 3 (`README.md`, `contracts/`, `tests/`). +- Собственная кодовая база лабораторной № 2 на Go, pgx и PostgreSQL, доработанная для лабораторной № 3. +- Конфигурация Docker Compose и Nginx с опорой на официальную документацию соответствующих инструментов. +- Claude Code использовался при доработке приложения и конфигураций; ChatGPT — при диагностике запуска и подготовке отчёта. Результаты проверок приведены из фактического вывода PowerShell. diff --git a/app_test.go b/app_test.go new file mode 100644 index 00000000..eb027287 --- /dev/null +++ b/app_test.go @@ -0,0 +1,307 @@ +package main + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "strings" + "sync" + "testing" + "time" +) + +// Тесты без БД всегда выполняются; тесты с БД — только если задан TEST_DATABASE_URL +// (пустая тестовая БД, например postgres://messenger@127.0.0.1:55432/messenger_test). + +func TestCursorIsBoundToResource(t *testing.T) { + now := time.Now().UTC().Truncate(time.Microsecond) + c := encodeCursor("messages", "chat-a", now, newUUID()) + if _, _, err := decodeCursor(c, "messages", "chat-a"); err != nil { + t.Fatalf("own cursor rejected: %v", err.message) + } + if _, _, err := decodeCursor(c, "messages", "chat-b"); err == nil || err.status != 400 { + t.Fatal("cursor of another chat must be rejected with 400") + } + if _, _, err := decodeCursor(c, "chats", "chat-a"); err == nil { + t.Fatal("cursor of another list kind must be rejected") + } + if _, _, err := decodeCursor("not-a-cursor", "messages", "chat-a"); err == nil { + t.Fatal("garbage cursor must be rejected") + } +} + +func TestBasicParsing(t *testing.T) { + mk := func(raw string) *http.Request { + r := httptest.NewRequest("POST", "/", nil) + r.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(raw))) + return r + } + u, p, ok := parseBasic(mk("alice:pa:ss:wörd-ü")) + if !ok || u != "alice" || p != "pa:ss:wörd-ü" { + t.Fatalf("colon in password must be kept, got %q %q %v", u, p, ok) + } + if _, _, ok := parseBasic(mk("no-colon")); ok { + t.Fatal("credentials without colon must be rejected") + } + r := httptest.NewRequest("POST", "/", nil) + r.Header.Set("Authorization", "Basic !!!not-base64") + if _, _, ok := parseBasic(r); ok { + t.Fatal("invalid base64 must be rejected") + } + b := httptest.NewRequest("GET", "/", nil) + b.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("a:b"))) + if _, ok := bearerToken(b); ok { + t.Fatal("Basic must not be accepted as Bearer") + } +} + +func TestTokenAndPasswordHash(t *testing.T) { + token, hash := newToken() + if len(token) != 43 || len(hash) != 32 { + t.Fatalf("token must carry 256 bits (43 base64url chars), got %d", len(token)) + } + if other, _ := newToken(); other == token { + t.Fatal("tokens must be unique") + } + h := newHasher(1) + hashed, err := h.hash(context.Background(), "correct horse battery") + if err != nil || len(hashed) < 40 || hashed[:10] != "$argon2id$" { + t.Fatalf("expected a PHC argon2id hash, got %q (%v)", hashed, err) + } + if ok, _ := h.verify(context.Background(), "correct horse battery", hashed); !ok { + t.Fatal("correct password must verify") + } + if ok, _ := h.verify(context.Background(), "wrong horse battery!", hashed); ok { + t.Fatal("wrong password must not verify") + } +} + +// ---- тесты с PostgreSQL ---- + +type env struct { + srv *httptest.Server + store *Store + url string +} + +func setup(t *testing.T, ttl int) *env { + t.Helper() + url := os.Getenv("TEST_DATABASE_URL") + if url == "" { + t.Skip("TEST_DATABASE_URL is not set") + } + ctx := context.Background() + if err := runMigrations(ctx, url); err != nil { + t.Fatal(err) + } + pool, err := newPool(ctx, url, 10) + if err != nil { + t.Fatal(err) + } + t.Cleanup(pool.Close) + store := &Store{pool: pool} + api := &API{store: store, hasher: newHasher(4), ttlSecs: ttl, reqLimit: 8 * time.Second} + srv := httptest.NewServer(api) + t.Cleanup(srv.Close) + return &env{srv: srv, store: store, url: url} +} + +func (e *env) do(t *testing.T, method, path string, body any, headers map[string]string) (int, map[string]any, http.Header) { + t.Helper() + var rd *bytes.Reader + if body != nil { + raw, _ := json.Marshal(body) + rd = bytes.NewReader(raw) + } else { + rd = bytes.NewReader(nil) + } + req, _ := http.NewRequest(method, e.srv.URL+path, rd) + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + for k, v := range headers { + req.Header.Set(k, v) + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + var out map[string]any + _ = json.NewDecoder(resp.Body).Decode(&out) + return resp.StatusCode, out, resp.Header +} + +func basic(user, pass string) map[string]string { + return map[string]string{"Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pass))} +} + +func bearer(token string) map[string]string { + return map[string]string{"Authorization": "Bearer " + token} +} + +func (e *env) register(t *testing.T, name string) (id, pass string) { + t.Helper() + pass = "Passw0rd-" + newUUID() + status, out, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Тест", "password": pass}, nil) + if status != 201 { + t.Fatalf("register %s: %d %v", name, status, out) + } + if _, leaked := out["password"]; leaked { + t.Fatal("password must never be returned") + } + return out["id"].(string), pass +} + +func (e *env) login(t *testing.T, name, pass string) string { + t.Helper() + status, out, _ := e.do(t, "POST", "/api/v1/auth/sessions", nil, basic(name, pass)) + if status != 201 { + t.Fatalf("login: %d %v", status, out) + } + return out["token"].(string) +} + +func uname() string { return "t_" + strings.ReplaceAll(newUUID(), "-", "")[:12] } + +func TestRegistrationRaceYieldsOneUser(t *testing.T) { + e := setup(t, 3600) + name := uname() + const workers = 16 + var wg sync.WaitGroup + codes := make(chan int, workers) + for i := 0; i < workers; i++ { + wg.Add(1) + go func() { + defer wg.Done() + status, _, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Гонка", "password": "Race-password-123"}, nil) + codes <- status + }() + } + wg.Wait() + close(codes) + created, conflicts := 0, 0 + for c := range codes { + switch c { + case 201: + created++ + case 409: + conflicts++ + default: + t.Fatalf("unexpected status %d", c) + } + } + if created != 1 || conflicts != workers-1 { + t.Fatalf("expected exactly one 201 and %d×409, got %d / %d", workers-1, created, conflicts) + } + var n int + if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM users WHERE username = $1`, name).Scan(&n); err != nil || n != 1 { + t.Fatalf("database must hold exactly one row, got %d (%v)", n, err) + } +} + +func TestCreateChatIsAtomic(t *testing.T) { + e := setup(t, 3600) + name := uname() + id, pass := e.register(t, name) + ctx := context.Background() + var before int + _ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before) + + // Участник-призрак: INSERT чата уже выполнен, INSERT участников падает на внешнем ключе -> откат всего. + chat := Chat{ID: newUUID(), Title: "rollback", MemberIDs: []string{id, newUUID()}} + if _, err := e.store.createChat(ctx, chat, id); err != errInvalidMembers { + t.Fatalf("expected errInvalidMembers, got %v", err) + } + var after, members int + _ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after) + _ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE chat_id = $1::uuid`, chat.ID).Scan(&members) + if after != before || members != 0 { + t.Fatalf("partial chat left behind: chats %d->%d, members %d", before, after, members) + } + + // То же через HTTP: 400, а у пользователя по-прежнему нет чатов. + token := e.login(t, name, pass) + status, _, _ := e.do(t, "POST", "/api/v1/chats", map[string]any{"title": "x", "member_ids": []string{id, newUUID()}}, bearer(token)) + if status != 400 { + t.Fatalf("unknown member must give 400, got %d", status) + } + _, list, _ := e.do(t, "GET", "/api/v1/chats", nil, bearer(token)) + if items, _ := list["items"].([]any); len(items) != 0 { + t.Fatalf("failed creation must leave no chat, got %d", len(items)) + } +} + +func TestSessionLifecycle(t *testing.T) { + e := setup(t, 1) // TTL = 1 с + name := uname() + id, pass := e.register(t, name) + + // неверный пароль и неизвестный пользователь: одинаковый 401 + Basic challenge + for _, c := range []map[string]string{basic(name, "wrong-password-xx"), basic(uname(), "whatever-password")} { + status, _, h := e.do(t, "POST", "/api/v1/auth/sessions", nil, c) + if status != 401 || h.Get("WWW-Authenticate") != basicChallenge { + t.Fatalf("bad credentials: %d %q", status, h.Get("WWW-Authenticate")) + } + } + token := e.login(t, name, pass) + + status, out, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token)) + if status != 200 || out["id"] != id { + t.Fatalf("fresh session must work: %d", status) + } + // X-User-Id не даёт доступа и не подменяет владельца; Basic на бизнес-эндпоинте — 401 + if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, map[string]string{"X-User-Id": id}); status != 401 { + t.Fatalf("X-User-Id alone must give 401, got %d", status) + } + if status, _, h := e.do(t, "GET", "/api/v1/users/me", nil, basic(name, pass)); status != 401 || h.Get("WWW-Authenticate") != bearerChallenge { + t.Fatalf("Basic on business endpoint must give 401 Bearer, got %d", status) + } + + // истечение срока + time.Sleep(1300 * time.Millisecond) + if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token)); status != 401 { + t.Fatalf("expired session must give 401, got %d", status) + } + + // logout (отдельный пользователь с длинным TTL) + long := setup(t, 3600) + n2 := uname() + _, p2 := long.register(t, n2) + t2 := long.login(t, n2, p2) + if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 204 { + t.Fatalf("logout must give 204, got %d", status) + } + if status, _, _ := long.do(t, "GET", "/api/v1/users/me", nil, bearer(t2)); status != 401 { + t.Fatalf("revoked token must give 401, got %d", status) + } + if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 401 { + t.Fatalf("repeated logout must give 401, got %d", status) + } +} + +func TestMigrationsAreIdempotent(t *testing.T) { + e := setup(t, 3600) + name := uname() + e.register(t, name) + count := func(table string) int { + var n int + if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM `+table).Scan(&n); err != nil { + t.Fatal(err) + } + return n + } + users, versions := count("users"), count("schema_migrations") + for i := 0; i < 2; i++ { + if err := runMigrations(context.Background(), e.url); err != nil { + t.Fatal(err) + } + } + if count("users") != users || count("schema_migrations") != versions { + t.Fatal("re-running migrations changed data or duplicated version records") + } +} diff --git a/auth.go b/auth.go new file mode 100644 index 00000000..561fd665 --- /dev/null +++ b/auth.go @@ -0,0 +1,110 @@ +package main + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "net/http" + "regexp" + "strings" + "unicode/utf8" + + "github.com/alexedwards/argon2id" +) + +// Argon2id (RFC 9106, профиль «низкая память»: t=3, m=64 MiB). Параметры хранятся внутри PHC-строки хеша, +// поэтому их можно менять без инвалидации старых паролей. +var argonParams = &argon2id.Params{Memory: 64 * 1024, Iterations: 3, Parallelism: 2, SaltLength: 16, KeyLength: 32} + +var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{32,256}$`) + +// Hasher ограничивает число одновременных хеширований: каждое занимает 64 MiB памяти. +type Hasher struct { + sem chan struct{} + dummy string // хеш-«пустышка»: вход несуществующего пользователя стоит столько же времени, сколько неверный пароль +} + +func newHasher(concurrency int) *Hasher { + h := &Hasher{sem: make(chan struct{}, concurrency)} + dummy, err := argon2id.CreateHash("dummy-password-for-timing-equalization", argonParams) + if err != nil { + panic(err) + } + h.dummy = dummy + return h +} + +func (h *Hasher) acquire(ctx context.Context) error { + select { + case h.sem <- struct{}{}: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} +func (h *Hasher) release() { <-h.sem } + +func (h *Hasher) hash(ctx context.Context, password string) (string, error) { + if err := h.acquire(ctx); err != nil { + return "", err + } + defer h.release() + return argon2id.CreateHash(password, argonParams) +} + +func (h *Hasher) verify(ctx context.Context, password, hash string) (bool, error) { + if err := h.acquire(ctx); err != nil { + return false, err + } + defer h.release() + return argon2id.ComparePasswordAndHash(password, hash) // сравнение за постоянное время +} + +// newToken: 32 байта из crypto/rand (256 бит), клиенту — base64url (43 символа), в БД — только SHA-256. +func newToken() (token string, hash []byte) { + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + panic("crypto/rand failed") + } + token = base64.RawURLEncoding.EncodeToString(raw) + return token, hashToken(token) +} + +func hashToken(token string) []byte { + sum := sha256.Sum256([]byte(token)) + return sum[:] +} + +// splitAuthorization разбирает «Scheme value»; схема нечувствительна к регистру (RFC 9110). +func splitAuthorization(r *http.Request) (scheme, value string) { + header := r.Header.Get("Authorization") + scheme, value, ok := strings.Cut(header, " ") + if !ok { + return "", "" + } + return strings.ToLower(scheme), strings.TrimSpace(value) +} + +// parseBasic: base64(username:password), UTF-8. Двоеточие допустимо в пароле, но не в username. +func parseBasic(r *http.Request) (username, password string, ok bool) { + scheme, value := splitAuthorization(r) + if scheme != "basic" || value == "" { + return "", "", false + } + decoded, err := base64.StdEncoding.DecodeString(value) + if err != nil || len(decoded) > 1024 || !utf8.Valid(decoded) { + return "", "", false + } + username, password, ok = strings.Cut(string(decoded), ":") + return username, password, ok +} + +// bearerToken возвращает токен только из «Authorization: Bearer …». X-User-Id и Basic игнорируются. +func bearerToken(r *http.Request) (string, bool) { + scheme, value := splitAuthorization(r) + if scheme != "bearer" || !tokenPattern.MatchString(value) { + return "", false + } + return value, true +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..e0d013ef --- /dev/null +++ b/compose.yaml @@ -0,0 +1,125 @@ +# Лабораторная 3: Клиент → nginx (LB) → API × N → PostgreSQL (данные + сессии + ключи идемпотентности). +# Запуск: sh scripts/init-secrets.sh (или .ps1) && docker compose up -d --build +# Секреты лежат в ./secrets (создаются scripts/init-secrets.*, в Git не попадают). +name: mtusi-lab3 + +services: + postgres: + image: postgres:16.9-bookworm + restart: unless-stopped + environment: + POSTGRES_DB: ${POSTGRES_DB:-messenger} + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + command: ["postgres", "-c", "fsync=on", "-c", "synchronous_commit=on", "-c", "full_page_writes=on", "-c", "max_connections=100"] + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + networks: + - backend + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 10s + stop_grace_period: 30s + deploy: + resources: + limits: { cpus: "1.0", memory: 512m } + + # Одноразовая задача: ровно ОДИН процесс применяет миграции (под advisory lock) и завершается. + # Реплики API стартуют только после её успешного завершения и сами миграции не запускают. + migrate: + build: . + image: mtusi-messenger:lab3 + command: ["migrate"] + restart: "no" + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + networks: + - backend + + # Взаимозаменяемые реплики. Без container_name и без published ports: наружу — только через LB. + # Локального состояния нет: сессии, ключи идемпотентности и данные — в PostgreSQL. + api: + build: . + image: mtusi-messenger:lab3 + restart: unless-stopped + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: postgres + DATABASE_URL_FILE: /run/secrets/database_url + DB_MAX_CONNS: ${DB_MAX_CONNS:-10} + SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:-1} + secrets: + - database_url + expose: + - "8080" + depends_on: + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + networks: + - lb + - backend + read_only: true + cap_drop: + - ALL + security_opt: + - no-new-privileges:true + stop_grace_period: 15s + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: { cpus: "0.5", memory: 256m } + + # Единственная публичная точка входа. Адреса backend берутся из DNS Docker (имя `api` + # указывает на все живые реплики) и перерезолвятся каждую секунду — см. infra/nginx/default.conf. + lb: + image: nginx:1.27.5-alpine + restart: unless-stopped + ports: + - "127.0.0.1:${PUBLISHED_PORT:-8080}:80" + volumes: + - ./infra/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro + depends_on: + api: + condition: service_healthy + networks: + - lb + - frontend + healthcheck: + test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1/lb-health || exit 1"] + interval: 5s + timeout: 3s + retries: 6 + deploy: + resources: + limits: { cpus: "0.5", memory: 128m } + +networks: + frontend: {} + lb: + internal: true # LB ↔ API + backend: + internal: true # API ↔ PostgreSQL, наружу выхода нет + +volumes: + pgdata: {} # переживает stop/start/restart/up; удаляется только `docker compose down -v` + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url diff --git a/config.go b/config.go new file mode 100644 index 00000000..7e76cbbe --- /dev/null +++ b/config.go @@ -0,0 +1,87 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "strings" + "time" +) + +// Config собирается только из переменных окружения (см. .env.example). +// Секреты (строка подключения к БД) читаются из файла, а не из env. +type Config struct { + Host string + Port string + SessionTTLSecs int + SessionStore string + DatabaseURL string + DBMaxConns int32 + DrainPeriod time.Duration +} + +func envOr(name, fallback string) string { + if v := os.Getenv(name); v != "" { + return v + } + return fallback +} + +func envInt(name string, fallback, min, max int) (int, error) { + raw := os.Getenv(name) + if raw == "" { + return fallback, nil + } + n, err := strconv.Atoi(raw) + if err != nil || n < min || n > max { + return 0, fmt.Errorf("%s must be an integer in [%d, %d]", name, min, max) + } + return n, nil +} + +// readSecretFile читает секрет из файла (Docker secrets); BOM и перевод строки отбрасываются, +// чтобы файл, созданный в Windows PowerShell, работал так же, как созданный в Linux. +func readSecretFile(path string) (string, error) { + raw, err := os.ReadFile(path) + if err != nil { + return "", err + } + return strings.TrimSpace(strings.TrimPrefix(string(raw), "\xEF\xBB\xBF")), nil +} + +func loadConfig() (Config, error) { + cfg := Config{Host: envOr("APP_HOST", "0.0.0.0"), Port: envOr("APP_PORT", "8080")} + if _, err := strconv.Atoi(cfg.Port); err != nil { + return cfg, fmt.Errorf("APP_PORT must be an integer") + } + ttl, err := envInt("SESSION_TTL_SECONDS", 3600, 1, 30*24*3600) + if err != nil { + return cfg, err + } + cfg.SessionTTLSecs = ttl + conns, err := envInt("DB_MAX_CONNS", 10, 1, 100) + if err != nil { + return cfg, err + } + cfg.DBMaxConns = int32(conns) + drain, err := envInt("SHUTDOWN_DRAIN_SECONDS", 1, 0, 30) + if err != nil { + return cfg, err + } + cfg.DrainPeriod = time.Duration(drain) * time.Second + cfg.SessionStore = envOr("SESSION_STORE", "postgres") + if cfg.SessionStore != "postgres" { + return cfg, fmt.Errorf("SESSION_STORE=%q is not supported at grade 3 (only \"postgres\")", cfg.SessionStore) + } + if file := os.Getenv("DATABASE_URL_FILE"); file != "" { + if cfg.DatabaseURL, err = readSecretFile(file); err != nil { + return cfg, fmt.Errorf("cannot read DATABASE_URL_FILE: %w", err) + } + } else { + cfg.DatabaseURL = os.Getenv("DATABASE_URL") // только для локальной отладки без Docker secrets + } + if cfg.DatabaseURL == "" { + return cfg, fmt.Errorf("set DATABASE_URL_FILE (path to a file with the PostgreSQL URL)") + } + return cfg, nil +} diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..f8f6332c --- /dev/null +++ b/go.mod @@ -0,0 +1,18 @@ +module mtusi-messenger + +go 1.23 + +require ( + github.com/alexedwards/argon2id v1.0.0 + github.com/jackc/pgx/v5 v5.7.2 +) + +require ( + 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 + golang.org/x/crypto v0.31.0 // indirect + golang.org/x/sync v0.10.0 // indirect + golang.org/x/sys v0.28.0 // indirect + golang.org/x/text v0.21.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..b5945b58 --- /dev/null +++ b/go.sum @@ -0,0 +1,70 @@ +github.com/alexedwards/argon2id v1.0.0 h1:wJzDx66hqWX7siL/SRUmgz3F8YMrd/nfX/xHHcQQP0w= +github.com/alexedwards/argon2id v1.0.0/go.mod h1:tYKkqIjzXvZdzPvADMWOEZ+l6+BD6CtBXMj5fnJppiw= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +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.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI= +github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ= +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/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +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.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= +golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= +golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +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= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/handlers.go b/handlers.go new file mode 100644 index 00000000..0c7c858f --- /dev/null +++ b/handlers.go @@ -0,0 +1,405 @@ +package main + +import ( + "context" + "crypto/sha256" + "sync/atomic" + "errors" + "log" + "net/http" + "runtime/debug" + "sort" + "strings" + "time" + "unicode/utf8" +) + +type API struct { + store *Store + hasher *Hasher + ttlSecs int + reqLimit time.Duration + // instanceID — стабильный на всё время жизни процесса псевдоним реплики (X-Instance-Id). + instanceID string + // draining выставляется по SIGTERM: /health/ready отвечает 503, новые запросы уходят на другие реплики. + draining atomic.Bool +} + +// ---- аутентификация ---- + +// actor: «кто вы». Только действующая Bearer-сессия из PostgreSQL; ответ на любой сбой одинаков. +func (a *API) actor(r *http.Request) (User, string, *apiError) { + token, ok := bearerToken(r) + if !ok { + return User{}, "", unauthorized(bearerChallenge, "Требуется Authorization: Bearer ") + } + user, err := a.store.sessionUser(r.Context(), hashToken(token)) + if errors.Is(err, errNotFound) { + return User{}, "", unauthorized(bearerChallenge, "Недействительная сессия") + } + if err != nil { + return User{}, "", dbFail(err) + } + return user, token, nil +} + +func (a *API) createSession(r *http.Request) (int, any, *apiError) { + denied := unauthorized(basicChallenge, "Неверные учётные данные") + username, password, ok := parseBasic(r) + if !ok { + return 0, nil, denied + } + user, hash, err := a.store.userWithHash(r.Context(), username) + found := err == nil + if err != nil && !errors.Is(err, errNotFound) { + return 0, nil, dbFail(err) + } + if !found { + hash = a.hasher.dummy + } + match, herr := a.hasher.verify(r.Context(), password, hash) + if herr != nil && !errors.Is(herr, context.Canceled) && !errors.Is(herr, context.DeadlineExceeded) { + match = false // повреждённый хеш = отказ, не 500 + } else if herr != nil { + return 0, nil, unavailable() + } + if !found || !match { + return 0, nil, denied + } + token, tokenHash := newToken() + expires, err := a.store.createSession(r.Context(), tokenHash, user.ID, a.ttlSecs) + if err != nil { + return 0, nil, dbFail(err) + } + return http.StatusCreated, map[string]any{ + "token": token, "token_type": "Bearer", "expires_at": formatTime(expires), "user": user, + }, nil +} + +func (a *API) revokeSession(r *http.Request) (int, any, *apiError) { + _, token, err := a.actor(r) + if err != nil { + return 0, nil, err + } + if rerr := a.store.revokeSession(r.Context(), hashToken(token)); rerr != nil { + return 0, nil, dbFail(rerr) + } + return http.StatusNoContent, nil, nil +} + +// ---- пользователи ---- + +func (a *API) createUser(r *http.Request) (int, any, *apiError) { + body, err := readJSON(r) + if err != nil { + return 0, nil, err + } + if err := exactFields(body, "username", "display_name", "password"); err != nil { + return 0, nil, err + } + username, ok := body["username"].(string) + if !ok || !usernamePattern.MatchString(username) { + return 0, nil, invalid("Некорректный username") + } + displayName, err := requiredString(body["display_name"], 100, "display_name") + if err != nil { + return 0, nil, err + } + password, ok := body["password"].(string) + if n := utf8.RuneCountInString(password); !ok || !utf8.ValidString(password) || n < 12 || n > 128 { + return 0, nil, invalid("Некорректный password") + } + hash, herr := a.hasher.hash(r.Context(), password) + if herr != nil { + return 0, nil, unavailable() + } + user, serr := a.store.createUser(r.Context(), User{ID: newUUID(), Username: username, DisplayName: displayName}, hash) + if errors.Is(serr, errConflict) { + return 0, nil, fail(http.StatusConflict, "conflict", "Username уже занят") + } + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusCreated, user, nil +} + +func (a *API) currentUser(r *http.Request) (int, any, *apiError) { + user, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + return http.StatusOK, user, nil +} + +// ---- чаты ---- + +func (a *API) createChat(r *http.Request) (int, any, *apiError) { + actor, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + body, err := readJSON(r) + if err != nil { + return 0, nil, err + } + if err := exactFields(body, "title", "member_ids"); err != nil { + return 0, nil, err + } + title, err := requiredString(body["title"], 100, "title") + if err != nil { + return 0, nil, err + } + rawMembers, ok := body["member_ids"].([]any) + if !ok || len(rawMembers) < 1 || len(rawMembers) > 100 { + return 0, nil, invalid("Некорректные участники") + } + members, seen := make([]string, 0, len(rawMembers)), map[string]bool{} + for _, raw := range rawMembers { + member, typeOK := raw.(string) + id, idOK := validUUID(member) + if !typeOK || !idOK || seen[id] { + return 0, nil, invalid("Некорректные участники") + } + seen[id] = true + members = append(members, id) + } + if !seen[actor.ID] { + return 0, nil, invalid("Создатель должен быть участником") + } + sort.Strings(members) // детерминированный порядок: одинаковый в POST и GET + chat, serr := a.store.createChat(r.Context(), Chat{ID: newUUID(), Title: title, MemberIDs: members}, actor.ID) + if errors.Is(serr, errInvalidMembers) { + return 0, nil, invalid("Некорректные участники") + } + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusCreated, chat, nil +} + +func (a *API) listChats(r *http.Request) (int, any, *apiError) { + actor, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + limit, rawCursor, err := parsePage(r) + if err != nil { + return 0, nil, err + } + var after *time.Time + var afterID string + if rawCursor != "" { + t, id, cerr := decodeCursor(rawCursor, "chats", actor.ID) + if cerr != nil { + return 0, nil, cerr + } + after, afterID = &t, id + } + items, next, serr := a.store.listChats(r.Context(), actor.ID, limit, after, afterID) + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusOK, pageBody(items, next), nil +} + +func pageBody(items any, next string) map[string]any { + var cursor any + if next != "" { + cursor = next + } + return map[string]any{"items": items, "next_cursor": cursor} +} + +// chatAccess: сначала аутентификация (вызывается до этого), затем доступ к конкретному чату. +// Чужой и несуществующий чат неразличимы: оба дают 404. +func (a *API) chatAccess(r *http.Request, actorID, rawID string) (string, *apiError) { + id, ok := validUUID(rawID) + if !ok { + return "", invalid("Некорректный идентификатор") + } + member, err := a.store.isMember(r.Context(), actorID, id) + if err != nil { + return "", dbFail(err) + } + if !member { + return "", notFound() + } + return id, nil +} + +func (a *API) getChat(r *http.Request, rawID string) (int, any, *apiError) { + actor, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + id, ok := validUUID(rawID) + if !ok { + return 0, nil, invalid("Некорректный идентификатор") + } + chat, serr := a.store.getChat(r.Context(), actor.ID, id) + if errors.Is(serr, errNotFound) { + return 0, nil, notFound() + } + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusOK, chat, nil +} + +// ---- сообщения ---- + +func (a *API) createMessage(r *http.Request, rawID string) (int, any, *apiError) { + actor, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + chatID, err := a.chatAccess(r, actor.ID, rawID) + if err != nil { + return 0, nil, err + } + keys := r.Header.Values("Idempotency-Key") + if len(keys) != 1 || !idempotencyKeyPattern.MatchString(keys[0]) { + return 0, nil, invalid("Требуется корректный заголовок Idempotency-Key") + } + key := keys[0] + body, err := readJSON(r) + if err != nil { + return 0, nil, err + } + // sender_id в теле не принимается: лишнее поле — 400. Отправитель берётся только из сессии. + if err := exactFields(body, "text"); err != nil { + return 0, nil, err + } + text, err := requiredString(body["text"], 4000, "text") + if err != nil { + return 0, nil, err + } + sum := sha256.Sum256([]byte(text)) // канонический вид тела: единственное поле text + path := "/api/v1/chats/" + chatID + "/messages" + message, _, serr := a.store.createMessageIdempotent(r.Context(), + Message{ID: newUUID(), ChatID: chatID, SenderID: actor.ID, Text: text}, key, path, sum[:]) + if errors.Is(serr, errConflict) { + return 0, nil, fail(http.StatusConflict, "conflict", "Idempotency-Key уже использован с другим сообщением") + } + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusCreated, message, nil +} + +func (a *API) listMessages(r *http.Request, rawID string) (int, any, *apiError) { + actor, _, err := a.actor(r) + if err != nil { + return 0, nil, err + } + chatID, err := a.chatAccess(r, actor.ID, rawID) + if err != nil { + return 0, nil, err + } + limit, rawCursor, err := parsePage(r) + if err != nil { + return 0, nil, err + } + var after *time.Time + var afterID string + if rawCursor != "" { + t, id, cerr := decodeCursor(rawCursor, "messages", chatID) + if cerr != nil { + return 0, nil, cerr + } + after, afterID = &t, id + } + items, next, serr := a.store.listMessages(r.Context(), chatID, limit, after, afterID) + if serr != nil { + return 0, nil, dbFail(serr) + } + return http.StatusOK, pageBody(items, next), nil +} + +// ---- health ---- + +func (a *API) ready(r *http.Request) (int, any, *apiError) { + if a.draining.Load() { + return 0, nil, unavailable() + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + if err := a.store.ready(ctx); err != nil { + log.Printf("readiness: dependency check failed") + return 0, nil, unavailable() + } + return http.StatusOK, map[string]string{"status": "ok"}, nil +} + +// ---- маршрутизация ---- + +func (a *API) dispatch(r *http.Request) (int, any, *apiError) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && path == "/health/live": + return http.StatusOK, map[string]string{"status": "ok"}, nil + case r.Method == http.MethodGet && path == "/health/ready": + return a.ready(r) + case r.Method == http.MethodPost && path == "/api/v1/users": + return a.createUser(r) + case r.Method == http.MethodGet && path == "/api/v1/users/me": + return a.currentUser(r) + case r.Method == http.MethodPost && path == "/api/v1/auth/sessions": + return a.createSession(r) // единственное место, где принимается Basic + case r.Method == http.MethodDelete && path == "/api/v1/auth/sessions/current": + return a.revokeSession(r) + case r.Method == http.MethodPost && path == "/api/v1/chats": + return a.createChat(r) + case r.Method == http.MethodGet && path == "/api/v1/chats": + return a.listChats(r) + } + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 4 && strings.Join(parts[:3], "/") == "api/v1/chats" && r.Method == http.MethodGet { + return a.getChat(r, parts[3]) + } + if len(parts) == 5 && strings.Join(parts[:3], "/") == "api/v1/chats" && parts[4] == "messages" { + if r.Method == http.MethodPost { + return a.createMessage(r, parts[3]) + } + if r.Method == http.MethodGet { + return a.listMessages(r, parts[3]) + } + } + return 0, nil, notFound() +} + +type statusWriter struct { + http.ResponseWriter + status int +} + +func (w *statusWriter) WriteHeader(code int) { w.status = code; w.ResponseWriter.WriteHeader(code) } + +func (a *API) ServeHTTP(rw http.ResponseWriter, r *http.Request) { + id := newUUID() + rw.Header().Set("X-Instance-Id", a.instanceID) + w := &statusWriter{ResponseWriter: rw, status: 200} + started := time.Now() + ctx, cancel := context.WithTimeout(r.Context(), a.reqLimit) + defer cancel() + r = r.WithContext(ctx) + defer func() { + if rec := recover(); rec != nil { + log.Printf("panic request_id=%s: %v\n%s", id, rec, debug.Stack()) + writeError(w, id, fail(http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")) + } + // В лог не попадают заголовки, query-строка, тела запросов и токены. + log.Printf("%s %s -> %d request_id=%s %s", r.Method, r.URL.Path, w.status, id, time.Since(started).Round(time.Millisecond)) + }() + status, body, err := a.dispatch(r) + if err != nil { + writeError(w, id, err) + return + } + if status == http.StatusNoContent { + w.Header().Set("X-Request-Id", id) + w.WriteHeader(status) + return + } + writeJSON(w, id, status, body) +} diff --git a/httpx.go b/httpx.go new file mode 100644 index 00000000..6cfcc34d --- /dev/null +++ b/httpx.go @@ -0,0 +1,204 @@ +package main + +import ( + "crypto/rand" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "mime" + "net/http" + "regexp" + "strconv" + "strings" + "time" + "unicode/utf8" +) + +const maxJSONBytes = 1 << 20 + +var ( + usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`) +) + +type apiError struct { + status int + code, message string + challenge string // значение WWW-Authenticate для 401 +} + +func fail(status int, code, message string) *apiError { + return &apiError{status: status, code: code, message: message} +} +func invalid(message string) *apiError { + return fail(http.StatusBadRequest, "invalid_request", message) +} +func notFound() *apiError { + return fail(http.StatusNotFound, "not_found", "Объект не найден") +} +func unavailable() *apiError { + return fail(http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен") +} +func unauthorized(challenge, message string) *apiError { + e := fail(http.StatusUnauthorized, "unauthorized", message) + e.challenge = challenge + return e +} + +const ( + bearerChallenge = `Bearer realm="messenger"` + basicChallenge = `Basic realm="messenger", charset="UTF-8"` +) + +func newUUID() string { + b := make([]byte, 16) + if _, err := rand.Read(b); err != nil { + panic("crypto/rand failed") + } + 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]) +} + +// formatTime — RFC 3339 UTC, всегда 6 знаков долей секунды (точность PostgreSQL). +func formatTime(t time.Time) string { return t.UTC().Format("2006-01-02T15:04:05.000000Z") } + +func validUUID(value string) (string, bool) { + if !uuidPattern.MatchString(value) { + return "", false + } + return strings.ToLower(value), true +} + +// cleanText: валидный UTF-8 без NUL (PostgreSQL не хранит \x00 в text). +func cleanText(s string) bool { return utf8.ValidString(s) && !strings.ContainsRune(s, 0) } + +func requiredString(value any, limit int, field string) (string, *apiError) { + text, ok := value.(string) + if !ok || text == "" || strings.TrimSpace(text) == "" || !cleanText(text) || utf8.RuneCountInString(text) > limit { + return "", invalid("Некорректное поле " + field) + } + return text, nil +} + +func exactFields(body map[string]any, expected ...string) *apiError { + if len(body) != len(expected) { + return invalid("Неожиданные или отсутствующие поля") + } + for _, name := range expected { + if _, ok := body[name]; !ok { + return invalid("Неожиданные или отсутствующие поля") + } + } + return nil +} + +func readJSON(r *http.Request) (map[string]any, *apiError) { + mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || mediaType != "application/json" { + return nil, fail(http.StatusUnsupportedMediaType, "unsupported_media_type", "Требуется application/json") + } + raw, err := io.ReadAll(io.LimitReader(r.Body, maxJSONBytes+1)) + if err != nil { + return nil, invalid("Некорректное тело запроса") + } + if len(raw) > maxJSONBytes { + return nil, fail(http.StatusRequestEntityTooLarge, "payload_too_large", "Слишком большой JSON") + } + if !utf8.Valid(raw) { + return nil, invalid("Некорректный JSON") + } + decoder := json.NewDecoder(strings.NewReader(string(raw))) + var body map[string]any + if err := decoder.Decode(&body); err != nil || body == nil { + return nil, invalid("Некорректный JSON") + } + var trailing any + if err := decoder.Decode(&trailing); err != io.EOF { + return nil, invalid("Некорректный JSON") + } + return body, nil +} + +func writeJSON(w http.ResponseWriter, id string, status int, body any) { + w.Header().Set("X-Request-Id", id) + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + enc := json.NewEncoder(w) + enc.SetEscapeHTML(false) + _ = enc.Encode(body) +} + +func writeError(w http.ResponseWriter, id string, err *apiError) { + if err.challenge != "" { + w.Header().Set("WWW-Authenticate", err.challenge) + } + writeJSON(w, id, err.status, map[string]any{"error": map[string]string{"code": err.code, "message": err.message, "request_id": id}}) +} + +func parsePage(r *http.Request) (int, string, *apiError) { + query := r.URL.Query() + if len(query["limit"]) > 1 || len(query["cursor"]) > 1 { + return 0, "", invalid("Повторяющийся параметр пагинации") + } + limit := 50 + if values, exists := query["limit"]; exists { + n, err := strconv.Atoi(values[0]) + if err != nil || n < 1 || n > 100 || strconv.Itoa(n) != values[0] { + return 0, "", invalid("Некорректный limit") + } + limit = n + } + if values, exists := query["cursor"]; exists { + if values[0] == "" { + return 0, "", invalid("Некорректный cursor") + } + return limit, values[0], nil + } + return limit, "", nil +} + +// cursor — непрозрачная для клиента строка: ключ (created_at, id) + тип списка + владелец +// (id чата либо пользователя). Курсор другого ресурса отклоняется с 400. +type cursor struct { + Kind string `json:"k"` + Owner string `json:"o"` + Time string `json:"t"` + ID string `json:"i"` +} + +func encodeCursor(kind, owner string, created time.Time, id string) string { + raw, _ := json.Marshal(cursor{kind, owner, formatTime(created), id}) + return base64.RawURLEncoding.EncodeToString(raw) +} + +func decodeCursor(value, kind, owner string) (time.Time, string, *apiError) { + raw, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return time.Time{}, "", invalid("Некорректный cursor") + } + var fields map[string]any + if json.Unmarshal(raw, &fields) != nil || len(fields) != 4 { + return time.Time{}, "", invalid("Некорректный cursor") + } + for _, name := range []string{"k", "o", "t", "i"} { + if _, ok := fields[name].(string); !ok { + return time.Time{}, "", invalid("Некорректный cursor") + } + } + c := cursor{fields["k"].(string), fields["o"].(string), fields["t"].(string), fields["i"].(string)} + if c.Kind != kind || c.Owner != owner { + return time.Time{}, "", invalid("Некорректный cursor") + } + id, ok := validUUID(c.ID) + if !ok { + return time.Time{}, "", invalid("Некорректный cursor") + } + t, err := time.Parse("2006-01-02T15:04:05.000000Z", c.Time) + if err != nil { + return time.Time{}, "", invalid("Некорректный cursor") + } + return t, id, nil +} diff --git a/infra/nginx/default.conf b/infra/nginx/default.conf new file mode 100644 index 00000000..350a79f9 --- /dev/null +++ b/infra/nginx/default.conf @@ -0,0 +1,36 @@ +# LB без sticky session: каждый запрос независимо уходит на любую живую реплику. +# Docker DNS отдаёт имя `api` → IP всех работающих реплик (в случайном порядке); +# resolver с valid=1s заставляет nginx обновлять список backend каждую секунду, +# поэтому остановленная реплика исчезает из ротации максимум за ~1-2 с. +resolver 127.0.0.11 valid=1s ipv6=off; + +server { + listen 80; + server_name _; + + # Проверка самого LB (healthcheck контейнера). + location = /lb-health { + access_log off; + default_type text/plain; + return 200 "ok\n"; + } + + location / { + set $api_upstream http://api:8080; + proxy_pass $api_upstream; + + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $remote_addr; + + # Отказ реплики: быстрый connect-timeout и повтор на другом адресе. + # Повторяются только ошибки соединения/таймаут/502/503/504; POST после отправки тела + # автоматически НЕ повторяется (без non_idempotent) — безопасный повтор делает клиент + # с тем же Idempotency-Key. + proxy_connect_timeout 1s; + proxy_send_timeout 10s; + proxy_read_timeout 10s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 3; + proxy_next_upstream_timeout 5s; + } +} diff --git a/main.go b/main.go new file mode 100644 index 00000000..83444cdf --- /dev/null +++ b/main.go @@ -0,0 +1,116 @@ +package main + +import ( + "context" + "errors" + "fmt" + "log" + "net" + "net/http" + "os" + "os/signal" + "syscall" + "time" +) + +func main() { + command := "serve" + if len(os.Args) > 1 { + command = os.Args[1] + } + switch command { + case "serve": + os.Exit(serve()) + case "migrate": + os.Exit(migrateCommand()) + case "healthcheck": + os.Exit(healthcheck()) + default: + fmt.Fprintln(os.Stderr, "usage: messenger [serve|migrate|healthcheck]") + os.Exit(2) + } +} + +func migrateCommand() int { + cfg, err := loadConfig() + if err != nil { + log.Printf("config error: %v", err) + return 1 + } + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + if err := runMigrations(ctx, cfg.DatabaseURL); err != nil { + log.Printf("migrate failed: %v", err) + return 1 + } + return 0 +} + +// healthcheck нужен для HEALTHCHECK контейнера: в образе scratch нет ни shell, ни curl. +func healthcheck() int { + client := &http.Client{Timeout: 3 * time.Second} + resp, err := client.Get("http://127.0.0.1:" + envOr("APP_PORT", "8080") + "/health/ready") + if err != nil { + return 1 + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + return 1 + } + return 0 +} + +func serve() int { + cfg, err := loadConfig() + if err != nil { + log.Printf("config error: %v", err) + return 1 + } + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + + pool, err := newPool(ctx, cfg.DatabaseURL, cfg.DBMaxConns) + if err != nil { + log.Printf("database setup error: %v", err) + return 1 + } + defer pool.Close() + + // Псевдоним реплики = hostname контейнера (короткий ID): по нему stop-one находит контейнер. + instance, _ := os.Hostname() + if instance == "" { + instance = newUUID() + } + api := &API{store: &Store{pool: pool}, hasher: newHasher(4), ttlSecs: cfg.SessionTTLSecs, reqLimit: 8 * time.Second, instanceID: instance} + server := &http.Server{ + Addr: net.JoinHostPort(cfg.Host, cfg.Port), + Handler: api, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 30 * time.Second, + IdleTimeout: 60 * time.Second, + } + errs := make(chan error, 1) + go func() { errs <- server.ListenAndServe() }() + log.Printf("messenger listening on %s (instance %s, session ttl %ds, max db conns %d)", server.Addr, instance, cfg.SessionTTLSecs, cfg.DBMaxConns) + + select { + case err := <-errs: + if !errors.Is(err, http.ErrServerClosed) { + log.Printf("server error: %v", err) + return 1 + } + case <-ctx.Done(): + // Сначала перестаём быть «готовыми», даём LB время убрать реплику, и только затем закрываем listener. + api.draining.Store(true) + log.Printf("shutting down: not ready, draining %s, then finishing in-flight requests", cfg.DrainPeriod) + time.Sleep(cfg.DrainPeriod) + shutdown, cancel := context.WithTimeout(context.Background(), 8*time.Second) + defer cancel() + if err := server.Shutdown(shutdown); err != nil { + log.Printf("shutdown error: %v", err) + return 1 + } + } + return 0 +} diff --git a/migrate.go b/migrate.go new file mode 100644 index 00000000..76fe717f --- /dev/null +++ b/migrate.go @@ -0,0 +1,122 @@ +package main + +import ( + "context" + "crypto/sha256" + "embed" + "encoding/hex" + "fmt" + "log" + "sort" + "strconv" + "strings" + "time" + + "github.com/jackc/pgx/v5" +) + +//go:embed migrations/*.sql +var migrationFS embed.FS + +// Произвольная константа-ключ advisory lock: параллельные запуски миграций выстраиваются в очередь. +const migrationLockKey int64 = 7_272_026_002 + +type migration struct{ version, sql, checksum string } + +func itoa(n int) string { return strconv.Itoa(n) } + +func loadMigrations() []migration { + entries, err := migrationFS.ReadDir("migrations") + if err != nil { + panic(err) + } + var list []migration + for _, e := range entries { + if e.IsDir() || !strings.HasSuffix(e.Name(), ".sql") { + continue + } + raw, err := migrationFS.ReadFile("migrations/" + e.Name()) + if err != nil { + panic(err) + } + sum := sha256.Sum256(raw) + list = append(list, migration{strings.TrimSuffix(e.Name(), ".sql"), string(raw), hex.EncodeToString(sum[:])}) + } + sort.Slice(list, func(i, j int) bool { return list[i].version < list[j].version }) + return list +} + +func migrationVersions() []string { + var v []string + for _, m := range loadMigrations() { + v = append(v, m.version) + } + return v +} + +// runMigrations применяет только ещё не применённые версии. Повторный запуск ничего не меняет и не трогает данные: +// каждая версия записывается в schema_migrations в той же транзакции, что и сама миграция. +func runMigrations(ctx context.Context, databaseURL string) error { + var conn *pgx.Conn + var err error + deadline := time.Now().Add(60 * time.Second) + for { + cctx, cancel := context.WithTimeout(ctx, 5*time.Second) + conn, err = pgx.Connect(cctx, databaseURL) + cancel() + if err == nil { + break + } + if time.Now().After(deadline) || ctx.Err() != nil { + return fmt.Errorf("database is not reachable: %w", err) + } + log.Printf("migrate: waiting for database...") + time.Sleep(2 * time.Second) + } + defer conn.Close(context.Background()) + + if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, migrationLockKey); err != nil { + return err + } + defer func() { _, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, migrationLockKey) }() + + if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + checksum text NOT NULL, + applied_at timestamptz NOT NULL DEFAULT now())`); err != nil { + return err + } + applied := 0 + for _, m := range loadMigrations() { + var have string + err := conn.QueryRow(ctx, `SELECT checksum FROM schema_migrations WHERE version = $1`, m.version).Scan(&have) + if err == nil { + if have != m.checksum { + return fmt.Errorf("migration %s was changed after being applied (checksum mismatch)", m.version) + } + continue + } + if err != pgx.ErrNoRows { + return err + } + tx, err := conn.Begin(ctx) + if err != nil { + return err + } + if _, err := tx.Exec(ctx, m.sql); err != nil { + _ = tx.Rollback(ctx) + return fmt.Errorf("migration %s failed: %w", m.version, err) + } + if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)`, m.version, m.checksum); err != nil { + _ = tx.Rollback(ctx) + return err + } + if err := tx.Commit(ctx); err != nil { + return err + } + applied++ + log.Printf("migrate: applied %s", m.version) + } + log.Printf("migrate: done, %d new, %d total", applied, len(loadMigrations())) + return nil +} diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..d6d71420 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,45 @@ +-- Источник истины: пользователи, чаты, участники и сообщения. +-- Транзакционные границы: +-- * регистрация — один INSERT в users (уникальность username решает сама БД); +-- * создание чата — INSERT в chats + INSERT всех участников в одной транзакции; +-- * отправка сообщения — один INSERT в messages (id и время назначает сервер). + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); +-- Список чатов отсортирован по (created_at, id) — keyset-пагинация без OFFSET. +CREATE INDEX chats_created_at_id_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id) +); +-- «Чаты пользователя»: поиск по user_id, а не по chat_id. +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_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 clock_timestamp(), + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); +-- История чата: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n. +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); diff --git a/migrations/002_sessions.sql b/migrations/002_sessions.sql new file mode 100644 index 00000000..b4785312 --- /dev/null +++ b/migrations/002_sessions.sql @@ -0,0 +1,15 @@ +-- Серверные сессии. Клиент получает непрозрачный токен (256 бит случайности), +-- в БД хранится только его SHA-256: утечка таблицы не раскрывает рабочие токены. +-- Срок жизни абсолютный (expires_at) и не продлевается рестартом. + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32), + CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at) +); +CREATE INDEX sessions_expires_at_idx ON sessions (expires_at); +CREATE INDEX sessions_user_idx ON sessions (user_id); diff --git a/migrations/003_idempotency.sql b/migrations/003_idempotency.sql new file mode 100644 index 00000000..348103e9 --- /dev/null +++ b/migrations/003_idempotency.sql @@ -0,0 +1,19 @@ +-- Общая (между репликами API) идемпотентность отправки сообщения. +-- Область уникальности: пользователь + HTTP-метод + путь чата + ключ. +-- Запись ключа и сообщение создаются в ОДНОЙ транзакции, поэтому «побочный эффект» и +-- «результат» атомарны, а конкурентный повтор на другой реплике блокируется уникальным +-- индексом до коммита первой транзакции и затем видит готовый результат. + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + method text NOT NULL, + path text NOT NULL, + key text NOT NULL, + request_hash bytea NOT NULL, + message_id uuid REFERENCES messages (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, key), + CONSTRAINT idempotency_key_format CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$') +); +-- Очистка ключей старше 24 часов. +CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at); diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 new file mode 100644 index 00000000..23dd0ee0 --- /dev/null +++ b/scripts/init-secrets.ps1 @@ -0,0 +1,25 @@ +# Creates local secrets and .env (Windows PowerShell 5.1 / PowerShell 7). +# Existing files are NEVER overwritten: the password of an already initialised database volume +# must keep matching secrets/postgres_password. +$ErrorActionPreference = 'Stop' +Set-Location (Join-Path $PSScriptRoot '..') +$db = if ($env:POSTGRES_DB) { $env:POSTGRES_DB } else { 'messenger' } +$user = if ($env:POSTGRES_USER) { $env:POSTGRES_USER } else { 'messenger' } +New-Item -ItemType Directory -Force -Path 'secrets' | Out-Null +# UTF-8 WITHOUT BOM and without a trailing newline: readable by the PostgreSQL image and by the app. +$utf8 = New-Object System.Text.UTF8Encoding($false) +$pwFile = Join-Path (Get-Location) 'secrets/postgres_password' +$urlFile = Join-Path (Get-Location) 'secrets/database_url' +if (-not (Test-Path $pwFile)) { + $bytes = New-Object byte[] 24 + [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes) + $password = ($bytes | ForEach-Object { $_.ToString('x2') }) -join '' + [System.IO.File]::WriteAllText($pwFile, $password, $utf8) + Write-Host 'created secrets/postgres_password' +} +if (-not (Test-Path $urlFile)) { + $password = [System.IO.File]::ReadAllText($pwFile).Trim() + [System.IO.File]::WriteAllText($urlFile, "postgres://${user}:${password}@postgres:5432/${db}?sslmode=disable", $utf8) + Write-Host 'created secrets/database_url' +} +if (-not (Test-Path '.env')) { Copy-Item '.env.example' '.env'; Write-Host 'created .env' } diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100644 index 00000000..cc362e34 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,20 @@ +#!/bin/sh +# Создаёт локальные секреты и .env (Linux/macOS/Git Bash). Существующие файлы НЕ перезаписываются: +# пароль уже созданной БД в volume должен совпадать с secrets/postgres_password. +set -eu +cd "$(dirname "$0")/.." +DB="${POSTGRES_DB:-messenger}" +USER_NAME="${POSTGRES_USER:-messenger}" +mkdir -p secrets +if [ ! -f secrets/postgres_password ]; then + head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/postgres_password + echo "created secrets/postgres_password" >&2 +fi +if [ ! -f secrets/database_url ]; then + printf 'postgres://%s:%s@postgres:5432/%s?sslmode=disable' "$USER_NAME" "$(cat secrets/postgres_password)" "$DB" > secrets/database_url + echo "created secrets/database_url" >&2 +fi +# Контейнеры работают не от вашего пользователя: файлы должны читаться всеми (каталог в Git не попадает). +chmod 755 secrets +chmod 644 secrets/postgres_password secrets/database_url +if [ ! -f .env ]; then cp .env.example .env; echo "created .env" >&2; fi diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..be2ea10e --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,25 @@ +@echo off +rem Full restart of LB, all API replicas and PostgreSQL, volumes are preserved (Windows). No secrets are printed. +setlocal +cd /d "%~dp0.." || exit /b 1 + +docker compose stop lb api postgres >nul 2>&1 +if errorlevel 1 exit /b 1 +docker compose start postgres >nul 2>&1 +if errorlevel 1 exit /b 1 + +set /a tries=0 +:waitpg +docker compose exec -T postgres sh -c "pg_isready -q -U $POSTGRES_USER -d $POSTGRES_DB" >nul 2>&1 +if not errorlevel 1 goto pgready +set /a tries+=1 +if %tries% GEQ 45 exit /b 1 +rem ping instead of timeout: timeout fails when stdin is redirected (as in tests/resilience.py) +ping -n 2 127.0.0.1 >nul +goto waitpg + +:pgready +docker compose start api >nul 2>&1 +if errorlevel 1 exit /b 1 +docker compose start lb >nul 2>&1 +exit /b %errorlevel% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..9e84d65f --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,23 @@ +#!/bin/sh +# Полный перезапуск LB, ВСЕХ реплик API и используемых хранилищ (PostgreSQL) с сохранением volumes. +# Не использует down -v / удаление volumes / повторный seed. Вывод секретов отсутствует. +set -eu +cd "$(dirname "$0")/.." + +# stop → SIGTERM (graceful): API дожидается запросов, PostgreSQL делает fast shutdown и сбрасывает WAL. +docker compose stop lb api postgres >/dev/null 2>&1 +docker compose start postgres >/dev/null 2>&1 + +tries=0 +until docker compose exec -T postgres sh -c 'pg_isready -q -U "$POSTGRES_USER" -d "$POSTGRES_DB"' >/dev/null 2>&1; do + tries=$((tries + 1)) + if [ "$tries" -ge 45 ]; then + echo "postgres did not become ready in time" >&2 + exit 1 + fi + sleep 1 +done + +docker compose start api >/dev/null 2>&1 +docker compose start lb >/dev/null 2>&1 +exit 0 diff --git a/scripts/start-all.cmd b/scripts/start-all.cmd new file mode 100644 index 00000000..41620ea4 --- /dev/null +++ b/scripts/start-all.cmd @@ -0,0 +1,3 @@ +@echo off +cd /d "%~dp0.." || exit /b 1 +docker compose up -d diff --git a/scripts/start-all.sh b/scripts/start-all.sh new file mode 100644 index 00000000..0bdcfd67 --- /dev/null +++ b/scripts/start-all.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Восстановление: поднимает все остановленные/недостающие сервисы (в т.ч. остановленную реплику API). +set -eu +cd "$(dirname "$0")/.." +docker compose up -d diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..6284c3bc --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,11 @@ +@echo off +rem Stops exactly ONE API replica: the container whose hostname equals TARGET_INSTANCE_ID (X-Instance-Id). +rem Leaves it stopped; DB, LB and volumes are untouched. Restore separately: docker compose up -d +setlocal +if "%TARGET_INSTANCE_ID%"=="" exit /b 2 +cd /d "%~dp0.." || exit /b 1 +set "CID=" +for /f %%i in ('docker ps -q --filter "id=%TARGET_INSTANCE_ID%" --filter "label=com.docker.compose.service=api"') do if not defined CID set "CID=%%i" +if not defined CID exit /b 1 +docker stop --time 5 %CID% >nul 2>&1 +exit /b %errorlevel% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..f6788986 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Останавливает РОВНО ОДНУ API-реплику: ту, чей X-Instance-Id (= hostname контейнера) передан в +# TARGET_INSTANCE_ID, и оставляет её остановленной. БД, LB и volumes не трогаются. Секреты не печатаются. +# Восстановление отдельно: docker compose up -d (или scripts/start-all.sh) +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +case "$TARGET_INSTANCE_ID" in + *[!A-Za-z0-9._-]*|"") echo "bad instance id" >&2; exit 2 ;; +esac +cd "$(dirname "$0")/.." +# Фильтр по compose-сервису api: LB/БД остановить этим скриптом невозможно. +cid=$(docker ps -q --filter "id=$TARGET_INSTANCE_ID" --filter "label=com.docker.compose.service=api" | head -n 1) +[ -n "$cid" ] || { echo "api container for instance not found" >&2; exit 1; } +# SIGTERM → graceful shutdown (ready=503, drain, закрытие listener); через 5 с — SIGKILL. +docker stop --time 5 "$cid" >/dev/null diff --git a/store.go b/store.go new file mode 100644 index 00000000..d11b834c --- /dev/null +++ b/store.go @@ -0,0 +1,372 @@ +package main + +import ( + "bytes" + "context" + "errors" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` +} + +var ( + errConflict = errors.New("conflict") + errNotFound = errors.New("not found") + errInvalidMembers = errors.New("invalid members") +) + +// Store — единственный источник истины: PostgreSQL. Все запросы параметризованы ($1, $2, …), +// строки SQL не собираются из пользовательских данных. +type Store struct{ pool *pgxpool.Pool } + +func newPool(ctx context.Context, url string, maxConns int32) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(url) + if err != nil { + return nil, errors.New("invalid database URL") + } + cfg.MaxConns = maxConns + cfg.MaxConnLifetime = 30 * time.Minute + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.HealthCheckPeriod = 15 * time.Second + cfg.ConnConfig.ConnectTimeout = 3 * time.Second + if cfg.ConnConfig.RuntimeParams == nil { + cfg.ConnConfig.RuntimeParams = map[string]string{} + } + cfg.ConnConfig.RuntimeParams["timezone"] = "UTC" + cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000" + cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000" + cfg.ConnConfig.RuntimeParams["application_name"] = "messenger-api" + // Соединения создаются лениво: API стартует и при недоступной БД (тогда /health/ready даёт 503). + return pgxpool.NewWithConfig(ctx, cfg) +} + +// dbFail переводит ошибку БД в ограниченный ответ: ни SQL, ни адреса, ни текста драйвера клиенту не уходят. +func dbFail(err error) *apiError { + var pg *pgconn.PgError + if errors.As(err, &pg) { + // 08 — соединение, 53 — ресурсы, 57 — остановка/отмена, 40 — откат по конкуренции. + switch pg.Code[:2] { + case "08", "53", "57", "40": + return unavailable() + } + return fail(500, "internal_error", "Внутренняя ошибка") + } + // не PgError: обрыв соединения, таймаут, пул исчерпан, БД недоступна + return unavailable() +} + +func isPgCode(err error, code string) bool { + var pg *pgconn.PgError + return errors.As(err, &pg) && pg.Code == code +} + +// ---- пользователи ---- + +func (s *Store) createUser(ctx context.Context, u User, passwordHash string) (User, error) { + var created time.Time + err := s.pool.QueryRow(ctx, + `INSERT INTO users (id, username, display_name, password_hash) VALUES ($1::uuid, $2, $3, $4) RETURNING created_at`, + u.ID, u.Username, u.DisplayName, passwordHash).Scan(&created) + if err != nil { + if isPgCode(err, "23505") { // unique_violation: username занят, в том числе при гонке + return User{}, errConflict + } + return User{}, err + } + u.CreatedAt = formatTime(created) + return u, nil +} + +func (s *Store) userWithHash(ctx context.Context, username string) (User, string, error) { + var u User + var hash string + var created time.Time + err := s.pool.QueryRow(ctx, + `SELECT id::text, username, display_name, created_at, password_hash FROM users WHERE username = $1`, + username).Scan(&u.ID, &u.Username, &u.DisplayName, &created, &hash) + if errors.Is(err, pgx.ErrNoRows) { + return User{}, "", errNotFound + } + if err != nil { + return User{}, "", err + } + u.CreatedAt = formatTime(created) + return u, hash, nil +} + +// ---- сессии ---- + +func (s *Store) createSession(ctx context.Context, tokenHash []byte, userID string, ttlSecs int) (time.Time, error) { + // Оппортунистическая чистка давно истёкших строк; индекс по expires_at делает её дешёвой. + _, _ = s.pool.Exec(ctx, `DELETE FROM sessions WHERE expires_at < now() - interval '1 day'`) + var expires time.Time + err := s.pool.QueryRow(ctx, + `INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2::uuid, now() + make_interval(secs => $3::float8)) RETURNING expires_at`, + tokenHash, userID, float64(ttlSecs)).Scan(&expires) + return expires, err +} + +// sessionUser возвращает владельца действующей (не истёкшей и не отозванной) сессии. +// Срок проверяется по часам PostgreSQL, поэтому он не зависит от рестарта API. +func (s *Store) sessionUser(ctx context.Context, tokenHash []byte) (User, error) { + var u User + var created time.Time + err := s.pool.QueryRow(ctx, + `SELECT u.id::text, u.username, u.display_name, u.created_at + FROM sessions s JOIN users u ON u.id = s.user_id + WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`, + tokenHash).Scan(&u.ID, &u.Username, &u.DisplayName, &created) + if errors.Is(err, pgx.ErrNoRows) { + return User{}, errNotFound + } + if err != nil { + return User{}, err + } + u.CreatedAt = formatTime(created) + return u, nil +} + +func (s *Store) revokeSession(ctx context.Context, tokenHash []byte) error { + _, err := s.pool.Exec(ctx, + `UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`, tokenHash) + return err +} + +// ---- чаты ---- + +// createChat — составная операция: чат и ВСЕ участники появляются в одной транзакции. +// Любая ошибка (например, несуществующий участник → FK) откатывает всё: «половинчатых» чатов не бывает. +func (s *Store) createChat(ctx context.Context, c Chat, creatorID string) (Chat, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return Chat{}, err + } + defer func() { _ = tx.Rollback(context.Background()) }() // no-op после Commit + + var created time.Time + if err := tx.QueryRow(ctx, + `INSERT INTO chats (id, title, created_by) VALUES ($1::uuid, $2, $3::uuid) RETURNING created_at`, + c.ID, c.Title, creatorID).Scan(&created); err != nil { + return Chat{}, err + } + if _, err := tx.Exec(ctx, + `INSERT INTO chat_members (chat_id, user_id) SELECT $1::uuid, m::uuid FROM unnest($2::text[]) AS m`, + c.ID, c.MemberIDs); err != nil { + if isPgCode(err, "23503") { // foreign_key_violation: неизвестный участник + return Chat{}, errInvalidMembers + } + return Chat{}, err + } + if err := tx.Commit(ctx); err != nil { + return Chat{}, err + } + c.CreatedAt = formatTime(created) + return c, nil +} + +const chatColumns = `c.id::text, c.title, c.created_at, + ARRAY(SELECT m2.user_id::text FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id)` + +func scanChat(row pgx.Row) (Chat, time.Time, error) { + var c Chat + var created time.Time + if err := row.Scan(&c.ID, &c.Title, &created, &c.MemberIDs); err != nil { + return Chat{}, time.Time{}, err + } + c.CreatedAt = formatTime(created) + return c, created, nil +} + +func (s *Store) getChat(ctx context.Context, actorID, chatID string) (Chat, error) { + c, _, err := scanChat(s.pool.QueryRow(ctx, + `SELECT `+chatColumns+` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid WHERE c.id = $2::uuid`, + actorID, chatID)) + if errors.Is(err, pgx.ErrNoRows) { + return Chat{}, errNotFound + } + return c, err +} + +func (s *Store) isMember(ctx context.Context, actorID, chatID string) (bool, error) { + var ok bool + err := s.pool.QueryRow(ctx, + `SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid)`, + chatID, actorID).Scan(&ok) + return ok, err +} + +// listChats: keyset-пагинация по (created_at, id); запрашивается limit+1 строк, чтобы точно знать, есть ли следующая. +func (s *Store) listChats(ctx context.Context, actorID string, limit int, after *time.Time, afterID string) ([]Chat, string, error) { + sql := `SELECT ` + chatColumns + ` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid` + args := []any{actorID} + if after != nil { + sql += ` WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid)` + args = append(args, *after, afterID) + } + sql += ` ORDER BY c.created_at, c.id LIMIT ` + placeholder(len(args)+1) + args = append(args, limit+1) + rows, err := s.pool.Query(ctx, sql, args...) + if err != nil { + return nil, "", err + } + defer rows.Close() + items := []Chat{} + var lastTime time.Time + for rows.Next() { + c, created, err := scanChat(rows) + if err != nil { + return nil, "", err + } + if len(items) == limit { // лишняя строка: следующая страница существует + return items, encodeCursor("chats", actorID, lastTime, items[len(items)-1].ID), rows.Err() + } + items = append(items, c) + lastTime = created + } + return items, "", rows.Err() +} + +func placeholder(n int) string { return "$" + itoa(n) } + +// ---- сообщения ---- + +func (s *Store) createMessage(ctx context.Context, m Message) (Message, error) { + var created time.Time + err := s.pool.QueryRow(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1::uuid, $2::uuid, $3::uuid, $4) RETURNING created_at`, + m.ID, m.ChatID, m.SenderID, m.Text).Scan(&created) + if err != nil { + return Message{}, err + } + m.CreatedAt = formatTime(created) + return m, nil +} + +// createMessageIdempotent: ключ и сообщение — одна транзакция. Возвращает (сообщение, replayed, ошибка). +// errConflict — тот же ключ с другим телом. Дубль невозможен: PRIMARY KEY ключа сериализует +// конкурентные повторы (в том числе с разных реплик), проигравший ждёт коммита победителя. +func (s *Store) createMessageIdempotent(ctx context.Context, m Message, key, path string, reqHash []byte) (Message, bool, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return Message{}, false, err + } + defer func() { _ = tx.Rollback(context.Background()) }() + + // Ключ старше 24 часов считается свободным. + if _, err := tx.Exec(ctx, + `DELETE FROM idempotency_keys WHERE user_id = $1::uuid AND method = 'POST' AND path = $2 AND key = $3 + AND created_at < now() - interval '24 hours'`, m.SenderID, path, key); err != nil { + return Message{}, false, err + } + tag, err := tx.Exec(ctx, + `INSERT INTO idempotency_keys (user_id, method, path, key, request_hash) VALUES ($1::uuid, 'POST', $2, $3, $4) + ON CONFLICT DO NOTHING`, m.SenderID, path, key, reqHash) + if err != nil { + return Message{}, false, err + } + if tag.RowsAffected() == 0 { + // Ключ уже занят закоммиченной записью: отдаём сохранённый результат или 409. + var stored []byte + var created time.Time + var prev Message + err := tx.QueryRow(ctx, + `SELECT k.request_hash, m.id::text, m.chat_id::text, m.sender_id::text, 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.method = 'POST' AND k.path = $2 AND k.key = $3`, + m.SenderID, path, key).Scan(&stored, &prev.ID, &prev.ChatID, &prev.SenderID, &prev.Text, &created) + if err != nil { + return Message{}, false, err + } + if !bytes.Equal(stored, reqHash) { + return Message{}, false, errConflict + } + prev.CreatedAt = formatTime(created) + return prev, true, nil + } + var created time.Time + if err := tx.QueryRow(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1::uuid, $2::uuid, $3::uuid, $4) RETURNING created_at`, + m.ID, m.ChatID, m.SenderID, m.Text).Scan(&created); err != nil { + return Message{}, false, err + } + if _, err := tx.Exec(ctx, + `UPDATE idempotency_keys SET message_id = $4::uuid WHERE user_id = $1::uuid AND method = 'POST' AND path = $2 AND key = $3`, + m.SenderID, path, key, m.ID); err != nil { + return Message{}, false, err + } + if err := tx.Commit(ctx); err != nil { + return Message{}, false, err + } + m.CreatedAt = formatTime(created) + return m, false, nil +} + +func (s *Store) listMessages(ctx context.Context, chatID string, limit int, after *time.Time, afterID string) ([]Message, string, error) { + sql := `SELECT id::text, chat_id::text, sender_id::text, text, created_at FROM messages WHERE chat_id = $1::uuid` + args := []any{chatID} + if after != nil { + sql += ` AND (created_at, id) > ($2::timestamptz, $3::uuid)` + args = append(args, *after, afterID) + } + sql += ` ORDER BY created_at, id LIMIT ` + placeholder(len(args)+1) + args = append(args, limit+1) + rows, err := s.pool.Query(ctx, sql, args...) + if err != nil { + return nil, "", err + } + defer rows.Close() + items := []Message{} + var lastTime time.Time + for rows.Next() { + var m Message + var created time.Time + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &created); err != nil { + return nil, "", err + } + if len(items) == limit { + return items, encodeCursor("messages", chatID, lastTime, items[len(items)-1].ID), rows.Err() + } + m.CreatedAt = formatTime(created) + items = append(items, m) + lastTime = created + } + return items, "", rows.Err() +} + +// ready: БД отвечает и схема доведена до последней миграции. +func (s *Store) ready(ctx context.Context) error { + versions := migrationVersions() + var n int + if err := s.pool.QueryRow(ctx, + `SELECT count(*) FROM schema_migrations WHERE version = ANY($1::text[])`, versions).Scan(&n); err != nil { + return err + } + if n != len(versions) { + return errors.New("schema is not up to date") + } + return nil +} -- 2.54.0