From 1493ecd99097b46b1c69def8d00c5ba599e642ff Mon Sep 17 00:00:00 2001 From: Ilia Sokolov Date: Sat, 31 Oct 2026 18:30:23 +0300 Subject: [PATCH] Implement lab4 S3 attachments and resilience --- .env.example | 8 + Dockerfile | 26 ++ Makefile | 19 +- REPORT.md | 128 +++++-- app_test.go | 307 ++++++++++++++++ auth.go | 110 ++++++ compose.yaml | 169 +++++++++ config.go | 109 ++++++ go.mod | 29 ++ go.sum | 93 +++++ handlers.go | 619 +++++++++++++++++++++++++++++++++ httpx.go | 204 +++++++++++ infra/nginx/default.conf | 39 +++ main.go | 130 +++++++ migrate.go | 122 +++++++ migrations/001_init.sql | 45 +++ migrations/002_sessions.sql | 15 + migrations/003_idempotency.sql | 19 + migrations/004_attachments.sql | 35 ++ s3.go | 99 ++++++ scripts/init-secrets.ps1 | 30 ++ scripts/init-secrets.sh | 28 ++ 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 | 466 +++++++++++++++++++++++++ 29 files changed, 2906 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 migrations/004_attachments.sql create mode 100644 s3.go 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 d99d26a2..8e801c66 100644 --- a/.env.example +++ b/.env.example @@ -18,3 +18,11 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 + +# --- добавлено в 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 9ad2b84f..e9579965 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,117 @@ -# Отчёт — лабораторная 4 +# Отчёт — лабораторная работа № 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Дисциплина:** Высоконагруженные системы +- **Тема:** S3-хранилище и вложения +- **Факультет:** ИТ +- **Группа:** БВТ2302 +- **Студент:** Соколов Илья Сергеевич +- **Целевая оценка:** 3 +- **Дата локальных испытаний:** 31.10.2026 +- **Commit / PR:** заполнить после публикации в Gitea. -## Запуск из чистого clone +## Цель -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Расширить возможности лабораторной работы № 3: хранить метаданные прикреплённых изображений в PostgreSQL, а бинарное содержимое — в приватном S3-совместимом хранилище. Обеспечить авторизованные загрузку и скачивание оригиналов, доступность вложений через разные реплики API и сохранность данных после перезапуска стенда. -## Архитектура и решения +## Состав стенда и архитектура -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → **Nginx** (единственный опубликованный HTTP-порт) → **две реплики API на Go** → **PostgreSQL** (чаты, сессии, ключи идемпотентности, метаданные вложений) + **S3** (оригинальные байты изображений). -## Доказательства критериев +| Компонент | Реализация | Назначение | +| --- | --- | --- | +| Балансировщик | `nginx:1.27.5-alpine` | Приём клиентских запросов и балансировка между API | +| API | Go 1.23.8, два контейнера | REST API, проверка доступа, загрузка/скачивание | +| База данных | `postgres:16.9-bookworm` | Метаданные, сессии, сообщения и идемпотентность; volume `pgdata` | +| Объектное хранилище | `docker.io/pgsty/silo:RELEASE.2026-10-26T00-00-00Z` | S3-совместимое хранение файлов; volume `s3data` | +| Миграции | Одноразовый контейнер `migrate` | Миграции БД (включая `004_attachments.sql`), создание приватного bucket | -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +**Изменение по сравнению с исходным шаблоном:** исходный образ `minio/minio:RELEASE.2025-04-22T22-12-26Z` не удалось скачать в данном окружении из Docker Hub; альтернативные попытки через `quay.io/minio/minio` (401) и `cgr.dev/chainguard/minio` (403) также не сработали. Для локально проверенного стенда установлен S3-совместимый образ Silo с закреплённым тегом. В `compose.yaml` для него указаны `command: ["server", "/data"]`, `MINIO_ROOT_USER_FILE` и `MINIO_ROOT_PASSWORD_FILE` с путями к Docker secrets. Проверка S3 API выполнялась на этом образе; полная эквивалентность реализаций не заявляется. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +**Использованный тег образа:** `RELEASE.2026-10-26T00-00-00Z`; при локальном скачивании Docker показал digest `sha256:7bb2aff6b89efe1cb1303c10fc21d579447434ed06649ac9ec05a5e2dbf30ad7`. -## Эксперименты и отказы +## Воспроизводимый запуск (Windows PowerShell) -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Из корня репозитория, при запущенном Docker Desktop: -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +```powershell +powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1 +``` -## Ограничения и следующие шаги +Скрипт создаёт локальные `.env` и `secrets/` (не включать в Git). Для локального запуска, когда порт `8080` уже занят лабораторной № 3, установить в `.env`: -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +```dotenv +PUBLISHED_PORT=18081 +``` + +Далее: + +```powershell +docker compose config --quiet +docker compose up -d --build +docker compose ps +curl.exe http://localhost:18081/health/ready +python -X utf8 scripts\check_contract.py +python -X utf8 tests\smoke.py --base-url http://localhost:18081 +``` + +На свободном порту `8080` можно оставить значение по умолчанию, заменив `18081` на `8080` в командах проверки. UTF-8 включён опцией `-X utf8`, чтобы избежать ошибки декодирования `lab.json` в Windows. + +Инициализация bucket выполняется через `migrate`, а PostgreSQL и S3 хранят данные в отдельных persistent volumes. `docker compose down` не удаляет volumes; `docker compose down -v` удаляет данные и не применяется для проверки сохранности. + +## Реализованная функциональность + +- Авторизованная загрузка PNG/JPEG до 10 MiB; проверка MIME по содержимому, ограничение размеров изображения до 40 млн пикселей и валидация filename. +- Хранение оригинала в приватном S3 bucket; назначаемый сервером `object_key` не основан на имени файла. +- Метаданные вложения и связь сообщения с вложениями хранятся в PostgreSQL, а оригинальные байты — в S3. +- Скачивание оригинала через API с проверкой принадлежности к чату. Постороннему пользователю доступ запрещён. +- Сохранение возможностей предыдущих лабораторных: общие сессии, идемпотентность, две API-реплики, балансировка, миграции и healthcheck. +- При недоступном S3 загрузка возвращает `503`, но обычные текстовые сообщения продолжают работать. + +## Фактически выполненные проверки + +| Проверка | Команда или сценарий | Наблюдаемый результат | +| --- | --- | --- | +| Проверка структуры | `python -X utf8 scripts\check_contract.py` | `PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.` | +| Публичный smoke | `python -X utf8 tests\smoke.py --base-url http://localhost:18081` | `PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.` | +| Persistence | `python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:18081` | `PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.` | +| Failover, первый успешный запуск | `python -X utf8 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://localhost:18081` | PASS; 2 реплики до отказа; 8 успешных записей, 0 неудачных попыток, восстановление 4,157 с; остановлена `mtusi-lab4-api-2` | +| Failover, повторный успешный запуск | Та же команда после `docker compose up -d` | PASS; 2 реплики до отказа; 8 успешных записей, 0 неудачных попыток, восстановление 4,156 с; вновь остановлена `mtusi-lab4-api-2` | +| Недоступность S3 | `docker compose stop s3`, авторизованная попытка загрузки и текстовое сообщение | `PASS: S3 unavailable -> HTTP 503`; `PASS: text messages work without S3` | +| Восстановление S3 | `docker compose start s3` и `docker compose up -d` | S3 запущен, обе реплики API, PostgreSQL и Nginx имеют статус `healthy` в последней проверке | + +Для persistence скрипт `scripts/restart.cmd` был изменён так, чтобы вместе с PostgreSQL, API и Nginx остановить и запустить S3 с сохранением volumes. Сам успешный ответ теста не является доказательством фактического перезапуска всех контейнеров: для защиты требуется приложить журналы/состояние контейнеров до и после действия. + +**Ограничение доказательств:** оба успешных запуска `failover` остановили **одну и ту же реплику** `api-2`. Независимая демонстрация отказа `api-1` не выполнена; её нельзя считать подтверждённой. Один промежуточный запуск был прерван вручную (`KeyboardInterrupt`) и не учитывается как успешный. + +## Результаты экспериментов + +### Отказ API-реплики + +Перед отказом наблюдалось две API-реплики. Скрипт остановил обслуживавшую запрос реплику `api-2`. Через работающую реплику продолжилась обработка сообщений; подтверждённые данные и сессия сохранились. Отмечено 8 успешных записей и 0 неудачных попыток, первый успешный ответ после переключения — через 4,157 с (первый опыт) и 4,156 с (повторный опыт). После каждого теста выполнено `docker compose up -d`; обе реплики вернулись в статус `healthy`. + +### Перезапуск компонентов + +Скрипт перезапуска сохранял Docker volumes. После перезапуска автоматический тест подтвердил сохранение ранее подтверждённых данных и существующей сессии; в профиле lab4 тест также проверяет доступ к ранее загруженному оригиналу. Вывод теста — PASS. Требуются отдельные операторские доказательства фактического перезапуска компонентов. + +### Отключение объектного хранилища + +При остановленном `s3` авторизованная попытка загрузки PNG вернула HTTP 503, тогда как отправка текстового сообщения прошла успешно. После проверки сервис `s3` восстановлен. Этот сценарий показывает частичную доступность текстового API при отказе хранилища вложений; он не доказывает высокой доступности самого S3. + +## Дополнительные подтверждения перед сдачей + +- Сохранить небольшие обезличенные файлы результатов в `evidence/` и показать вывод `docker compose ps` / остановленную реплику после failover. Не включать токены, `.env`, пароли и полный дамп БД. +- При необходимости отдельно остановить `api-1` и подтвердить, что `api-2` продолжает обслуживать запросы. Обе проверки `failover` выше останавливали `api-2`. +- Выполнить `make check` и `make test` (или документированные равнозначные команды Python), а также `go test ./...` — если эти команды ещё не выполнялись, не отмечать их как пройденные. +- Добавить ссылку на Pull Request и хеш коммита после публикации. + +## Ограничения решения + +- PostgreSQL, один экземпляр S3 и Nginx остаются едиными точками отказа; их резервирование не заявлено. +- Содержимое изображения проверяется по заголовкам и параметрам формата, без гарантии полного декодирования всего файла. +- Загрузка до 10 MiB буферизуется в памяти API; при падении между записью объекта в S3 и фиксацией метаданных может остаться осиротевший объект. +- Применяется S3-совместимый Silo вместо исходного MinIO; соответствие отдельных нестандартных функций MinIO дополнительно не проверялось. +- Thumbnail и обработка изображений относятся к следующей лабораторной. + +## Использованные технологии и источники + +Go, PostgreSQL, `pgx`, `minio-go/v7`, Nginx, Docker Compose, S3-совместимое объектное хранилище Silo. Основа реализации перенесена из лабораторной № 3 и доработана для лабораторной № 4. При разработке реализации использовался Claude Code (как указано в исходном отчёте), а при подготовке проверок и оформлении данного отчёта — ChatGPT. Публичные контракт и тесты преподавателя не должны изменяться при отправке решения. 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..950dba8d --- /dev/null +++ b/compose.yaml @@ -0,0 +1,169 @@ +# Лабораторная 4: Клиент → nginx (LB) → API × N → PostgreSQL (метаданные, сессии, ключи) + MinIO (байты вложений). +# Запуск: sh scripts/init-secrets.sh (или .ps1) && docker compose up -d --build +# Секреты лежат в ./secrets (создаются scripts/init-secrets.*, в Git не попадают). +name: mtusi-lab4 + +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 } + + # S3-совместимое хранилище (MinIO, версия закреплена). Порты наружу НЕ публикуются: доступ только из сети backend. + # Bucket приватный (анонимный доступ в MinIO выключен по умолчанию); создаёт его команда `migrate` (см. ниже). + s3: + image: docker.io/pgsty/silo:RELEASE.2026-10-26T00-00-00Z + restart: unless-stopped + command: ["server", "/data"] + environment: + MINIO_ROOT_USER_FILE: /run/secrets/s3_access_key_id + MINIO_ROOT_PASSWORD_FILE: /run/secrets/s3_secret_access_key + secrets: + - s3_access_key_id + - s3_secret_access_key + volumes: + - s3data:/data + networks: + - backend + stop_grace_period: 30s + deploy: + resources: + limits: { cpus: "1.0", memory: 512m } + + # Одноразовая задача: ровно ОДИН процесс применяет миграции (под advisory lock) и завершается. + # Затем идемпотентно создаёт приватный bucket (ждёт готовности S3 до 60 с). + # Реплики API стартуют только после её успешного завершения и сами миграции не запускают. + migrate: + build: . + image: mtusi-messenger:lab4 + command: ["migrate"] + restart: "no" + environment: + DATABASE_URL_FILE: /run/secrets/database_url + S3_ENDPOINT: http://s3:9000 + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key + secrets: + - database_url + - s3_access_key_id + - s3_secret_access_key + depends_on: + postgres: + condition: service_healthy + s3: + condition: service_started + networks: + - backend + + # Взаимозаменяемые реплики. Без container_name и без published ports: наружу — только через LB. + # Локального состояния нет: сессии, ключи идемпотентности и данные — в PostgreSQL. + api: + build: . + image: mtusi-messenger:lab4 + 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} + S3_ENDPOINT: http://s3:9000 + S3_REGION: us-east-1 + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key + MAX_UPLOAD_BYTES: "10485760" + MAX_IMAGE_PIXELS: "40000000" + secrets: + - database_url + - s3_access_key_id + - s3_secret_access_key + 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: 384m } + + # Единственная публичная точка входа. Адреса 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: + s3data: {} # байты вложений; переживает stop/restart/up + pgdata: {} # переживает stop/start/restart/up; удаляется только `docker compose down -v` + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + s3_access_key_id: + file: ./secrets/s3_access_key_id + s3_secret_access_key: + file: ./secrets/s3_secret_access_key diff --git a/config.go b/config.go new file mode 100644 index 00000000..d09c3da7 --- /dev/null +++ b/config.go @@ -0,0 +1,109 @@ +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 + S3Endpoint string + S3Region string + S3Bucket string + S3AccessKey string + S3SecretKey string + MaxUploadBytes int + MaxImagePixels int +} + +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 cfg.MaxUploadBytes, err = envInt("MAX_UPLOAD_BYTES", 10485760, 1, 10485760); err != nil { + return cfg, err + } + if cfg.MaxImagePixels, err = envInt("MAX_IMAGE_PIXELS", 40000000, 1, 40000000); err != nil { + return cfg, err + } + cfg.S3Endpoint = envOr("S3_ENDPOINT", "http://s3:9000") + cfg.S3Region = envOr("S3_REGION", "us-east-1") + cfg.S3Bucket = envOr("S3_BUCKET", "messenger-attachments") + if cfg.S3AccessKey, err = readSecretFile(os.Getenv("S3_ACCESS_KEY_ID_FILE")); err != nil { + return cfg, fmt.Errorf("cannot read S3_ACCESS_KEY_ID_FILE: %w", err) + } + if cfg.S3SecretKey, err = readSecretFile(os.Getenv("S3_SECRET_ACCESS_KEY_FILE")); err != nil { + return cfg, fmt.Errorf("cannot read S3_SECRET_ACCESS_KEY_FILE: %w", err) + } + 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..2f807e9d --- /dev/null +++ b/go.mod @@ -0,0 +1,29 @@ +module mtusi-messenger + +go 1.23 + +require ( + github.com/alexedwards/argon2id v1.0.0 + github.com/jackc/pgx/v5 v5.7.2 + github.com/minio/minio-go/v7 v7.0.87 +) + +require ( + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-ini/ini v1.67.0 // indirect + github.com/goccy/go-json v0.10.5 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/klauspost/compress v1.17.11 // indirect + github.com/klauspost/cpuid/v2 v2.2.9 // indirect + github.com/minio/crc64nvme v1.0.1 // indirect + github.com/minio/md5-simd v1.1.2 // indirect + github.com/rs/xid v1.6.0 // indirect + golang.org/x/crypto v0.33.0 // indirect + golang.org/x/net v0.35.0 // indirect + golang.org/x/sync v0.11.0 // indirect + golang.org/x/sys v0.30.0 // indirect + golang.org/x/text v0.22.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..bd691317 --- /dev/null +++ b/go.sum @@ -0,0 +1,93 @@ +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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= +github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.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/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= +github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY= +github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8= +github.com/minio/crc64nvme v1.0.1 h1:DHQPrYPdqK7jQG/Ls5CTBZWeex/2FMS3G5XGkycuFrY= +github.com/minio/crc64nvme v1.0.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.87 h1:nkr9x0u53PespfxfUqxP3UYWiE2a41gaofgNnC4Y8WQ= +github.com/minio/minio-go/v7 v7.0.87/go.mod h1:33+O8h0tO7pCeCWwBVa07RhVVfB/3vS4kEX7rwYKmIg= +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/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= +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.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +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.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus= +golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= +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/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8= +golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk= +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.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w= +golang.org/x/sync v0.11.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.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= +golang.org/x/sys v0.30.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.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= +golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= +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..f4f4b379 --- /dev/null +++ b/handlers.go @@ -0,0 +1,619 @@ +package main + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "log" + "mime" + "net/http" + "runtime/debug" + "sort" + "strconv" + "strings" + "sync/atomic" + "time" + "unicode" + "unicode/utf8" +) + +type API struct { + store *Store + hasher *Hasher + ttlSecs int + reqLimit time.Duration + blobs *BlobStore + maxUpload int + maxPixels int + // 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). Отправитель берётся только из сессии. + for name := range body { + if name != "text" && name != "attachment_ids" { + return 0, nil, invalid("Неожиданные поля") + } + } + attachmentIDs := []string{} + if raw, present := body["attachment_ids"]; present { + list, ok := raw.([]any) + if !ok || len(list) > 10 { + return 0, nil, invalid("Некорректные attachment_ids") + } + seen := map[string]bool{} + for _, item := range list { + str, typeOK := item.(string) + id, idOK := validUUID(str) + if !typeOK || !idOK || seen[id] { + return 0, nil, invalid("Некорректные attachment_ids") + } + seen[id] = true + attachmentIDs = append(attachmentIDs, id) + } + } + var text string + if rawText, ok := body["text"].(string); !ok { + return 0, nil, invalid("Некорректное поле text") + } else if len(attachmentIDs) > 0 && rawText == "" { + text = "" // сообщение только из вложений + } else { + var terr *apiError + if text, terr = requiredString(rawText, 4000, "text"); terr != nil { + return 0, nil, terr + } + } + // Канонический вид тела: порядок ключей JSON и отсутствие attachment_ids == [] неразличимы. + hasher := sha256.New() + hasher.Write([]byte(text)) + for _, id := range attachmentIDs { + hasher.Write([]byte{0}) + hasher.Write([]byte(id)) + } + sum := hasher.Sum(nil) + path := "/api/v1/chats/" + chatID + "/messages" + message, _, serr := a.store.createMessageIdempotent(r.Context(), + Message{ID: newUUID(), ChatID: chatID, SenderID: actor.ID, Text: text, AttachmentIDs: attachmentIDs}, key, path, sum) + if errors.Is(serr, errNotFound) { + return 0, nil, notFound() + } + 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 +} + +// ---- вложения ---- + +// binaryBody — ответ с байтами (не JSON); пишется в ServeHTTP. +type binaryBody struct { + contentType string + size int64 + body io.ReadCloser +} + +// detectImage определяет формат по СОДЕРЖИМОМУ (заголовок Content-Type клиента лишь сверяется) и читает размеры +// без декодирования пикселей: лимит 40 млн px применяется до любой тяжёлой обработки. +func detectImage(data []byte) (mime string, pixels int64, ok bool) { + cfg, format, err := image.DecodeConfig(bytes.NewReader(data)) + if err != nil || cfg.Width < 1 || cfg.Height < 1 { + return "", 0, false + } + switch format { + case "png": + mime = "image/png" + case "jpeg": + mime = "image/jpeg" + default: + return "", 0, false + } + return mime, int64(cfg.Width) * int64(cfg.Height), true +} + +func validFilename(name string) bool { + n := utf8.RuneCountInString(name) + if !utf8.ValidString(name) || n < 1 || n > 255 || strings.TrimSpace(name) == "" { + return false + } + for _, c := range name { + if c == '/' || c == '\\' || c == 0 || unicode.IsControl(c) { + return false + } + } + return true +} + +func (a *API) uploadAttachment(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 + } + query := r.URL.Query() + names := query["filename"] + if len(names) != 1 || !validFilename(names[0]) { + return 0, nil, invalid("Некорректный filename") + } + mediaType, _, merr := mime.ParseMediaType(r.Header.Get("Content-Type")) + if merr != nil || (mediaType != "image/png" && mediaType != "image/jpeg") { + return 0, nil, fail(http.StatusUnsupportedMediaType, "unsupported_media_type", "Нужен image/png или image/jpeg") + } + tooLarge := fail(http.StatusRequestEntityTooLarge, "payload_too_large", "Файл больше лимита") + if r.ContentLength > int64(a.maxUpload) { + return 0, nil, tooLarge + } + // Лимит применяется до чтения: больше maxUpload+1 байт из сокета не берётся. + data, rerr := io.ReadAll(io.LimitReader(r.Body, int64(a.maxUpload)+1)) + if rerr != nil { + return 0, nil, invalid("Не удалось прочитать тело запроса") + } + if len(data) > a.maxUpload { + return 0, nil, tooLarge + } + if len(data) == 0 { + return 0, nil, invalid("Пустое тело") + } + detected, pixels, ok := detectImage(data) + if !ok || detected != mediaType { + return 0, nil, fail(http.StatusUnsupportedMediaType, "unsupported_media_type", "Содержимое не является корректным PNG/JPEG") + } + if pixels > int64(a.maxPixels) { + return 0, nil, tooLarge + } + sum := sha256.Sum256(data) + id := newUUID() + att := Attachment{ + ID: id, ChatID: chatID, OwnerID: actor.ID, Filename: names[0], ContentType: detected, + SizeBytes: int64(len(data)), SHA256: hex.EncodeToString(sum[:]), + objectKey: "attachments/" + chatID + "/" + id, // ключ назначает сервер, filename в нём не участвует + } + // Порядок: сначала байты в S3, затем метаданные. 201 — только после обоих; при сбое БД объект удаляется. + if perr := a.blobs.put(r.Context(), att.objectKey, data, detected); perr != nil { + log.Printf("s3 put failed") + return 0, nil, unavailable() + } + created, serr := a.store.createAttachment(r.Context(), att) + if serr != nil { + a.blobs.remove(context.Background(), att.objectKey) + return 0, nil, dbFail(serr) + } + return http.StatusCreated, created, nil +} + +func (a *API) getAttachment(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("Некорректный идентификатор") + } + att, serr := a.store.getAttachment(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, att, nil +} + +func (a *API) downloadAttachment(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("Некорректный идентификатор") + } + if v := r.URL.Query()["variant"]; len(v) > 1 || (len(v) == 1 && v[0] != "original") { + return 0, nil, invalid("Некорректный variant") + } + att, serr := a.store.getAttachment(r.Context(), actor.ID, id) + if errors.Is(serr, errNotFound) { + return 0, nil, notFound() + } + if serr != nil { + return 0, nil, dbFail(serr) + } + body, gerr := a.blobs.get(r.Context(), att.objectKey) + if gerr != nil { + log.Printf("s3 get failed") + return 0, nil, unavailable() + } + return http.StatusOK, &binaryBody{contentType: att.ContentType, size: att.SizeBytes, body: body}, 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 r.Method == http.MethodPost && len(parts) == 5 && strings.Join(parts[:3], "/") == "api/v1/chats" && parts[4] == "attachments" { + return a.uploadAttachment(r, parts[3]) + } + if r.Method == http.MethodGet && len(parts) == 4 && strings.Join(parts[:3], "/") == "api/v1/attachments" { + return a.getAttachment(r, parts[3]) + } + if r.Method == http.MethodGet && len(parts) == 5 && strings.Join(parts[:3], "/") == "api/v1/attachments" && parts[4] == "content" { + return a.downloadAttachment(r, parts[3]) + } + 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 bin, ok := body.(*binaryBody); ok { + defer bin.body.Close() + w.Header().Set("X-Request-Id", id) + w.Header().Set("Content-Type", bin.contentType) + w.Header().Set("Content-Length", strconv.FormatInt(bin.size, 10)) + w.Header().Set("X-Content-Type-Options", "nosniff") + w.Header().Set("Content-Disposition", "attachment") + w.WriteHeader(status) + _, _ = io.Copy(w, bin.body) + 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..5aab8bca --- /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..6cd07524 --- /dev/null +++ b/infra/nginx/default.conf @@ -0,0 +1,39 @@ +# 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"; + } + + # Вложения до 10 MiB: лимит nginx чуть выше, финальный отказ 413 даёт API. + client_max_body_size 12m; + + 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 30s; + proxy_read_timeout 30s; + 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..2ebc1d8b --- /dev/null +++ b/main.go @@ -0,0 +1,130 @@ +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 + } + // Bootstrap приватного bucket: однократно и идемпотентно, вместе с миграциями. + blobs, err := newBlobStore(cfg) + if err == nil { + err = blobs.ensureBucket(ctx) + } + if err != nil { + log.Printf("s3 bootstrap 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() + } + blobs, err := newBlobStore(cfg) + if err != nil { + log.Printf("s3 setup error: %v", err) + return 1 + } + api := &API{blobs: blobs, maxUpload: cfg.MaxUploadBytes, maxPixels: cfg.MaxImagePixels, store: &Store{pool: pool}, hasher: newHasher(4), ttlSecs: cfg.SessionTTLSecs, reqLimit: 20 * time.Second, instanceID: instance} + server := &http.Server{ + Addr: net.JoinHostPort(cfg.Host, cfg.Port), + Handler: api, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 30 * time.Second, + WriteTimeout: 40 * 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/migrations/004_attachments.sql b/migrations/004_attachments.sql new file mode 100644 index 00000000..1479e204 --- /dev/null +++ b/migrations/004_attachments.sql @@ -0,0 +1,35 @@ +-- Вложения (lab4): метаданные — в PostgreSQL, байты — в приватном S3-bucket. +-- object_key назначает сервер; filename нужен только для отображения. + +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + owner_id uuid NOT NULL REFERENCES users (id), + filename text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + sha256 text NOT NULL, + object_key text NOT NULL, + status text NOT NULL DEFAULT 'ready', + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + updated_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT attachments_object_key_key UNIQUE (object_key), + CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')), + CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760), + CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'), + CONSTRAINT attachments_status CHECK (status = 'ready'), + CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255) +); +CREATE INDEX attachments_chat_idx ON attachments (chat_id); + +-- Одно вложение чата можно прикрепить к нескольким сообщениям; position хранит порядок attachment_ids. +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE CASCADE, + position int NOT NULL, + PRIMARY KEY (message_id, attachment_id) +); + +-- Сообщение может состоять только из вложений: пустой text допустим (правило «текст или вложение» — в API). +ALTER TABLE messages DROP CONSTRAINT messages_text_len; +ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 0 AND 4000); diff --git a/s3.go b/s3.go new file mode 100644 index 00000000..bf04364e --- /dev/null +++ b/s3.go @@ -0,0 +1,99 @@ +package main + +import ( + "bytes" + "context" + "errors" + "fmt" + "io" + "net" + "net/http" + "net/url" + "time" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +// BlobStore — приватное S3-хранилище байтов вложений (MinIO). Ключи объектов назначает сервер. +type BlobStore struct { + client *minio.Client + bucket string +} + +var errBlobMissing = errors.New("blob missing") + +func newBlobStore(cfg Config) (*BlobStore, error) { + u, err := url.Parse(cfg.S3Endpoint) + if err != nil || u.Host == "" { + return nil, errors.New("invalid S3_ENDPOINT") + } + // Короткие таймауты: недоступный S3 быстро превращается в 503, а не в зависший запрос. + transport := &http.Transport{ + DialContext: (&net.Dialer{Timeout: 2 * time.Second}).DialContext, + TLSHandshakeTimeout: 3 * time.Second, + ResponseHeaderTimeout: 8 * time.Second, + MaxIdleConnsPerHost: 10, + IdleConnTimeout: 30 * time.Second, + } + client, err := minio.New(u.Host, &minio.Options{ + Creds: credentials.NewStaticV4(cfg.S3AccessKey, cfg.S3SecretKey, ""), + Secure: u.Scheme == "https", + Region: cfg.S3Region, + Transport: transport, + }) + if err != nil { + return nil, fmt.Errorf("s3 client: %w", err) + } + return &BlobStore{client: client, bucket: cfg.S3Bucket}, nil +} + +// ensureBucket создаёт приватный bucket (анонимный доступ в MinIO по умолчанию запрещён). +// Операция идемпотентна и ждёт готовности S3 до ~60 с: вызывается из одноразовой команды migrate. +func (b *BlobStore) ensureBucket(ctx context.Context) error { + deadline := time.Now().Add(60 * time.Second) + for { + ok, err := b.client.BucketExists(ctx, b.bucket) + if err == nil && !ok { + err = b.client.MakeBucket(ctx, b.bucket, minio.MakeBucketOptions{Region: ""}) + if err != nil { + if resp := minio.ToErrorResponse(err); resp.Code == "BucketAlreadyOwnedByYou" || resp.Code == "BucketAlreadyExists" { + err = nil + } + } + } + if err == nil { + return nil + } + if time.Now().After(deadline) || ctx.Err() != nil { + return fmt.Errorf("s3 bucket init: %w", err) + } + time.Sleep(2 * time.Second) + } +} + +func (b *BlobStore) put(ctx context.Context, key string, data []byte, contentType string) error { + _, err := b.client.PutObject(ctx, b.bucket, key, bytes.NewReader(data), int64(len(data)), + minio.PutObjectOptions{ContentType: contentType}) + return err +} + +func (b *BlobStore) remove(ctx context.Context, key string) { + _ = b.client.RemoveObject(ctx, b.bucket, key, minio.RemoveObjectOptions{}) +} + +// get возвращает поток байт; ошибки S3 (в том числе недоступность) проявляются здесь, до записи заголовков ответа. +func (b *BlobStore) get(ctx context.Context, key string) (io.ReadCloser, error) { + obj, err := b.client.GetObject(ctx, b.bucket, key, minio.GetObjectOptions{}) + if err != nil { + return nil, err + } + if _, err := obj.Stat(); err != nil { + _ = obj.Close() + if minio.ToErrorResponse(err).Code == "NoSuchKey" { + return nil, errBlobMissing + } + return nil, err + } + return obj, nil +} diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 new file mode 100644 index 00000000..704d3a49 --- /dev/null +++ b/scripts/init-secrets.ps1 @@ -0,0 +1,30 @@ +# 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' +} +$akFile = Join-Path (Get-Location) 'secrets/s3_access_key_id' +$skFile = Join-Path (Get-Location) 'secrets/s3_secret_access_key' +function New-Hex($n) { $b = New-Object byte[] $n; [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($b); ($b | ForEach-Object { $_.ToString('x2') }) -join '' } +if (-not (Test-Path $akFile)) { [System.IO.File]::WriteAllText($akFile, ('s3' + (New-Hex 8)), $utf8); Write-Host 'created secrets/s3_access_key_id' } +if (-not (Test-Path $skFile)) { [System.IO.File]::WriteAllText($skFile, (New-Hex 24), $utf8); Write-Host 'created secrets/s3_secret_access_key' } +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..51041af8 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,28 @@ +#!/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 +if [ ! -f secrets/s3_access_key_id ]; then + printf 's3%s' "$(head -c 8 /dev/urandom | od -An -tx1 | tr -d ' \n')" > secrets/s3_access_key_id + echo "created secrets/s3_access_key_id" >&2 +fi +if [ ! -f secrets/s3_secret_access_key ]; then + head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/s3_secret_access_key + echo "created secrets/s3_secret_access_key" >&2 +fi +# Контейнеры работают не от вашего пользователя: файлы должны читаться всеми (каталог в Git не попадает). +chmod 755 secrets +chmod 644 secrets/* +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..82139958 --- /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 s3 >nul 2>&1 +if errorlevel 1 exit /b 1 +docker compose start postgres s3 >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..c091102f --- /dev/null +++ b/store.go @@ -0,0 +1,466 @@ +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"` + // attachment_ids присутствует всегда: [] для текстового сообщения. + AttachmentIDs []string `json:"attachment_ids"` +} + +type Attachment struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + OwnerID string `json:"owner_id"` + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + Status string `json:"status"` + Variants []string `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` + objectKey string +} + +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) { + m.AttachmentIDs = nonNil(m.AttachmentIDs) + tx, err := s.pool.Begin(ctx) + if err != nil { + return Message{}, false, err + } + defer func() { _ = tx.Rollback(context.Background()) }() + + // Все вложения должны принадлежать этому чату; чужое/неизвестное — errNotFound (404). + if len(m.AttachmentIDs) > 0 { + var n int + if err := tx.QueryRow(ctx, + `SELECT count(*) FROM attachments WHERE chat_id = $1::uuid AND id = ANY($2::uuid[])`, + m.ChatID, m.AttachmentIDs).Scan(&n); err != nil { + return Message{}, false, err + } + if n != len(m.AttachmentIDs) { + return Message{}, false, errNotFound + } + } + // Ключ старше 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) + if err := tx.QueryRow(ctx, + `SELECT ARRAY(SELECT attachment_id::text FROM message_attachments WHERE message_id = $1::uuid ORDER BY position)`, + prev.ID).Scan(&prev.AttachmentIDs); err != nil { + return Message{}, false, err + } + prev.AttachmentIDs = nonNil(prev.AttachmentIDs) + 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 len(m.AttachmentIDs) > 0 { + if _, err := tx.Exec(ctx, + `INSERT INTO message_attachments (message_id, attachment_id, position) + SELECT $1::uuid, a::uuid, ord FROM unnest($2::text[]) WITH ORDINALITY AS t(a, ord)`, + m.ID, m.AttachmentIDs); 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 m.id::text, m.chat_id::text, m.sender_id::text, m.text, m.created_at, + ARRAY(SELECT ma.attachment_id::text FROM message_attachments ma WHERE ma.message_id = m.id ORDER BY ma.position) + FROM messages m WHERE m.chat_id = $1::uuid` + args := []any{chatID} + if after != nil { + sql += ` AND (m.created_at, m.id) > ($2::timestamptz, $3::uuid)` + args = append(args, *after, afterID) + } + sql += ` ORDER BY m.created_at, m.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, &m.AttachmentIDs); 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) + m.AttachmentIDs = nonNil(m.AttachmentIDs) + 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 +} + +func nonNil(v []string) []string { + if v == nil { + return []string{} + } + return v +} + +// ---- вложения ---- + +func (s *Store) createAttachment(ctx context.Context, a Attachment) (Attachment, error) { + var created time.Time + err := s.pool.QueryRow(ctx, + `INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8) RETURNING created_at`, + a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, a.objectKey).Scan(&created) + if err != nil { + return Attachment{}, err + } + a.Status, a.Variants = "ready", []string{} + a.CreatedAt = formatTime(created) + a.UpdatedAt = a.CreatedAt + return a, nil +} + +// getAttachment: только участникам чата; чужое и несуществующее неразличимы (errNotFound). +func (s *Store) getAttachment(ctx context.Context, actorID, id string) (Attachment, error) { + var a Attachment + var created, updated time.Time + err := s.pool.QueryRow(ctx, + `SELECT a.id::text, a.chat_id::text, a.owner_id::text, a.filename, a.content_type, a.size_bytes, a.sha256, + a.status, a.created_at, a.updated_at, a.object_key + FROM attachments a JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $1::uuid + WHERE a.id = $2::uuid`, actorID, id). + Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, + &a.Status, &created, &updated, &a.objectKey) + if errors.Is(err, pgx.ErrNoRows) { + return Attachment{}, errNotFound + } + if err != nil { + return Attachment{}, err + } + a.Variants = []string{} + a.CreatedAt, a.UpdatedAt = formatTime(created), formatTime(updated) + return a, nil +} -- 2.54.0