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 +}