diff --git a/.env.example b/.env.example index 714c8076..e8f4c3f0 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,15 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Локальные учебные значения. Скопируйте в .env и не коммитьте .env. +# Пароль ниже — синтетический пароль стенда, не секрет продакшена. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +APP_ACCESS_LOG=1 + +POSTGRES_USER=messenger +POSTGRES_PASSWORD=messenger +POSTGRES_DB=messenger + +# Внутри сети Compose хост базы — postgres, хост Redis — redis. +DATABASE_URL=postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable +REDIS_URL=redis://redis:6379/0 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..dae1065e --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +# syntax=docker/dockerfile:1.7 +FROM golang:1.23.8-bookworm AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY cmd ./cmd +COPY internal ./internal +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server + +FROM gcr.io/distroless/static-debian12:nonroot +COPY --from=build /out/server /server +USER nonroot:nonroot +EXPOSE 8080 +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab \ + SESSION_TTL_SECONDS=3600 +HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \ + CMD ["/server", "-healthcheck"] +ENTRYPOINT ["/server"] diff --git a/Makefile b/Makefile index 9ecb223e..2e08a600 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,9 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +GO ?= go + +.PHONY: help check validate test load test-persistence student-test track2 help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +26,9 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +student-test: + $(GO) test ./student-tests/ -v -count=1 -timeout 180s + +track2: + bash scripts/run_track2.sh diff --git a/REPORT.md b/REPORT.md index e42f2b05..f2d11656 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,93 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Белоусов Анатолий Фахраддинович, БПИ2303 +- Целевая оценка; выбранный трек 5: **5, трек 2** (план запроса и восстановление) +- Commit/PR: ветка `solution/bpi2303-belousov` +- Использованные источники, библиотеки и помощь ИИ: Go `net/http`, `pgx` v5, `go-redis` v9, `golang.org/x/crypto/argon2`, `google/uuid`; публичные `tests/`; Cursor/Composer для реализации и прогонов. Пароли — Argon2id, не bcrypt: bcrypt обрезает пароль на 72 байта, а контракт разрешает до 128 code points. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker, Go 1.23+ (собственные тесты и трек 2), Python 3.9+. + +```sh +cp .env.example .env +docker compose --env-file .env up -d --build +# дождаться {"status":"ok"} на http://127.0.0.1:8080/health/ready +make test +make student-test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +bash scripts/check_deps.sh +bash scripts/run_track2.sh +``` + +Остановка без удаления данных: `docker compose --env-file .env stop`. +Удаление учебных volumes: `docker compose --env-file .env down -v`. + +Образы: сборка `golang:1.23.8-bookworm`, runtime `gcr.io/distroless/static-debian12:nonroot`, PostgreSQL `postgres:16.6`, Redis `redis:7.4.1` с `appendonly yes` и `appendfsync everysec`. + +Соответствие `.env.example`: `DATABASE_URL` и `REDIS_URL` задаются контейнеру явно. `DATABASE_URL_FILE` / `CACHE_URL_FILE` тоже читаются, если прямого URL нет. `SESSION_TTL_SECONDS` по умолчанию 3600. Пароль `messenger` в example — синтетический пароль локального стенда. + +Миграции вшиты в бинарник и применяются при старте. Повторный старт не дублирует строки: версия лежит в `schema_migrations`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → API (один процесс) → PostgreSQL для пользователей, чатов, состава и сообщений. Redis хранит только сессии. + +Пароль проверяется Argon2id (`m=19456,t=2,p=1`). В Redis лежит SHA-256 токена, не сам токен. Токен — 32 случайных байта (256 бит), клиенту отдаётся hex. TTL ключа равен оставшемуся сроку сессии и рестартом API не продлевается. AOF на volume переживает рестарт Redis. `kill -9` процесса Redis может потерять около секунды записей (`appendfsync everysec`) — это граница durability, не «данные вечны». + +`POST /auth/sessions` принимает только Basic. Остальные защищённые методы — только Bearer. `X-User-Id` не читается. Недоступные Postgres или Redis дают 503, а не успех от имени анонима. + +Создание чата — одна транзакция: строка чата и все участники фиксируются вместе. Неизвестный участник откатывает вставку. Гонка одинакового username закрыта `UNIQUE`, а не проверкой «сначала SELECT». + +История читается keyset-запросом `(created_at, id)` по индексу `messages_history_idx (chat_id, created_at, id)`. Кэша истории нет, поэтому успешная запись видна следующему чтению без инвалидации. Пул: до 10 соединений, `statement_timeout=3s`, таймаут подключения 2s. + +Из lab1 перенесены контрактные правила пользователей/чатов/сообщений, opaque cursor, non-root образ, healthcheck и остановка по SIGTERM за ≤10 с. Идентификация заменена с `X-User-Id` на сессию, память процесса больше не хранит данные. ## Доказательства критериев +Стенд прогона: macOS, 8 CPU, 8 GiB RAM, Docker Desktop, лимиты контейнеров не заданы (NanoCpus=0, Memory=0). Дата прогона: 2026-10-14. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke-pass.txt` | +| Сохранность данных и сессии | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence.txt` | +| Повтор миграций, JSON, чужой чат, пустой текст | `make student-test` | `ok student-tests` | `evidence/student-test.txt` | +| Гонка username | 8 параллельных POST одного username | 1×201 и 7×409 | `evidence/student-test.txt` | +| Откат создания чата | неизвестный участник | 400, строк с этим title: 0 | `evidence/student-test.txt` | +| Неверный пароль, logout, X-User-Id, Basic на /users/me | student-test | 401, после logout повторный DELETE тоже 401 | `evidence/student-test.txt` | +| Короткий TTL | `SESSION_TTL=2s`, пауза 2.5 с | 401 | `evidence/student-test.txt` | +| Redis/Postgres недоступны | `scripts/check_deps.sh` и закрытый клиент Redis | `/health/ready` = 503, Bearer не становится 200; после start снова 200 | `evidence/deps-down.txt`, `evidence/student-test.txt` | +| EXPLAIN на большой истории | трек 2, чат 74449 сообщений | см. ниже | `evidence/track2/` | +| Backup и сверка | `pg_dump -Fc` → новая база | 100000 сообщений, checksum совпал | `evidence/track2/restore.json` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +`scripts/restart.sh` перезапускает postgres, redis и api и не вызывает `down -v`. До и после прогона контейнеры — `mtusi2026lab2-api-1`, `mtusi2026lab2-postgres-1`, `mtusi2026lab2-redis-1`. -## Эксперименты и отказы +## Эксперименты и отказы (трек 2) -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза.** Индекс только по `chat_id` заставляет для keyset-страницы в середине большого чата прочитать хвост истории и отсортировать его. Индекс `(chat_id, created_at, id)` отдаёт страницу прямым чтением. Второй индекс почти не меняет стоимость вставки на 5000 строк. + +**Методика.** Отдельная база `track2`, не стенд smoke. 6 чатов размерами 1, 50, 500, 5000, 20000 и 74449 (сумма 100000). Запрос — keyset `LIMIT 50` от сообщения с OFFSET 30000 в самом большом чате. Два плана: `EXPLAIN (ANALYZE, BUFFERS)`. Затем вставка 5000 строк в отдельную таблицу с одним индексом и с двумя. Потом `pg_dump -Fc` и `pg_restore` в новую базу `track2_restore`. Сверка: число чатов и сообщений, SHA-256 потока `(id, created_at, text)` и id первого сообщения большого чата. Повтор: `bash scripts/run_track2.sh`. + +**Чтение.** + +| План | Корневой узел | Что под ним | Execution Time | Shared Hit Blocks | +| --- | --- | --- | --- | --- | +| Только `chat_id` | Limit | Sort → Bitmap Heap Scan 44448 строк | 16.435 ms | 847 | +| `(chat_id, created_at, id)` | Limit | Index Only Scan ровно 50 строк | 0.091 ms | 1 | + +Слабый план прочитал десятки тысяч строк чата. Рабочий план прочитал страницу. В продовой миграции оставлен только составной индекс. + +**Запись.** 5000 строк: 30 ms с индексом `chat_id` и 31 ms с двумя индексами. На этом объёме цена второго индекса теряется в шуме. Утверждать, что индекс «бесплатный навсегда», нельзя: при гораздо большей скорости вставки он начнёт быть виден. + +**Восстановление.** Counts и checksum совпали, 100000 = 100000. Дамп снят после COMMIT загрузки, поэтому сверка не показывает потерю незафиксированных строк. `appendfsync everysec` у Redis к этому дампу не относится: в дампе только PostgreSQL. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `scripts/restart.sh` | те же сообщения и тот же токен | PASS persistence | API дождался Postgres и поднялся в пределах 90 с теста; подтверждённые строки на месте | +| `docker compose stop redis` | `/health/ready` 503, не анонимный 200 | 503, затем 200 | около секунды после start | +| `docker compose stop postgres` | то же для БД | 503, затем 200 | около секунды после start | +| `pg_restore` в новую базу | те же 100000 строк | checksum совпал | дамп консистентен на момент `pg_dump`; незакоммиченное не входило | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один Docker-host не переживает потерю машины. Рестарт Redis с AOF `everysec` может потерять последнюю секунду новых сессий при жёстком убийстве процесса. История сообщений не кэшируется: read-after-write здесь свойство PostgreSQL, а не инвалидации кэша. Разница стоимости записи двух индексов на 5000 строках не доказана. `EXPLAIN ANALYZE` — один прогон на локальном диске Docker, не распределённый бенчмарк. diff --git a/cmd/server/main.go b/cmd/server/main.go new file mode 100644 index 00000000..efe22973 --- /dev/null +++ b/cmd/server/main.go @@ -0,0 +1,158 @@ +// Точка входа HTTP API. +// +// Процесс поднимает пул PostgreSQL, применяет миграции, проверяет Redis и только потом слушает порт. +// SIGTERM переводит /health/ready в 503 и даёт текущим запросам до 10 секунд на завершение. +package main + +import ( + "context" + "flag" + "fmt" + "io" + "log" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "mtusi2026lab2/internal/api" + "mtusi2026lab2/internal/auth" + "mtusi2026lab2/internal/config" + "mtusi2026lab2/internal/session" + "mtusi2026lab2/internal/store" +) + +func main() { + healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit") + flag.Parse() + if *healthcheck { + os.Exit(runHealthcheck()) + } + + cfg, err := config.Load() + if err != nil { + log.Fatalf("config: %v", err) + } + hasher, err := auth.NewHasher() + if err != nil { + log.Fatalf("password hasher: %v", err) + } + + rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) + defer stop() + + // docker compose restart поднимает API одновременно с Postgres. + // Процесс не выходит сразу: иначе контейнер останется мёртвым, а тест сохранности + // не дождётся /health/ready. Ждём хранилища ограниченное время. + st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher) + if err != nil { + log.Fatalf("postgres: %v", err) + } + defer st.Close() + if err := st.Migrate(rootCtx); err != nil { + log.Fatalf("migrate: %v", err) + } + sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL) + if err != nil { + log.Fatalf("redis: %v", err) + } + defer sessions.Close() + + srvAPI := api.New(st, sessions) + httpServer := &http.Server{ + Addr: cfg.Addr(), + Handler: srvAPI.Handler(), + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + errCh := make(chan error, 1) + go func() { + log.Printf("listening on %s env=%s session_ttl=%s", cfg.Addr(), cfg.Env, cfg.SessionTTL) + if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { + errCh <- err + } + }() + + select { + case err := <-errCh: + log.Fatalf("listen: %v", err) + case <-rootCtx.Done(): + } + log.Printf("shutting down") + srvAPI.BeginDrain() + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := httpServer.Shutdown(ctx); err != nil { + log.Printf("shutdown error: %v", err) + os.Exit(1) + } + log.Printf("shutdown complete") +} + +func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher) (*store.Store, error) { + deadline := time.Now().Add(45 * time.Second) + var last error + for { + st, err := store.Open(ctx, dsn, hasher) + if err == nil { + return st, nil + } + last = err + if ctx.Err() != nil || time.Now().After(deadline) { + return nil, last + } + log.Printf("postgres not ready, retrying") + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(time.Second): + } + } +} + +func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) { + deadline := time.Now().Add(45 * time.Second) + var last error + for { + st, err := session.Open(redisURL, ttl) + if err == nil { + return st, nil + } + last = err + if ctx.Err() != nil || time.Now().After(deadline) { + return nil, last + } + log.Printf("redis not ready, retrying") + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(time.Second): + } + } +} + +func runHealthcheck() int { + cfg, err := config.Load() + if err != nil { + return 1 + } + host := cfg.Host + if host == "0.0.0.0" || host == "::" { + host = "127.0.0.1" + } + client := &http.Client{Timeout: 2 * time.Second} + resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port)) + if err != nil { + return 1 + } + defer resp.Body.Close() + _, _ = io.Copy(io.Discard, resp.Body) + if resp.StatusCode != http.StatusOK { + return 1 + } + return 0 +} diff --git a/cmd/track2/main.go b/cmd/track2/main.go new file mode 100644 index 00000000..c84d8e10 --- /dev/null +++ b/cmd/track2/main.go @@ -0,0 +1,509 @@ +// Команда эксперимента трека 2: план запроса и восстановление. +// +// Режимы: +// +// prepare — 100 000 сообщений в чатах неравного размера, база должна называться track2; +// explain — слабый индекс (только chat_id) против рабочего (chat_id, created_at, id), +// плюс стоимость вставки; +// verify — сверка track2 и базы, восстановленной из pg_dump. +// +// В продовой схеме остаётся только составной индекс. Слабый создаётся на время замера и удаляется. +package main + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "flag" + "fmt" + "os" + "strings" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +func main() { + mode := flag.String("mode", "", "prepare|explain|verify") + dsn := flag.String("database-url", "", "postgres URL базы track2") + restore := flag.String("restore-url", "", "postgres URL восстановленной базы") + outDir := flag.String("out", "evidence/track2", "каталог JSON") + flag.Parse() + if *mode == "" || *dsn == "" { + fmt.Fprintln(os.Stderr, "нужны -mode и -database-url") + os.Exit(2) + } + if !strings.Contains(*dsn, "track2") { + fmt.Fprintln(os.Stderr, "отказ: database-url должен указывать на базу track2, чтобы не затереть стенд smoke") + os.Exit(2) + } + ctx := context.Background() + switch *mode { + case "prepare": + if err := prepare(ctx, *dsn); err != nil { + fail(err) + } + case "explain": + if err := explain(ctx, *dsn, *outDir); err != nil { + fail(err) + } + case "verify": + if *restore == "" || !strings.Contains(*restore, "track2_restore") { + fmt.Fprintln(os.Stderr, "нужен -restore-url на базу track2_restore") + os.Exit(2) + } + if err := verify(ctx, *dsn, *restore, *outDir); err != nil { + fail(err) + } + default: + fmt.Fprintln(os.Stderr, "неизвестный mode") + os.Exit(2) + } +} + +func prepare(ctx context.Context, dsn string) error { + pool, err := open(ctx, dsn) + if err != nil { + return err + } + defer pool.Close() + // Та же схема, что у API, но без statement_timeout: загрузка 100k не должна обрываться. + if err := applySchema(ctx, pool); err != nil { + return err + } + if _, err := pool.Exec(ctx, `TRUNCATE messages, chat_members, chats, users`); err != nil { + return err + } + userID := uuid.New() + now := time.Now().UTC().Truncate(time.Millisecond) + if _, err := pool.Exec(ctx, ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, 'track2_user', 'Трек 2', 'not-a-login-hash', $2)`, userID, now); err != nil { + return err + } + // Сумма размеров = 100 000. Один чат сильно больше остальных — так план на «горячей» истории + // не маскируется равномерным распределением. + sizes := []int{1, 50, 500, 5000, 20000, 74449} + sum := 0 + for _, n := range sizes { + sum += n + } + if sum != 100000 { + return fmt.Errorf("sizes sum %d", sum) + } + type chat struct { + id uuid.UUID + size int + } + chats := make([]chat, len(sizes)) + for i, n := range sizes { + chats[i] = chat{id: uuid.New(), size: n} + if _, err := pool.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, + chats[i].id, fmt.Sprintf("chat-%d", n), now.Add(time.Duration(i)*time.Millisecond)); err != nil { + return err + } + if _, err := pool.Exec(ctx, `INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`, chats[i].id, userID); err != nil { + return err + } + } + rows := make([][]any, 0, 1000) + flush := func() error { + if len(rows) == 0 { + return nil + } + _, err := pool.CopyFrom(ctx, pgx.Identifier{"messages"}, + []string{"id", "chat_id", "sender_id", "text", "created_at"}, pgx.CopyFromRows(rows)) + rows = rows[:0] + return err + } + for _, c := range chats { + for i := 0; i < c.size; i++ { + rows = append(rows, []any{ + uuid.New(), + c.id, + userID, + fmt.Sprintf("m-%d", i), + now.Add(time.Duration(i) * time.Millisecond), + }) + if len(rows) == 1000 { + if err := flush(); err != nil { + return err + } + } + } + } + if err := flush(); err != nil { + return err + } + var n int + if err := pool.QueryRow(ctx, `SELECT count(*) FROM messages`).Scan(&n); err != nil { + return err + } + fmt.Printf("prepared messages=%d chats=%d\n", n, len(chats)) + if n != 100000 { + return fmt.Errorf("expected 100000 messages, got %d", n) + } + return nil +} + +func explain(ctx context.Context, dsn, outDir string) error { + if err := os.MkdirAll(outDir, 0o755); err != nil { + return err + } + pool, err := open(ctx, dsn) + if err != nil { + return err + } + defer pool.Close() + var chatID uuid.UUID + var size int + if err := pool.QueryRow(ctx, ` + SELECT chat_id, count(*) FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1`, + ).Scan(&chatID, &size); err != nil { + return err + } + var curAt time.Time + var curID uuid.UUID + // Середина большой истории: keyset не должен для каждой страницы читать все предыдущие строки. + if err := pool.QueryRow(ctx, ` + SELECT created_at, id FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + OFFSET 30000 LIMIT 1`, chatID).Scan(&curAt, &curID); err != nil { + return err + } + + weak, err := withIndex(ctx, pool, false, func() (map[string]any, error) { + return explainQuery(ctx, pool, chatID, curAt, curID) + }) + if err != nil { + return fmt.Errorf("weak plan: %w", err) + } + strong, err := withIndex(ctx, pool, true, func() (map[string]any, error) { + return explainQuery(ctx, pool, chatID, curAt, curID) + }) + if err != nil { + return fmt.Errorf("strong plan: %w", err) + } + writeCost, err := measureInsert(ctx, pool, chatID) + if err != nil { + return err + } + summary := map[string]any{ + "largest_chat_messages": size, + "cursor_offset": 30000, + "weak_index": "messages_chat_only_idx (chat_id)", + "strong_index": "messages_history_idx (chat_id, created_at, id)", + "weak_plan": summarizePlan(weak), + "strong_plan": summarizePlan(strong), + "write_cost": writeCost, + } + if err := writeJSON(outDir+"/explain-weak.json", weak); err != nil { + return err + } + if err := writeJSON(outDir+"/explain-strong.json", strong); err != nil { + return err + } + if err := writeJSON(outDir+"/summary.json", summary); err != nil { + return err + } + fmt.Printf("weak: %s\nstrong: %s\nwrite: %+v\n", summarizePlan(weak), summarizePlan(strong), writeCost) + return nil +} + +func verify(ctx context.Context, srcDSN, dstDSN, outDir string) error { + src, err := open(ctx, srcDSN) + if err != nil { + return err + } + defer src.Close() + dst, err := open(ctx, dstDSN) + if err != nil { + return err + } + defer dst.Close() + srcCount, srcSum, err := fingerprint(ctx, src) + if err != nil { + return fmt.Errorf("source: %w", err) + } + dstCount, dstSum, err := fingerprint(ctx, dst) + if err != nil { + return fmt.Errorf("restore: %w", err) + } + var srcSample, dstSample string + q := ` + SELECT id::text FROM messages m + JOIN (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1) big + ON big.chat_id = m.chat_id + ORDER BY m.created_at, m.id + LIMIT 1` + if err := src.QueryRow(ctx, q).Scan(&srcSample); err != nil { + return err + } + if err := dst.QueryRow(ctx, q).Scan(&dstSample); err != nil { + return err + } + report := map[string]any{ + "source_messages": srcCount.messages, + "restore_messages": dstCount.messages, + "source_chats": srcCount.chats, + "restore_chats": dstCount.chats, + "source_sha256": srcSum, + "restore_sha256": dstSum, + "source_first_id": srcSample, + "restore_first_id": dstSample, + "counts_match": srcCount == dstCount, + "checksum_match": srcSum == dstSum, + "first_id_match": srcSample == dstSample, + } + if err := os.MkdirAll(outDir, 0o755); err != nil { + return err + } + if err := writeJSON(outDir+"/restore.json", report); err != nil { + return err + } + fmt.Printf("restore match counts=%v checksum=%v first=%v messages=%d\n", + srcCount == dstCount, srcSum == dstSum, srcSample == dstSample, srcCount.messages) + if srcCount != dstCount || srcSum != dstSum || srcSample != dstSample { + return fmt.Errorf("restore mismatch") + } + return nil +} + +type counts struct { + messages int + chats int +} + +func fingerprint(ctx context.Context, pool *pgxpool.Pool) (counts, string, error) { + var c counts + if err := pool.QueryRow(ctx, `SELECT count(*) FROM messages`).Scan(&c.messages); err != nil { + return c, "", err + } + if err := pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&c.chats); err != nil { + return c, "", err + } + rows, err := pool.Query(ctx, `SELECT id::text, created_at::text, text FROM messages ORDER BY created_at, id`) + if err != nil { + return c, "", err + } + defer rows.Close() + h := sha256.New() + for rows.Next() { + var id, ts, text string + if err := rows.Scan(&id, &ts, &text); err != nil { + return c, "", err + } + _, _ = fmt.Fprintf(h, "%s|%s|%s\n", id, ts, text) + } + if err := rows.Err(); err != nil { + return c, "", err + } + return c, hex.EncodeToString(h.Sum(nil)), nil +} + +func withIndex(ctx context.Context, pool *pgxpool.Pool, strong bool, fn func() (map[string]any, error)) (map[string]any, error) { + if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS messages_history_idx`); err != nil { + return nil, err + } + if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS messages_chat_only_idx`); err != nil { + return nil, err + } + var create string + if strong { + create = `CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id)` + } else { + create = `CREATE INDEX messages_chat_only_idx ON messages (chat_id)` + } + if _, err := pool.Exec(ctx, create); err != nil { + return nil, err + } + plan, err := fn() + // Продовый индекс возвращаем даже если замер упал. + _, _ = pool.Exec(ctx, `DROP INDEX IF EXISTS messages_chat_only_idx`) + _, recErr := pool.Exec(ctx, `CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id)`) + if err != nil { + return nil, err + } + if recErr != nil { + return nil, recErr + } + return plan, nil +} + +func explainQuery(ctx context.Context, pool *pgxpool.Pool, chatID uuid.UUID, curAt time.Time, curID uuid.UUID) (map[string]any, error) { + var raw []byte + err := pool.QueryRow(ctx, ` + EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + SELECT id, created_at FROM messages + WHERE chat_id = $1 AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT 50`, chatID, curAt, curID).Scan(&raw) + if err != nil { + return nil, err + } + var parsed any + if err := json.Unmarshal(raw, &parsed); err != nil { + return nil, err + } + return map[string]any{"explain": parsed}, nil +} + +func measureInsert(ctx context.Context, pool *pgxpool.Pool, chatID uuid.UUID) (map[string]any, error) { + var userID uuid.UUID + if err := pool.QueryRow(ctx, `SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID).Scan(&userID); err != nil { + return nil, err + } + if _, err := pool.Exec(ctx, `DROP TABLE IF EXISTS messages_write_probe`); err != nil { + return nil, err + } + if _, err := pool.Exec(ctx, ` + CREATE TABLE messages_write_probe ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL, + created_at timestamptz NOT NULL + )`); err != nil { + return nil, err + } + defer pool.Exec(ctx, `DROP TABLE IF EXISTS messages_write_probe`) + one, err := timedInsert(ctx, pool, chatID, userID, `CREATE INDEX probe_chat ON messages_write_probe (chat_id)`) + if err != nil { + return nil, err + } + if _, err := pool.Exec(ctx, `TRUNCATE messages_write_probe`); err != nil { + return nil, err + } + if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS probe_chat`); err != nil { + return nil, err + } + both, err := timedInsert(ctx, pool, chatID, userID, ` + CREATE INDEX probe_chat ON messages_write_probe (chat_id); + CREATE INDEX probe_hist ON messages_write_probe (chat_id, created_at, id)`) + if err != nil { + return nil, err + } + return map[string]any{ + "rows": 5000, + "only_chat_id_index_ms": one, + "chat_id_plus_history_ms": both, + }, nil +} + +func timedInsert(ctx context.Context, pool *pgxpool.Pool, chatID, userID uuid.UUID, indexSQL string) (int64, error) { + for _, stmt := range strings.Split(indexSQL, ";") { + stmt = strings.TrimSpace(stmt) + if stmt == "" { + continue + } + if _, err := pool.Exec(ctx, stmt); err != nil { + return 0, err + } + } + rows := make([][]any, 5000) + base := time.Now().UTC() + for i := range rows { + rows[i] = []any{uuid.New(), chatID, userID, "w", base.Add(time.Duration(i) * time.Millisecond)} + } + start := time.Now() + _, err := pool.CopyFrom(ctx, pgx.Identifier{"messages_write_probe"}, + []string{"id", "chat_id", "sender_id", "text", "created_at"}, pgx.CopyFromRows(rows)) + return time.Since(start).Milliseconds(), err +} + +func summarizePlan(plan map[string]any) string { + list, _ := plan["explain"].([]any) + if len(list) == 0 { + return "empty" + } + root, _ := list[0].(map[string]any) + p, _ := root["Plan"].(map[string]any) + node, _ := p["Node Type"].(string) + return fmt.Sprintf("node=%s execution_ms=%v shared_hit_blocks=%v sort=%v", + node, root["Execution Time"], p["Shared Hit Blocks"], hasNode(p, "Sort")) +} + +func hasNode(plan map[string]any, name string) bool { + if plan == nil { + return false + } + if plan["Node Type"] == name { + return true + } + children, _ := plan["Plans"].([]any) + for _, child := range children { + m, _ := child.(map[string]any) + if hasNode(m, name) { + return true + } + } + return false +} + +func applySchema(ctx context.Context, pool *pgxpool.Pool) error { + stmts := []string{ + `CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL)`, + `CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL)`, + `CREATE TABLE IF NOT EXISTS chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id))`, + `CREATE TABLE IF NOT EXISTS messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL)`, + `CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id)`, + } + for _, stmt := range stmts { + if _, err := pool.Exec(ctx, stmt); err != nil { + return err + } + } + return nil +} + +func open(ctx context.Context, dsn string) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + return nil, err + } + cfg.MaxConns = 4 + cfg.ConnConfig.ConnectTimeout = 5 * time.Second + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, err + } + if err := pool.Ping(ctx); err != nil { + pool.Close() + return nil, err + } + _, _ = pool.Exec(ctx, `SET statement_timeout = 0`) + return pool, nil +} + +func writeJSON(path string, v any) error { + b, err := json.MarshalIndent(v, "", " ") + if err != nil { + return err + } + return os.WriteFile(path, append(b, '\n'), 0o644) +} + +func fail(err error) { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..6228e20d --- /dev/null +++ b/compose.yaml @@ -0,0 +1,60 @@ +# Локальный стенд lab2. Образы закреплены тегом, не latest. +# Сессии живут в Redis с AOF: рестарт контейнера не стирает ключи, volume redisdata сохраняет файл. +# PostgreSQL — источник истины для пользователей, чатов и сообщений. +services: + postgres: + image: postgres:16.6 + environment: + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger} + POSTGRES_DB: ${POSTGRES_DB:-messenger} + volumes: + - pgdata:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"] + interval: 5s + timeout: 3s + retries: 20 + stop_grace_period: 10s + + redis: + image: redis:7.4.1 + # everysec — компромисс durability: потерять можно около секунды записей при внезапном kill -9, + # обычный docker restart данные сессий сохраняет. + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redisdata:/data + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + stop_grace_period: 10s + + api: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: ${APP_ENV:-lab} + APP_ACCESS_LOG: ${APP_ACCESS_LOG:-1} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgres://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-messenger}@postgres:5432/${POSTGRES_DB:-messenger}?sslmode=disable + REDIS_URL: redis://redis:6379/0 + ports: + - "127.0.0.1:8080:8080" + restart: unless-stopped + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + stop_grace_period: 10s + +volumes: + pgdata: + redisdata: diff --git a/evidence/deps-down.txt b/evidence/deps-down.txt new file mode 100644 index 00000000..d2f6a471 --- /dev/null +++ b/evidence/deps-down.txt @@ -0,0 +1,9 @@ +ready_before=200 +stop redis +ready_redis_down=503 +start redis +ready_redis_back=200 +stop postgres +ready_postgres_down=503 +start postgres +ready_postgres_back=200 diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/smoke-pass.txt b/evidence/smoke-pass.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/smoke-pass.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-test.txt b/evidence/student-test.txt new file mode 100644 index 00000000..ba557e35 --- /dev/null +++ b/evidence/student-test.txt @@ -0,0 +1,106 @@ +go test ./student-tests/ -v -count=1 -timeout 180s +=== RUN TestMalformedJSONAndValidation + api_test.go:73: → битый JSON, лишнее поле, пустой текст, чужой чат +2026/10/14 22:42:40 method=POST path=/api/v1/users status=400 request_id=db0c2117-db67-4ab9-a699-15677c5c8e82 duration_ms=0 + api_test.go:76: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"db0c2117-db67-4ab9-a699-15677c5c8e82"}} +2026/10/14 22:42:40 method=POST path=/api/v1/users status=400 request_id=e9462332-69fc-4af0-b565-138cdb4de77c duration_ms=0 + api_test.go:83: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"e9462332-69fc-4af0-b565-138cdb4de77c"}} +2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=2c9326a6-18dd-48f2-81d4-25649f6576ba duration_ms=47 + api_test.go:88: создан ok_user_3cadde8f id=651a935f-d2c3-43c1-8a41-2091d51869df +2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=dac3bb08-334d-464b-a77e-7e0caa05da79 duration_ms=43 + api_test.go:89: сессия выпущена, длина токена=64 (значение не печатаем) +2026/10/14 22:42:40 method=POST path=/api/v1/chats status=201 request_id=d27a6905-9e2e-4401-bcde-d193fd3ffd31 duration_ms=8 +2026/10/14 22:42:40 method=POST path=/api/v1/chats/72b3d41a-2a9b-4200-89c7-04b8cf677fbd/messages status=400 request_id=1ab2e48a-039f-47b6-b10c-9db395a19c08 duration_ms=0 + api_test.go:92: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"1ab2e48a-039f-47b6-b10c-9db395a19c08"}} +2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=39d6f236-ef73-47ba-83cd-2b364cad2e93 duration_ms=41 + api_test.go:97: создан outsider_6da955f2 id=11dc7c58-8f82-4df6-9f21-efe30bbeca0b +2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=83a59fc3-2092-4b62-bb99-d7c1b1bbf0d8 duration_ms=43 + api_test.go:98: сессия выпущена, длина токена=64 (значение не печатаем) +2026/10/14 22:42:40 method=POST path=/api/v1/chats/72b3d41a-2a9b-4200-89c7-04b8cf677fbd/messages status=404 request_id=d010a434-6f1b-4755-af3a-e0ff70dd4977 duration_ms=2 + api_test.go:100: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"d010a434-6f1b-4755-af3a-e0ff70dd4977"}} + api_test.go:104: ✓ валидация JSON, пустого текста и чужого чата +--- PASS: TestMalformedJSONAndValidation (0.19s) +=== RUN TestWrongPasswordLogoutAndIgnoredUserHeader + api_test.go:110: → неверный пароль, Basic на бизнес-методе, X-User-Id, logout +2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=94135aad-22c5-4efe-9e9c-7c186e4e882f duration_ms=41 + api_test.go:111: создан auth_user_eeb9bffa id=24709210-e37e-412a-a2c3-c6bc6d1d94a5 +2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=eb2ab683-800d-4e27-83f9-6babb77fb78d duration_ms=43 + api_test.go:112: создан auth_other_28c87fd6 id=7ba5a8e8-7334-4d9a-adc6-f1838016ad23 +2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=401 request_id=af58975d-5c3d-4105-9e75-eceb8779c0d9 duration_ms=42 + api_test.go:117: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"af58975d-5c3d-4105-9e75-eceb8779c0d9"}} +2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=37ceb9c7-1cc0-4e5e-abf2-5b1db8619733 duration_ms=42 + api_test.go:122: сессия выпущена, длина токена=64 (значение не печатаем) +2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=03c49eb3-a35e-4c83-b8ea-3d18810ec773 duration_ms=0 + api_test.go:126: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"03c49eb3-a35e-4c83-b8ea-3d18810ec773"}} +2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=55a150d9-208a-4347-a930-4ff11c5233eb duration_ms=0 + api_test.go:132: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"55a150d9-208a-4347-a930-4ff11c5233eb"}} +2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=200 request_id=70af7739-36a1-4877-a66a-dbb6363f0218 duration_ms=1 + api_test.go:141: status=200 body={"created_at":"2026-10-14T19:42:40.597Z","display_name":"Студент","id":"24709210-e37e-412a-a2c3-c6bc6d1d94a5","username":"auth_user_eeb9bffa"} +2026/10/14 22:42:40 method=DELETE path=/api/v1/auth/sessions/current status=204 request_id=6d8a5397-9d10-4b99-867c-ac14aceac351 duration_ms=1 + api_test.go:147: logout status=204 +2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=c50a007a-5035-4e06-ab4a-af010d47f8c3 duration_ms=1 +2026/10/14 22:42:40 method=DELETE path=/api/v1/auth/sessions/current status=401 request_id=1c274613-aeb3-4378-a750-cc94bd18bee6 duration_ms=1 + api_test.go:159: ✓ пароль, заголовки и отзыв сессии +--- PASS: TestWrongPasswordLogoutAndIgnoredUserHeader (0.18s) +=== RUN TestSessionExpiry + api_test.go:165: → SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается +2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=74b3345f-dec8-407a-80d9-278a1df89319 duration_ms=44 + api_test.go:166: создан ttl_user_6308467a id=be7334ea-1153-41f9-8047-1365cac6f5e4 +2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=dca5d965-9d6d-4615-bfc3-cbb2072da796 duration_ms=43 + api_test.go:167: сессия выпущена, длина токена=64 (значение не печатаем) +2026/10/14 22:42:43 method=GET path=/api/v1/users/me status=401 request_id=48e0b70b-ccb6-43ad-a346-28994552a1ca duration_ms=2 + api_test.go:170: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"48e0b70b-ccb6-43ad-a346-28994552a1ca"}} + api_test.go:174: ✓ истёкшая сессия отклонена +--- PASS: TestSessionExpiry (2.59s) +=== RUN TestDuplicateUsernameRace + api_test.go:181: → 8 параллельных регистраций username=race_c93a2ca7 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=55b47bef-3dbf-40b6-ae97-54baf81e83f5 duration_ms=69 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=5e44a96e-1029-417c-9e3b-64f89d848e0b duration_ms=71 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=889d648a-012e-45c9-844d-222238746315 duration_ms=71 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=f90c40f9-b561-46bf-b1cd-0d9d9c210b1b duration_ms=72 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=c2a836e7-ac2f-4d7a-9cbd-a5244a9cf1b1 duration_ms=78 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=f857d038-d7af-4102-9049-215605ad1447 duration_ms=77 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=88060523-0692-4030-894a-3ef49ec98a3c duration_ms=80 +2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=65d31b3a-04c9-40b4-9972-9599633b56e0 duration_ms=88 + api_test.go:206: created=1 conflict=7 + api_test.go:210: ✓ UNIQUE username выдержал гонку +--- PASS: TestDuplicateUsernameRace (0.10s) +=== RUN TestChatCreateRollsBack +2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=31a99df2-1cbb-4f6d-a0da-93874734b125 duration_ms=46 + api_test.go:216: создан roll_user_5dc7e0b5 id=b3e79e6a-0372-4ddb-b42b-88faf144cffa +2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=201 request_id=7df88d52-ca91-4117-b0d8-e67873c30a8e duration_ms=47 + api_test.go:217: сессия выпущена, длина токена=64 (значение не печатаем) + api_test.go:220: → создание чата с несуществующим участником должно откатиться, title=rollback-c249f42e-7e4b-45e5-899f-fca7fb2c8748 +2026/10/14 22:42:43 method=POST path=/api/v1/chats status=400 request_id=f5e498dd-c82e-449a-beba-a95a8d7bd4f2 duration_ms=7 + api_test.go:223: status=400 body={"error":{"code":"invalid_request","message":"unknown member","request_id":"f5e498dd-c82e-449a-beba-a95a8d7bd4f2"}} + api_test.go:231: строк chats с этим title после ошибки: 0 + api_test.go:235: ✓ транзакция создания чата откатилась +--- PASS: TestChatCreateRollsBack (0.11s) +=== RUN TestPaginationPages + api_test.go:241: → три сообщения, две страницы limit=2, затем последняя +2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=5c1c6082-a8cd-4b01-99b2-160271bbce01 duration_ms=49 + api_test.go:242: создан page_user_89c36669 id=d89903f6-8866-43f7-b83d-c119cf945dc9 +2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=201 request_id=4ff6d887-e45d-47f8-8781-b2a8bf302dd6 duration_ms=46 + api_test.go:243: сессия выпущена, длина токена=64 (значение не печатаем) +2026/10/14 22:42:43 method=POST path=/api/v1/chats status=201 request_id=e2552d9a-60ee-4b51-a7a8-541195f8c154 duration_ms=5 +2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=3de7ef09-36db-4d9f-8f76-ed4e4895a661 duration_ms=5 +2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=6461472e-b6c9-4c79-a676-807dbfac8e64 duration_ms=1 +2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=57164ec9-1914-489a-809d-b8dd483fd833 duration_ms=1 +2026/10/14 22:42:43 method=GET path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=200 request_id=48fea270-e7bf-4f0c-b123-bce8eec0b836 duration_ms=2 + api_test.go:253: status=200 body={"items":[{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.639Z","id":"ba4c7ac6-44f6-49da-9e93-dd6fc85c8bcb","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","text":"раз"},{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.643Z","id":"43302df0-2a23-4e84-929b-559d2d47ada1","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","te... +2026/10/14 22:42:43 method=GET path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=200 request_id=1277752d-bba6-4458-b304-9db0a01e6513 duration_ms=2 + api_test.go:261: status=200 body={"items":[{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.645Z","id":"187eb4f4-1ccf-4253-9737-3ec8ffbab89e","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","text":"три"}],"next_cursor":null} + api_test.go:267: ✓ keyset обошёл историю без зависания cursor +--- PASS: TestPaginationPages (0.12s) +=== RUN TestRedisDownIsNotAnonymous + api_test.go:271: → закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима +2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=6d30a90b-f1f4-4952-b7f9-356316ed7bf0 duration_ms=46 + api_test.go:283: создан redis_down_64e13e26 id=2263b741-9519-489e-8d91-fe23cd9ff347 +2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=503 request_id=5dd380b7-9f8a-4bb9-b199-56373bedd5a6 duration_ms=44 + api_test.go:288: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"5dd380b7-9f8a-4bb9-b199-56373bedd5a6"}} +2026/10/14 22:42:43 method=GET path=/api/v1/users/me status=503 request_id=fc700303-3f23-499c-bf31-41330924d33b duration_ms=0 + api_test.go:295: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"fc700303-3f23-499c-bf31-41330924d33b"}} + api_test.go:299: ✓ сбой Redis не стал анонимным доступом +--- PASS: TestRedisDownIsNotAnonymous (0.10s) +PASS +ok mtusi2026lab2/student-tests 4.097s diff --git a/evidence/track2/explain-strong.json b/evidence/track2/explain-strong.json new file mode 100644 index 00000000..797a559d --- /dev/null +++ b/evidence/track2/explain-strong.json @@ -0,0 +1,77 @@ +{ + "explain": [ + { + "Execution Time": 0.091, + "Plan": { + "Actual Loops": 1, + "Actual Rows": 50, + "Actual Startup Time": 0.061, + "Actual Total Time": 0.075, + "Async Capable": false, + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Node Type": "Limit", + "Parallel Aware": false, + "Plan Rows": 50, + "Plan Width": 24, + "Plans": [ + { + "Actual Loops": 1, + "Actual Rows": 50, + "Actual Startup Time": 0.06, + "Actual Total Time": 0.068, + "Alias": "messages", + "Async Capable": false, + "Heap Fetches": 50, + "Index Cond": "((chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid) AND (ROW(created_at, id) \u003e ROW('2026-10-14 19:46:28.256+00'::timestamp with time zone, 'f051734d-6f81-440a-9253-0b417ccee2b1'::uuid)))", + "Index Name": "messages_history_idx", + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Node Type": "Index Only Scan", + "Parallel Aware": false, + "Parent Relationship": "Outer", + "Plan Rows": 167, + "Plan Width": 24, + "Relation Name": "messages", + "Rows Removed by Index Recheck": 0, + "Scan Direction": "Forward", + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 1, + "Shared Read Blocks": 3, + "Shared Written Blocks": 0, + "Startup Cost": 0.42, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 635.76 + } + ], + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 1, + "Shared Read Blocks": 3, + "Shared Written Blocks": 0, + "Startup Cost": 0.42, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 190.64 + }, + "Planning": { + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 22, + "Shared Read Blocks": 1, + "Shared Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.17, + "Triggers": [] + } + ] +} diff --git a/evidence/track2/explain-weak.json b/evidence/track2/explain-weak.json new file mode 100644 index 00000000..57129622 --- /dev/null +++ b/evidence/track2/explain-weak.json @@ -0,0 +1,139 @@ +{ + "explain": [ + { + "Execution Time": 16.435, + "Plan": { + "Actual Loops": 1, + "Actual Rows": 50, + "Actual Startup Time": 16.393, + "Actual Total Time": 16.403, + "Async Capable": false, + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Node Type": "Limit", + "Parallel Aware": false, + "Plan Rows": 50, + "Plan Width": 24, + "Plans": [ + { + "Actual Loops": 1, + "Actual Rows": 50, + "Actual Startup Time": 16.392, + "Actual Total Time": 16.396, + "Async Capable": false, + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Node Type": "Sort", + "Parallel Aware": false, + "Parent Relationship": "Outer", + "Plan Rows": 167, + "Plan Width": 24, + "Plans": [ + { + "Actual Loops": 1, + "Actual Rows": 44448, + "Actual Startup Time": 4.156, + "Actual Total Time": 10.771, + "Alias": "messages", + "Async Capable": false, + "Exact Heap Blocks": 847, + "Filter": "(ROW(created_at, id) \u003e ROW('2026-10-14 19:46:28.256+00'::timestamp with time zone, 'f051734d-6f81-440a-9253-0b417ccee2b1'::uuid))", + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Lossy Heap Blocks": 0, + "Node Type": "Bitmap Heap Scan", + "Parallel Aware": false, + "Parent Relationship": "Outer", + "Plan Rows": 167, + "Plan Width": 24, + "Plans": [ + { + "Actual Loops": 1, + "Actual Rows": 74449, + "Actual Startup Time": 1.682, + "Actual Total Time": 1.683, + "Async Capable": false, + "Index Cond": "(chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid)", + "Index Name": "messages_chat_only_idx", + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Node Type": "Bitmap Index Scan", + "Parallel Aware": false, + "Parent Relationship": "Outer", + "Plan Rows": 500, + "Plan Width": 0, + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 0, + "Shared Read Blocks": 66, + "Shared Written Blocks": 0, + "Startup Cost": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 8.04 + } + ], + "Recheck Cond": "(chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid)", + "Relation Name": "messages", + "Rows Removed by Filter": 30001, + "Rows Removed by Index Recheck": 0, + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 847, + "Shared Read Blocks": 66, + "Shared Written Blocks": 0, + "Startup Cost": 8.08, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 918.22 + } + ], + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 847, + "Shared Read Blocks": 66, + "Shared Written Blocks": 0, + "Sort Key": [ + "created_at", + "id" + ], + "Sort Method": "top-N heapsort", + "Sort Space Type": "Memory", + "Sort Space Used": 28, + "Startup Cost": 923.77, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 924.19 + } + ], + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 847, + "Shared Read Blocks": 66, + "Shared Written Blocks": 0, + "Startup Cost": 923.77, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Total Cost": 923.89 + }, + "Planning": { + "Local Dirtied Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Written Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Hit Blocks": 16, + "Shared Read Blocks": 1, + "Shared Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.131, + "Triggers": [] + } + ] +} diff --git a/evidence/track2/restore.json b/evidence/track2/restore.json new file mode 100644 index 00000000..5dc03b43 --- /dev/null +++ b/evidence/track2/restore.json @@ -0,0 +1,13 @@ +{ + "checksum_match": true, + "counts_match": true, + "first_id_match": true, + "restore_chats": 6, + "restore_first_id": "4f8212c8-fea5-4870-989c-b5edf0dfdcf5", + "restore_messages": 100000, + "restore_sha256": "a6cec9d9dbd5898032730f587fdd6fad981f64360584ccfe6da60384b87e28c9", + "source_chats": 6, + "source_first_id": "4f8212c8-fea5-4870-989c-b5edf0dfdcf5", + "source_messages": 100000, + "source_sha256": "a6cec9d9dbd5898032730f587fdd6fad981f64360584ccfe6da60384b87e28c9" +} diff --git a/evidence/track2/run.txt b/evidence/track2/run.txt new file mode 100644 index 00000000..28ce842e --- /dev/null +++ b/evidence/track2/run.txt @@ -0,0 +1,5 @@ +prepared messages=100000 chats=6 +weak: node=Limit execution_ms=16.435 shared_hit_blocks=847 sort=true +strong: node=Limit execution_ms=0.091 shared_hit_blocks=1 sort=false +write: only_chat_id_index_ms=30 chat_id_plus_history_ms=31 rows=5000 +restore match counts=true checksum=true messages=100000 diff --git a/evidence/track2/summary.json b/evidence/track2/summary.json new file mode 100644 index 00000000..b7b868aa --- /dev/null +++ b/evidence/track2/summary.json @@ -0,0 +1,13 @@ +{ + "cursor_offset": 30000, + "largest_chat_messages": 74449, + "strong_index": "messages_history_idx (chat_id, created_at, id)", + "strong_plan": "node=Limit execution_ms=0.091 shared_hit_blocks=1 sort=false", + "weak_index": "messages_chat_only_idx (chat_id)", + "weak_plan": "node=Limit execution_ms=16.435 shared_hit_blocks=847 sort=true", + "write_cost": { + "chat_id_plus_history_ms": 31, + "only_chat_id_index_ms": 30, + "rows": 5000 + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..f3a74025 --- /dev/null +++ b/go.mod @@ -0,0 +1,21 @@ +module mtusi2026lab2 + +go 1.23.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.7.4 + github.com/redis/go-redis/v9 v9.7.3 + golang.org/x/crypto v0.36.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // 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 + golang.org/x/sync v0.12.0 // indirect + golang.org/x/sys v0.31.0 // indirect + golang.org/x/text v0.23.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..7082ba39 --- /dev/null +++ b/go.sum @@ -0,0 +1,42 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +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.4 h1:9wKznZrhWa2QiHL+NjTSPP6yjl3451BX3imWDnokYlg= +github.com/jackc/pgx/v5 v5.7.4/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM= +github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= +golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= +golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= +golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= +golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +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/internal/api/server.go b/internal/api/server.go new file mode 100644 index 00000000..782f9a0c --- /dev/null +++ b/internal/api/server.go @@ -0,0 +1,630 @@ +// Package api — HTTP-слой lab2. +// +// Порядок обработки запроса: +// 1. X-Request-Id на каждый ответ, включая ошибки; +// 2. журнал method/path/status без текста сообщений и без токена; +// 3. маршрут; +// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают. +// +// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL и Redis: +// без них нельзя честно принять запись или узнать, кто делает запрос. +package api + +import ( + "context" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "log" + "net/http" + "os" + "strconv" + "strings" + "sync/atomic" + "time" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi2026lab2/internal/session" + "mtusi2026lab2/internal/store" +) + +type ctxKey int + +const ( + userKey ctxKey = iota + tokenKey + requestIDKey +) + +const ( + challengeBasic = `Basic realm="messenger", charset="UTF-8"` + challengeBearer = `Bearer realm="messenger"` +) + +// Server связывает HTTP с PostgreSQL и Redis. +type Server struct { + Store *store.Store + Sessions *session.Store + ready atomic.Bool +} + +// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready. +func New(st *store.Store, sessions *session.Store) *Server { + s := &Server{Store: st, Sessions: sessions} + s.ready.Store(true) + return s +} + +// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready. +func (s *Server) BeginDrain() { s.ready.Store(false) } + +// Handler собирает маршруты lab2. Идемпотентности и вложений здесь нет — это lab3+. +func (s *Server) Handler() http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("GET /health/live", s.handleLive) + mux.HandleFunc("GET /health/ready", s.handleReady) + mux.HandleFunc("POST /api/v1/users", s.handleCreateUser) + mux.HandleFunc("POST /api/v1/auth/sessions", s.handleCreateSession) + mux.HandleFunc("DELETE /api/v1/auth/sessions/current", s.requireUser(s.handleRevokeSession)) + mux.HandleFunc("GET /api/v1/users/me", s.requireUser(s.handleMe)) + mux.HandleFunc("POST /api/v1/chats", s.requireUser(s.handleCreateChat)) + mux.HandleFunc("GET /api/v1/chats", s.requireUser(s.handleListChats)) + mux.HandleFunc("GET /api/v1/chats/{chat_id}", s.requireUser(s.handleGetChat)) + mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleCreateMessage)) + mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleListMessages)) + return s.withRequestID(s.withAccessLog(mux)) +} + +func (s *Server) handleLive(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) { + if !s.ready.Load() { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "service is shutting down") + return + } + if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + return + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) { + var body struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := decodeStrict(r, &body); err != nil { + writeDecodeErr(w, r, err) + return + } + if !validUsername(body.Username) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username") + return + } + display := strings.TrimSpace(body.DisplayName) + if display == "" || utf8.RuneCountInString(display) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name") + return + } + if n := utf8.RuneCountInString(body.Password); n < 12 || n > 128 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password") + return + } + u, err := s.Store.CreateUser(r.Context(), body.Username, display, body.Password) + if err != nil { + s.writeStoreErr(w, r, err, http.StatusConflict, "conflict", "username already taken") + return + } + writeJSON(w, http.StatusCreated, userDTO(u)) +} + +func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) { + username, password, ok := parseBasic(r.Header.Get("Authorization")) + if !ok || !validUsername(username) { + writeAuthError(w, r, challengeBasic) + return + } + if n := utf8.RuneCountInString(password); n < 12 || n > 128 { + writeAuthError(w, r, challengeBasic) + return + } + u, err := s.Store.Authenticate(r.Context(), username, password) + if errors.Is(err, store.ErrNotFound) { + writeAuthError(w, r, challengeBasic) + return + } + if err != nil { + s.writeStoreErr(w, r, err, 0, "", "") + return + } + token, exp, err := s.Sessions.Issue(r.Context(), u.ID) + if err != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + return + } + writeJSON(w, http.StatusCreated, map[string]any{ + "token": token, + "token_type": "Bearer", + "expires_at": formatTime(exp), + "user": userDTO(u), + }) +} + +func (s *Server) handleRevokeSession(w http.ResponseWriter, r *http.Request) { + token, _ := r.Context().Value(tokenKey).(string) + if err := s.Sessions.Revoke(r.Context(), token); err != nil { + if errors.Is(err, session.ErrUnauthorized) { + writeAuthError(w, r, challengeBearer) + return + } + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + return + } + w.WriteHeader(http.StatusNoContent) +} + +func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) { + u, err := s.Store.GetUser(r.Context(), userFrom(r)) + if err != nil { + s.writeStoreErr(w, r, err, http.StatusUnauthorized, "unauthorized", "authentication required") + return + } + writeJSON(w, http.StatusOK, userDTO(u)) +} + +func (s *Server) handleCreateChat(w http.ResponseWriter, r *http.Request) { + var body struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := decodeStrict(r, &body); err != nil { + writeDecodeErr(w, r, err) + return + } + title := strings.TrimSpace(body.Title) + if title == "" || utf8.RuneCountInString(title) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title") + return + } + if len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids") + return + } + uid := userFrom(r) + seen := make(map[uuid.UUID]struct{}, len(body.MemberIDs)) + ids := make([]uuid.UUID, 0, len(body.MemberIDs)) + callerPresent := false + for _, raw := range body.MemberIDs { + id, err := uuid.Parse(raw) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member id") + return + } + if _, dup := seen[id]; dup { + writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate member id") + return + } + seen[id] = struct{}{} + if id == uid { + callerPresent = true + } + ids = append(ids, id) + } + if !callerPresent { + writeError(w, r, http.StatusBadRequest, "invalid_request", "caller must be a member") + return + } + chat, err := s.Store.CreateChat(r.Context(), title, ids) + if errors.Is(err, store.ErrNotFound) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "unknown member") + return + } + if err != nil { + s.writeStoreErr(w, r, err, 0, "", "") + return + } + writeJSON(w, http.StatusCreated, chatDTO(chat)) +} + +func (s *Server) handleListChats(w http.ResponseWriter, r *http.Request) { + uid := userFrom(r) + limit, after, err := parsePage(r, "chats:"+uid.String()) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error()) + return + } + items, next, err := s.Store.ListChats(r.Context(), uid, limit, after) + if err != nil { + s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor") + return + } + out := make([]any, len(items)) + for i := range items { + out[i] = chatDTO(&items[i]) + } + var cursor *store.PageCursor + if next != nil { + cursor = &store.PageCursor{Scope: "chats:" + uid.String(), CreatedAt: next.CreatedAt, ID: next.ID} + } + writeJSON(w, http.StatusOK, pageDTO(out, cursor)) +} + +func (s *Server) handleGetChat(w http.ResponseWriter, r *http.Request) { + chatID, err := uuid.Parse(r.PathValue("chat_id")) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id") + return + } + chat, err := s.Store.GetChat(r.Context(), chatID, userFrom(r)) + if errors.Is(err, store.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + if err != nil { + s.writeStoreErr(w, r, err, 0, "", "") + return + } + writeJSON(w, http.StatusOK, chatDTO(chat)) +} + +func (s *Server) handleCreateMessage(w http.ResponseWriter, r *http.Request) { + chatID, err := uuid.Parse(r.PathValue("chat_id")) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id") + return + } + var body struct { + Text string `json:"text"` + } + if err := decodeStrict(r, &body); err != nil { + writeDecodeErr(w, r, err) + return + } + text := strings.TrimSpace(body.Text) + if text == "" || utf8.RuneCountInString(text) > 4000 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text") + return + } + msg, err := s.Store.CreateMessage(r.Context(), chatID, userFrom(r), text) + if errors.Is(err, store.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + if err != nil { + s.writeStoreErr(w, r, err, 0, "", "") + return + } + writeJSON(w, http.StatusCreated, messageDTO(msg)) +} + +func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) { + chatID, err := uuid.Parse(r.PathValue("chat_id")) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id") + return + } + scope := "chat:" + chatID.String() + limit, after, err := parsePage(r, scope) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error()) + return + } + items, next, err := s.Store.ListMessages(r.Context(), chatID, userFrom(r), limit, after) + if errors.Is(err, store.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + if err != nil { + s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor") + return + } + out := make([]any, len(items)) + for i := range items { + out[i] = messageDTO(&items[i]) + } + var cursor *store.PageCursor + if next != nil { + cursor = &store.PageCursor{Scope: scope, CreatedAt: next.CreatedAt, ID: next.ID} + } + writeJSON(w, http.StatusOK, pageDTO(out, cursor)) +} + +// requireUser принимает только Authorization: Bearer. X-User-Id не читается. +// Basic на бизнес-методе — тот же 401, но с Bearer-challenge, не с Basic. +func (s *Server) requireUser(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + header := r.Header.Get("Authorization") + if strings.HasPrefix(strings.ToLower(header), "basic ") { + writeAuthError(w, r, challengeBearer) + return + } + token, ok := parseBearer(header) + if !ok { + writeAuthError(w, r, challengeBearer) + return + } + uid, err := s.Sessions.Lookup(r.Context(), token) + if errors.Is(err, session.ErrUnauthorized) { + writeAuthError(w, r, challengeBearer) + return + } + if err != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + return + } + ctx := context.WithValue(r.Context(), userKey, uid) + ctx = context.WithValue(ctx, tokenKey, token) + next(w, r.WithContext(ctx)) + } +} + +func userFrom(r *http.Request) uuid.UUID { + id, _ := r.Context().Value(userKey).(uuid.UUID) + return id +} + +func (s *Server) withRequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + rid := r.Header.Get("X-Request-Id") + if rid == "" { + rid = uuid.NewString() + } + w.Header().Set("X-Request-Id", rid) + next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, rid))) + }) +} + +type statusRecorder struct { + http.ResponseWriter + status int +} + +func (s *statusRecorder) WriteHeader(code int) { + s.status = code + s.ResponseWriter.WriteHeader(code) +} + +func (s *Server) withAccessLog(next http.Handler) http.Handler { + quiet := strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "0") || strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "false") + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK} + next.ServeHTTP(rec, r) + if quiet && rec.status < 400 { + return + } + if strings.HasPrefix(r.URL.Path, "/health/") && rec.status == http.StatusOK { + return + } + rid, _ := r.Context().Value(requestIDKey).(string) + // path без query: в cursor нет секрета, но и текста сообщения в логе быть не должно. + log.Printf("method=%s path=%s status=%d request_id=%s duration_ms=%d", + r.Method, r.URL.Path, rec.status, rid, time.Since(start).Milliseconds()) + }) +} + +func parsePage(r *http.Request, expectedScope string) (int, *store.PageCursor, error) { + limit := 50 + if raw := r.URL.Query().Get("limit"); raw != "" { + n, err := strconv.Atoi(raw) + if err != nil || n < 1 || n > 100 { + return 0, nil, fmt.Errorf("invalid limit") + } + limit = n + } + rawCursor := r.URL.Query().Get("cursor") + if rawCursor == "" { + return limit, nil, nil + } + cur, err := decodeCursor(rawCursor) + if err != nil || cur.Scope != expectedScope { + return 0, nil, fmt.Errorf("invalid cursor") + } + return limit, cur, nil +} + +func encodeCursor(c *store.PageCursor) string { + payload := fmt.Sprintf("%s|%s|%s", c.Scope, c.CreatedAt.UTC().Format(time.RFC3339Nano), c.ID.String()) + return base64.RawURLEncoding.EncodeToString([]byte(payload)) +} + +func decodeCursor(raw string) (*store.PageCursor, error) { + b, err := base64.RawURLEncoding.DecodeString(raw) + if err != nil { + return nil, err + } + parts := strings.SplitN(string(b), "|", 3) + if len(parts) != 3 { + return nil, fmt.Errorf("bad cursor") + } + ts, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return nil, err + } + id, err := uuid.Parse(parts[2]) + if err != nil { + return nil, err + } + return &store.PageCursor{Scope: parts[0], CreatedAt: ts.UTC(), ID: id}, nil +} + +func validUsername(s string) bool { + if len(s) < 3 || len(s) > 32 { + return false + } + for _, c := range s { + if (c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' { + return false + } + } + return true +} + +func decodeStrict(r *http.Request, dst any) error { + ct := r.Header.Get("Content-Type") + if ct != "" && !strings.HasPrefix(strings.ToLower(strings.TrimSpace(ct)), "application/json") { + return errUnsupported + } + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(dst); err != nil { + return errMalformed + } + if dec.More() { + return errMalformed + } + return nil +} + +var ( + errUnsupported = errors.New("unsupported media type") + errMalformed = errors.New("malformed json") +) + +func writeDecodeErr(w http.ResponseWriter, r *http.Request, err error) { + if errors.Is(err, errUnsupported) { + writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "unsupported media type") + return + } + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed json") +} + +func parseBasic(header string) (string, string, bool) { + const prefix = "basic " + if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):])) + if err != nil || !utf8.Valid(raw) { + return "", "", false + } + user, pass, ok := strings.Cut(string(raw), ":") + if !ok || user == "" { + return "", "", false + } + return user, pass, true +} + +func parseBearer(header string) (string, bool) { + const prefix = "bearer " + if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix { + return "", false + } + token := strings.TrimSpace(header[len(prefix):]) + if token == "" || strings.Contains(token, " ") { + return "", false + } + return token, true +} + +func userDTO(u *store.User) map[string]any { + return map[string]any{ + "id": u.ID.String(), + "username": u.Username, + "display_name": u.DisplayName, + "created_at": formatTime(u.CreatedAt), + } +} + +func chatDTO(c *store.Chat) map[string]any { + ids := make([]string, len(c.MemberIDs)) + for i, id := range c.MemberIDs { + ids[i] = id.String() + } + return map[string]any{ + "id": c.ID.String(), + "title": c.Title, + "member_ids": ids, + "created_at": formatTime(c.CreatedAt), + } +} + +func messageDTO(m *store.Message) map[string]any { + return map[string]any{ + "id": m.ID.String(), + "chat_id": m.ChatID.String(), + "sender_id": m.SenderID.String(), + "text": m.Text, + "created_at": formatTime(m.CreatedAt), + } +} + +func pageDTO(items []any, next *store.PageCursor) map[string]any { + var cursor any + if next != nil { + cursor = encodeCursor(next) + } + if items == nil { + items = []any{} + } + return map[string]any{"items": items, "next_cursor": cursor} +} + +func formatTime(t time.Time) string { + return t.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z") +} + +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + enc := json.NewEncoder(w) + enc.SetEscapeHTML(false) + _ = enc.Encode(v) +} + +func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) { + rid, _ := r.Context().Value(requestIDKey).(string) + if rid == "" { + rid = w.Header().Get("X-Request-Id") + } + writeJSON(w, status, map[string]any{ + "error": map[string]any{ + "code": code, + "message": message, + "request_id": rid, + }, + }) +} + +func writeAuthError(w http.ResponseWriter, r *http.Request, challenge string) { + w.Header().Set("WWW-Authenticate", challenge) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "authentication required") +} + +// writeStoreErr прячет текст драйвера. fallbackStatus используется для ожидаемой доменной ошибки. +func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error, fallbackStatus int, fallbackCode, fallbackMessage string) { + switch { + case errors.Is(err, store.ErrUnavailable): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + case errors.Is(err, store.ErrConflict) && fallbackStatus != 0: + writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage) + case errors.Is(err, store.ErrNotFound) && fallbackStatus != 0: + if fallbackCode == "unauthorized" { + writeAuthError(w, r, challengeBearer) + return + } + writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage) + case errors.Is(err, store.ErrInvalidCursor): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor") + default: + if errors.Is(err, store.ErrConflict) { + writeError(w, r, http.StatusConflict, "conflict", "username already taken") + return + } + // В лог — только тип, без SQL и без текста, который драйвер мог вложить в ошибку. + log.Printf("request_id=%s store_error_type=%T", requestID(r), err) + writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error") + } +} + +func requestID(r *http.Request) string { + rid, _ := r.Context().Value(requestIDKey).(string) + return rid +} diff --git a/internal/auth/password.go b/internal/auth/password.go new file mode 100644 index 00000000..fb798dba --- /dev/null +++ b/internal/auth/password.go @@ -0,0 +1,110 @@ +// Package auth хранит пароли через Argon2id. +// +// bcrypt отвергнут: библиотека молча режет пароль на 72 байта, а контракт +// разрешает до 128 Unicode code points, включая символы вне ASCII. +// Argon2id принимает пароль целиком. Параметры — интерактивные, не «серверные» +// на сотни миллисекунд: smoke создаёт несколько пользователей подряд. +package auth + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + argonTime = 2 + argonMemory = 19 * 1024 // KiB, около 19 MiB + argonThreads = 1 + argonKeyLen = 32 + argonSaltLen = 16 +) + +// Hasher умеет хешировать и проверять. dummy — хеш случайного пароля, +// чтобы отсутствующий username занимал примерно столько же CPU, сколько неверный пароль. +type Hasher struct { + dummy string +} + +// NewHasher готовит dummy-хеш один раз на процесс. +func NewHasher() (*Hasher, error) { + dummy, err := Hash(randomPassword()) + if err != nil { + return nil, err + } + return &Hasher{dummy: dummy}, nil +} + +// Hash возвращает PHC-строку. Её пишем в users.password_hash. +func Hash(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", err + } + sum := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s", + argonMemory, argonTime, argonThreads, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(sum), + ), nil +} + +// Verify сравнивает пароль с PHC-строкой. При битой строке возвращает false, не панику. +func (h *Hasher) Verify(encoded, password string) bool { + if encoded == "" { + encoded = h.dummy + } + ok, err := verify(encoded, password) + if err != nil { + // Всё равно тратим время dummy-проверки, чтобы ветка ошибки не была мгновенной. + _, _ = verify(h.dummy, password) + return false + } + return ok +} + +// Burn тратит время проверки, когда пользователя нет. Результат всегда false. +func (h *Hasher) Burn(password string) { + _, _ = verify(h.dummy, password) +} + +func verify(encoded, password string) (bool, error) { + parts := strings.Split(encoded, "$") + // ["", "argon2id", "v=19", "m=..,t=..,p=..", salt, hash] + if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" { + return false, fmt.Errorf("bad hash") + } + var memory uint32 + var timeCost uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil { + return false, err + } + if memory != argonMemory || timeCost != argonTime || threads != argonThreads { + return false, fmt.Errorf("unexpected argon2 parameters") + } + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return false, err + } + want, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return false, err + } + got := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, uint32(len(want))) + // ConstantTimeCompare не даёт выйти на первом несовпавшем байте. + if subtle.ConstantTimeCompare(got, want) != 1 { + return false, nil + } + return true, nil +} + +func randomPassword() string { + buf := make([]byte, 24) + _, _ = rand.Read(buf) + return base64.RawStdEncoding.EncodeToString(buf) +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..4fdb9331 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,84 @@ +// Package config читает настройки процесса из окружения. +// +// Прямые URL (DATABASE_URL, REDIS_URL) удобны в Compose. +// Вариант *_FILE из .env.example нужен, если секрет смонтирован файлом: +// тогда в переменной лежит путь, а не сам секрет. +package config + +import ( + "fmt" + "os" + "strconv" + "strings" + "time" +) + +// Config — всё, что процесс обязан знать до открытия соединений. +type Config struct { + Host string + Port int + Env string + DatabaseURL string + RedisURL string + SessionTTL time.Duration +} + +// Load собирает Config. Пустой URL без файла — ошибка запуска, а не тихий дефолт на чужой хост. +func Load() (Config, error) { + cfg := Config{ + Host: getenv("APP_HOST", "0.0.0.0"), + Env: getenv("APP_ENV", "lab"), + } + port, err := strconv.Atoi(getenv("APP_PORT", "8080")) + if err != nil || port < 1 || port > 65535 { + return cfg, fmt.Errorf("invalid APP_PORT") + } + cfg.Port = port + + ttlSec, err := strconv.Atoi(getenv("SESSION_TTL_SECONDS", "3600")) + if err != nil || ttlSec < 1 || ttlSec > 7*24*3600 { + return cfg, fmt.Errorf("invalid SESSION_TTL_SECONDS") + } + cfg.SessionTTL = time.Duration(ttlSec) * time.Second + + cfg.DatabaseURL, err = getenvOrFile("DATABASE_URL", "DATABASE_URL_FILE") + if err != nil { + return cfg, err + } + cfg.RedisURL, err = getenvOrFile("REDIS_URL", "CACHE_URL_FILE") + if err != nil { + return cfg, err + } + return cfg, nil +} + +// Addr — адрес Listen, обычно 0.0.0.0:8080 внутри контейнера. +func (c Config) Addr() string { + return fmt.Sprintf("%s:%d", c.Host, c.Port) +} + +func getenv(key, fallback string) string { + if v := strings.TrimSpace(os.Getenv(key)); v != "" { + return v + } + return fallback +} + +func getenvOrFile(directKey, fileKey string) (string, error) { + if v := strings.TrimSpace(os.Getenv(directKey)); v != "" { + return v, nil + } + path := strings.TrimSpace(os.Getenv(fileKey)) + if path == "" { + return "", fmt.Errorf("set %s or %s", directKey, fileKey) + } + b, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("read %s: %w", fileKey, err) + } + v := strings.TrimSpace(string(b)) + if v == "" { + return "", fmt.Errorf("%s is empty", fileKey) + } + return v, nil +} diff --git a/internal/session/redis.go b/internal/session/redis.go new file mode 100644 index 00000000..ee6d98d2 --- /dev/null +++ b/internal/session/redis.go @@ -0,0 +1,135 @@ +// Package session хранит opaque Bearer-сессии в Redis. +// +// PostgreSQL остаётся источником истины для пользователей и сообщений. +// Сессия — отдельная роль: случайный токен, срок жизни SESSION_TTL_SECONDS и отзыв. +// В Redis лежит не сам токен, а его SHA-256: дамп AOF не содержит значение, +// которое клиент предъявляет в Authorization. +// +// TTL ключа равен оставшемуся сроку сессии. Рестарт API его не продлевает. +// Рестарт Redis сессию сохраняет только потому, что включён AOF на volume. +package session + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "strings" + "time" + + "github.com/google/uuid" + "github.com/redis/go-redis/v9" +) + +var ( + ErrUnauthorized = errors.New("unauthorized") + ErrUnavailable = errors.New("unavailable") +) + +// Store — клиент Redis с короткими таймаутами. +type Store struct { + client *redis.Client + ttl time.Duration +} + +// Open разбирает redis:// URL. Пароль в лог не пишется. +func Open(redisURL string, ttl time.Duration) (*Store, error) { + opt, err := redis.ParseURL(redisURL) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + opt.DialTimeout = 500 * time.Millisecond + opt.ReadTimeout = 500 * time.Millisecond + opt.WriteTimeout = 500 * time.Millisecond + opt.PoolSize = 20 + client := redis.NewClient(opt) + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := client.Ping(ctx).Err(); err != nil { + _ = client.Close() + return nil, err + } + return &Store{client: client, ttl: ttl}, nil +} + +// Close закрывает пул при остановке процесса. +func (s *Store) Close() error { + return s.client.Close() +} + +// Ping — готовность кэша сессий. Недоступный Redis не означает «анонимный доступ». +func (s *Store) Ping(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond) + defer cancel() + if err := s.client.Ping(ctx).Err(); err != nil { + return ErrUnavailable + } + return nil +} + +// Issue выпускает 256 бит случайности (32 байта) и кладёт сессию с TTL. +// Наружу уходит hex (64 символа). В Redis — только хеш. +func (s *Store) Issue(ctx context.Context, userID uuid.UUID) (token string, expiresAt time.Time, err error) { + buf := make([]byte, 32) + if _, err = rand.Read(buf); err != nil { + return "", time.Time{}, err + } + token = hex.EncodeToString(buf) + expiresAt = time.Now().UTC().Add(s.ttl).Truncate(time.Millisecond) + value := userID.String() + "|" + expiresAt.Format(time.RFC3339Nano) + ctx, cancel := context.WithTimeout(ctx, time.Second) + defer cancel() + if err = s.client.Set(ctx, key(token), value, time.Until(expiresAt)).Err(); err != nil { + return "", time.Time{}, ErrUnavailable + } + return token, expiresAt, nil +} + +// Lookup возвращает владельца живой сессии. +// Промах и истёкший срок — ErrUnauthorized. Сбой Redis — ErrUnavailable (HTTP 503). +func (s *Store) Lookup(ctx context.Context, token string) (uuid.UUID, error) { + ctx, cancel := context.WithTimeout(ctx, time.Second) + defer cancel() + raw, err := s.client.Get(ctx, key(token)).Result() + if errors.Is(err, redis.Nil) { + return uuid.Nil, ErrUnauthorized + } + if err != nil { + return uuid.Nil, ErrUnavailable + } + userPart, expPart, ok := strings.Cut(raw, "|") + if !ok { + return uuid.Nil, ErrUnauthorized + } + exp, err := time.Parse(time.RFC3339Nano, expPart) + if err != nil || !exp.After(time.Now()) { + _ = s.client.Del(ctx, key(token)).Err() + return uuid.Nil, ErrUnauthorized + } + id, err := uuid.Parse(userPart) + if err != nil { + return uuid.Nil, ErrUnauthorized + } + return id, nil +} + +// Revoke удаляет текущую сессию. Повторный отзыв — это уже отсутствие ключа. +func (s *Store) Revoke(ctx context.Context, token string) error { + ctx, cancel := context.WithTimeout(ctx, time.Second) + defer cancel() + n, err := s.client.Del(ctx, key(token)).Result() + if err != nil { + return ErrUnavailable + } + if n == 0 { + return ErrUnauthorized + } + return nil +} + +func key(token string) string { + sum := sha256.Sum256([]byte(token)) + return "sess:" + hex.EncodeToString(sum[:]) +} diff --git a/internal/store/migrate.go b/internal/store/migrate.go new file mode 100644 index 00000000..bbeeb2a7 --- /dev/null +++ b/internal/store/migrate.go @@ -0,0 +1,84 @@ +package store + +import ( + "context" + "embed" + "fmt" + "sort" + "strings" + "time" +) + +//go:embed migrations/*.sql +var migrationFS embed.FS + +// Migrate применяет встроенные SQL-файлы по одному разу. +// Повторный старт процесса не создаёт вторую копию строк: версия пишется в schema_migrations. +func (s *Store) Migrate(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, 30*time.Second) + defer cancel() + if _, err := s.pool.Exec(ctx, ` + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + )`); err != nil { + return fmt.Errorf("schema_migrations: %w", err) + } + entries, err := migrationFS.ReadDir("migrations") + if err != nil { + return err + } + names := make([]string, 0, len(entries)) + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") { + names = append(names, e.Name()) + } + } + sort.Strings(names) + for _, name := range names { + var exists bool + if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)`, name).Scan(&exists); err != nil { + return err + } + if exists { + continue + } + body, err := migrationFS.ReadFile("migrations/" + name) + if err != nil { + return err + } + tx, err := s.pool.Begin(ctx) + if err != nil { + return err + } + // pgx в extended protocol не выполняет несколько команд одним Exec. + for _, stmt := range splitSQL(string(body)) { + if _, err := tx.Exec(ctx, stmt); err != nil { + _ = tx.Rollback(ctx) + return fmt.Errorf("migrate %s: %w", name, err) + } + } + if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, name); err != nil { + _ = tx.Rollback(ctx) + return err + } + if err := tx.Commit(ctx); err != nil { + return err + } + } + return nil +} + +// splitSQL делит файл миграции по ';'. В этих файлах нет строк с точкой с запятой внутри литералов. +func splitSQL(body string) []string { + parts := strings.Split(body, ";") + out := make([]string, 0, len(parts)) + for _, part := range parts { + stmt := strings.TrimSpace(part) + if stmt == "" { + continue + } + out = append(out, stmt) + } + return out +} diff --git a/internal/store/migrations/001_init.sql b/internal/store/migrations/001_init.sql new file mode 100644 index 00000000..205bc6a7 --- /dev/null +++ b/internal/store/migrations/001_init.sql @@ -0,0 +1,49 @@ +-- Схема lab2. PostgreSQL — источник истины для пользователей, чатов и сообщений. +-- Сессии здесь намеренно нет: их держит Redis с AOF, TTL не продлевается рестартом API. +-- Повторный запуск безопасен: все объекты создаются через IF NOT EXISTS. + +CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + -- Argon2id PHC-строка. Не SHA-256 и не plaintext. Наружу не отдаётся. + password_hash text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT users_username_unique UNIQUE (username) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL +); + +-- Составной первичный ключ не даёт вставить участника дважды. +-- Внешние ключи не дают сослаться на несуществующего пользователя или чат. +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id) +); + +-- Список чатов пользователя начинается с фильтра «где я участник». +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id); + +CREATE TABLE IF NOT EXISTS messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL +); + +-- Keyset истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id. +-- Составной индекс покрывает и фильтр, и порядок. Слабый индекс только по chat_id +-- заставил бы сортировать историю чата. Его нет в продовой схеме, он появляется +-- лишь на время эксперимента трека 2. +CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id); diff --git a/internal/store/store.go b/internal/store/store.go new file mode 100644 index 00000000..121ce7ec --- /dev/null +++ b/internal/store/store.go @@ -0,0 +1,496 @@ +// Package store — пользователи, чаты и сообщения в PostgreSQL. +// +// Источник истины lab2 — только эти таблицы. Память процесса после рестарта пуста, +// поэтому ни одного map с данными здесь нет. Каждый запрос параметризован ($1, $2): +// текст сообщения не склеивается в SQL. +// +// Создание чата — одна транзакция: строка чата и все участники фиксируются вместе +// либо не фиксируются вообще. Уникальность username обеспечивает UNIQUE, а не проверка +// «сначала SELECT, потом INSERT» (та проверка проигрывает гонке). +package store + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "mtusi2026lab2/internal/auth" +) + +const queryTimeout = 3 * time.Second + +// Ошибки домена. HTTP-слой переводит их в коды контракта и не показывает SQL. +var ( + ErrConflict = errors.New("conflict") + ErrNotFound = errors.New("not found") + ErrInvalidCursor = errors.New("invalid cursor") + ErrUnavailable = errors.New("unavailable") +) + +// User — публичные поля пользователя. Hash пароля в эту структуру не попадает. +type User struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} + +// Chat — чат и явный состав участников. +type Chat struct { + ID uuid.UUID + Title string + MemberIDs []uuid.UUID + CreatedAt time.Time +} + +// Message — одно подтверждённое сообщение. sender_id назначает сервер. +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + CreatedAt time.Time +} + +// PageCursor — позиция keyset. Клиент видит только opaque-строку в пакете api. +type PageCursor struct { + CreatedAt time.Time + ID uuid.UUID + Scope string +} + +// Store — пул соединений. Пул ограничен, у каждого запроса свой таймаут. +type Store struct { + pool *pgxpool.Pool + hasher *auth.Hasher +} + +// Open поднимает пул. ConnectTimeout короткий, чтобы недоступная БД быстро стала 503, +// а не висела до клиентского таймаута теста. +func Open(ctx context.Context, databaseURL string, hasher *auth.Hasher) (*Store, error) { + cfg, err := pgxpool.ParseConfig(databaseURL) + if err != nil { + return nil, fmt.Errorf("parse database url: %w", err) + } + cfg.MaxConns = 10 + cfg.MinConns = 1 + cfg.MaxConnLifetime = 30 * time.Minute + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.HealthCheckPeriod = 30 * time.Second + cfg.ConnConfig.ConnectTimeout = 2 * time.Second + cfg.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error { + // UTC, чтобы timestamptz читался так же, как мы его записали. + // statement_timeout обрывает запрос, который внезапно решил сканировать всё. + _, err := conn.Exec(ctx, `SET TIME ZONE 'UTC'; SET statement_timeout = '3s'`) + return err + } + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, err + } + pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, err + } + return &Store{pool: pool, hasher: hasher}, nil +} + +// Close освобождает соединения при остановке процесса. +func (s *Store) Close() { + s.pool.Close() +} + +// Ping — проверка для /health/ready. Ошибка здесь значит «не готов», не «жив». +func (s *Store) Ping(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond) + defer cancel() + if err := s.pool.Ping(ctx); err != nil { + return ErrUnavailable + } + return nil +} + +// CreateUser пишет пользователя. Повтор username → ErrConflict благодаря UNIQUE. +func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*User, error) { + hash, err := auth.Hash(password) + if err != nil { + return nil, err + } + u := &User{ + ID: uuid.New(), + Username: username, + DisplayName: displayName, + CreatedAt: nowUTC(), + } + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + _, err = s.pool.Exec(ctx, ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5)`, + u.ID, u.Username, u.DisplayName, hash, u.CreatedAt) + if err != nil { + return nil, mapWriteErr(err) + } + return u, nil +} + +// Authenticate проверяет Basic-логин. Нет пользователя и неверный пароль +// выглядят одинаково: оба дают false без отдельной ошибки «такого логина нет». +func (s *Store) Authenticate(ctx context.Context, username, password string) (*User, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var u User + var hash string + err := s.pool.QueryRow(ctx, ` + SELECT id, username, display_name, created_at, password_hash + FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash) + if errors.Is(err, pgx.ErrNoRows) { + s.hasher.Burn(password) + return nil, ErrNotFound + } + if err != nil { + return nil, mapWriteErr(err) + } + if !s.hasher.Verify(hash, password) { + return nil, ErrNotFound + } + return &u, nil +} + +// GetUser нужен, чтобы ответ /users/me совпал с объектом из регистрации. +func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (*User, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var u User + err := s.pool.QueryRow(ctx, ` + SELECT id, username, display_name, created_at FROM users WHERE id = $1`, id). + Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, mapWriteErr(err) + } + return &u, nil +} + +// CreateChat атомарно создаёт чат и состав. Неизвестный участник откатывает всё: +// в таблице chats не остаётся «пустой» строки без полного состава. +func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []uuid.UUID) (*Chat, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + tx, err := s.pool.Begin(ctx) + if err != nil { + return nil, mapWriteErr(err) + } + defer func() { _ = tx.Rollback(ctx) }() + + chat := &Chat{ + ID: uuid.New(), + Title: title, + MemberIDs: append([]uuid.UUID(nil), memberIDs...), + CreatedAt: nowUTC(), + } + if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, + chat.ID, chat.Title, chat.CreatedAt); err != nil { + return nil, mapWriteErr(err) + } + for _, uid := range memberIDs { + // INSERT ... SELECT вставит 0 строк, если пользователя нет, и не нарушит FK. + tag, err := tx.Exec(ctx, ` + INSERT INTO chat_members (chat_id, user_id) + SELECT $1, id FROM users WHERE id = $2`, chat.ID, uid) + if err != nil { + return nil, mapWriteErr(err) + } + if tag.RowsAffected() != 1 { + return nil, ErrNotFound + } + } + if err := tx.Commit(ctx); err != nil { + return nil, mapWriteErr(err) + } + return chat, nil +} + +// GetChat возвращает чат только участнику. Чужому — ErrNotFound (HTTP 404, не 403). +func (s *Store) GetChat(ctx context.Context, chatID, userID uuid.UUID) (*Chat, error) { + if err := s.ensureMember(ctx, chatID, userID); err != nil { + return nil, err + } + return s.loadChat(ctx, chatID) +} + +// ListChats — keyset по (created_at, id) только среди чатов этого пользователя. +func (s *Store) ListChats(ctx context.Context, userID uuid.UUID, limit int, after *PageCursor) ([]Chat, *PageCursor, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var ( + rows pgx.Rows + err error + ) + if after == nil { + rows, err = s.pool.Query(ctx, ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1 + ORDER BY c.created_at, c.id + LIMIT $2`, userID, limit+1) + } else { + rows, err = s.pool.Query(ctx, ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1 + AND (c.created_at, c.id) > ($2, $3) + ORDER BY c.created_at, c.id + LIMIT $4`, userID, after.CreatedAt, after.ID, limit+1) + } + if err != nil { + return nil, nil, mapWriteErr(err) + } + defer rows.Close() + + var items []Chat + for rows.Next() { + var c Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, nil, mapWriteErr(err) + } + items = append(items, c) + } + if err := rows.Err(); err != nil { + return nil, nil, mapWriteErr(err) + } + next, items := trimPage(items, limit, func(c Chat) (time.Time, uuid.UUID) { + return c.CreatedAt, c.ID + }) + for i := range items { + members, err := s.memberIDs(ctx, items[i].ID) + if err != nil { + return nil, nil, err + } + items[i].MemberIDs = members + } + var cursor *PageCursor + if next { + last := items[len(items)-1] + cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID} + } + return items, cursor, nil +} + +// CreateMessage пишет сообщение только если отправитель состоит в чате. +// Подтверждение — это COMMIT строки. Следующее чтение видит её без кэша истории. +func (s *Store) CreateMessage(ctx context.Context, chatID, senderID uuid.UUID, text string) (*Message, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + msg := &Message{ + ID: uuid.New(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: nowUTC(), + } + tag, err := s.pool.Exec(ctx, ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT $1, $2, $3, $4, $5 + WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3 + )`, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt) + if err != nil { + return nil, mapWriteErr(err) + } + if tag.RowsAffected() != 1 { + return nil, ErrNotFound + } + return msg, nil +} + +// ListMessages — keyset по индексу messages_history_idx. Берём limit+1 строку, +// чтобы next_cursor был null, когда следующей записи уже нет. +func (s *Store) ListMessages(ctx context.Context, chatID, userID uuid.UUID, limit int, after *PageCursor) ([]Message, *PageCursor, error) { + if err := s.ensureMember(ctx, chatID, userID); err != nil { + return nil, nil, err + } + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var ( + rows pgx.Rows + err error + ) + if after == nil { + rows, err = s.pool.Query(ctx, ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + LIMIT $2`, chatID, limit+1) + } else { + rows, err = s.pool.Query(ctx, ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT $4`, chatID, after.CreatedAt, after.ID, limit+1) + } + if err != nil { + return nil, nil, mapWriteErr(err) + } + defer rows.Close() + var items []Message + for rows.Next() { + var m Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, nil, mapWriteErr(err) + } + items = append(items, m) + } + if err := rows.Err(); err != nil { + return nil, nil, mapWriteErr(err) + } + hasNext, items := trimPage(items, limit, func(m Message) (time.Time, uuid.UUID) { + return m.CreatedAt, m.ID + }) + var cursor *PageCursor + if hasNext { + last := items[len(items)-1] + cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID} + } + return items, cursor, nil +} + +// ChatExistsForTitle помогает тесту отката: после ошибки создания чата строки нет. +func (s *Store) CountChatsByTitle(ctx context.Context, title string) (int, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var n int + err := s.pool.QueryRow(ctx, `SELECT count(*) FROM chats WHERE title = $1`, title).Scan(&n) + if err != nil { + return 0, mapWriteErr(err) + } + return n, nil +} + +func (s *Store) ensureMember(ctx context.Context, chatID, userID uuid.UUID) error { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var one int + err := s.pool.QueryRow(ctx, ` + SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&one) + if errors.Is(err, pgx.ErrNoRows) { + return ErrNotFound + } + if err != nil { + return mapWriteErr(err) + } + return nil +} + +func (s *Store) loadChat(ctx context.Context, chatID uuid.UUID) (*Chat, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var c Chat + err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, chatID). + Scan(&c.ID, &c.Title, &c.CreatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, mapWriteErr(err) + } + c.MemberIDs, err = s.memberIDs(ctx, chatID) + if err != nil { + return nil, err + } + return &c, nil +} + +func (s *Store) memberIDs(ctx context.Context, chatID uuid.UUID) ([]uuid.UUID, error) { + rows, err := s.pool.Query(ctx, ` + SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY user_id`, chatID) + if err != nil { + return nil, mapWriteErr(err) + } + defer rows.Close() + var ids []uuid.UUID + for rows.Next() { + var id uuid.UUID + if err := rows.Scan(&id); err != nil { + return nil, mapWriteErr(err) + } + ids = append(ids, id) + } + return ids, mapWriteErr(rows.Err()) +} + +func trimPage[T any](items []T, limit int, _ func(T) (time.Time, uuid.UUID)) (bool, []T) { + if len(items) > limit { + return true, items[:limit] + } + return false, items +} + +func nowUTC() time.Time { + // Миллисекунда — точность, которую мы же и печатаем в JSON. + return time.Now().UTC().Truncate(time.Millisecond) +} + +func mapWriteErr(err error) error { + if err == nil { + return nil + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { + return ErrConflict + } + if errors.Is(err, context.DeadlineExceeded) || isConn(err) { + return ErrUnavailable + } + return err +} + +func isConn(err error) bool { + msg := err.Error() + // Не логируем и не возвращаем клиенту эту строку. Здесь только классификация. + switch { + case errors.Is(err, pgx.ErrNoRows): + return false + default: + if stringsContains(msg, "connection refused") || + stringsContains(msg, "failed to connect") || + stringsContains(msg, "conn closed") || + stringsContains(msg, "broken pipe") || + stringsContains(msg, "connection reset") || + stringsContains(msg, "SQLSTATE 57P01") || + stringsContains(msg, "SQLSTATE 08006") || + stringsContains(msg, "SQLSTATE 08001") { + return true + } + } + return false +} + +func stringsContains(s, sub string) bool { + return len(s) >= len(sub) && (s == sub || len(sub) == 0 || + (func() bool { return contains(s, sub) })()) +} + +func contains(s, sub string) bool { + for i := 0; i+len(sub) <= len(s); i++ { + if s[i:i+len(sub)] == sub { + return true + } + } + return false +} diff --git a/scripts/check_deps.sh b/scripts/check_deps.sh new file mode 100755 index 00000000..39d173a1 --- /dev/null +++ b/scripts/check_deps.sh @@ -0,0 +1,42 @@ +#!/bin/sh +# Показывает, что остановленный Redis или PostgreSQL даёт 503, а не успешный анонимный ответ. +# Контейнеры в конце снова запущены. Токены в вывод не попадают. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +BASE=${BASE_URL:-http://127.0.0.1:8080} + +ready() { + curl -s -o /tmp/lab2-ready-body -w "%{http_code}" "$BASE/health/ready" || echo "curl_fail" +} + +echo "ready_before=$(ready)" +echo "stop redis" +docker compose --env-file .env stop redis +sleep 1 +echo "ready_redis_down=$(ready)" +echo "start redis" +docker compose --env-file .env start redis +for _ in 1 2 3 4 5 6 7 8 9 10; do + code=$(ready) + if [ "$code" = "200" ]; then + break + fi + sleep 1 +done +echo "ready_redis_back=$code" + +echo "stop postgres" +docker compose --env-file .env stop postgres +sleep 1 +echo "ready_postgres_down=$(ready)" +echo "start postgres" +docker compose --env-file .env start postgres +for _ in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do + code=$(ready) + if [ "$code" = "200" ]; then + break + fi + sleep 1 +done +echo "ready_postgres_back=$code" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..cace833e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,19 @@ +#!/bin/sh +# Перезапуск API и обоих хранилищ без удаления volumes и без повторного seed. +# Тест сохранности сам дождётся /health/ready. Скрипт только инициирует restart. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +# Сначала хранилища, затем API. API ещё и сам ждёт порт БД до 45 секунд, +# если restart поднимет его раньше, чем Postgres примет соединения. +docker compose --env-file .env restart postgres redis +i=0 +while [ "$i" -lt 40 ]; do + if docker compose --env-file .env exec -T postgres pg_isready -U "${POSTGRES_USER:-messenger}" -d "${POSTGRES_DB:-messenger}" >/dev/null 2>&1 \ + && docker compose --env-file .env exec -T redis redis-cli ping >/dev/null 2>&1; then + break + fi + i=$((i + 1)) + sleep 1 +done +docker compose --env-file .env up -d --no-deps --no-build api diff --git a/scripts/run_track2.sh b/scripts/run_track2.sh new file mode 100755 index 00000000..f5305300 --- /dev/null +++ b/scripts/run_track2.sh @@ -0,0 +1,34 @@ +#!/bin/sh +# Трек 2: 100k сообщений, два плана запроса, pg_dump и сверка восстановления. +# Дамп остаётся в /tmp контейнера и в git не попадает. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +if [ -f .env ]; then + set -a + # shellcheck disable=SC1091 + . ./.env + set +a +fi +USER=${POSTGRES_USER:-messenger} +PASS=${POSTGRES_PASSWORD:-messenger} +export PATH="/opt/homebrew/bin:/usr/bin:/bin:$PATH" + +docker compose --env-file .env exec -T postgres psql -U "$USER" -d postgres -v ON_ERROR_STOP=1 -c "SELECT 1" >/dev/null +docker compose --env-file .env exec -T postgres createdb -U "$USER" track2 2>/dev/null || true +docker compose --env-file .env exec -T postgres createdb -U "$USER" track2_restore 2>/dev/null || true + +SRC="postgres://${USER}:${PASS}@127.0.0.1:5432/track2?sslmode=disable" +DST="postgres://${USER}:${PASS}@127.0.0.1:5432/track2_restore?sslmode=disable" + +go run ./cmd/track2 -mode prepare -database-url "$SRC" +go run ./cmd/track2 -mode explain -database-url "$SRC" -out evidence/track2 + +docker compose --env-file .env exec -T postgres pg_dump -U "$USER" -d track2 -Fc -f /tmp/track2.dump +docker compose --env-file .env exec -T postgres psql -U "$USER" -d postgres -v ON_ERROR_STOP=1 \ + -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'track2_restore' AND pid <> pg_backend_pid();" \ + -c "DROP DATABASE IF EXISTS track2_restore" \ + -c "CREATE DATABASE track2_restore" +docker compose --env-file .env exec -T postgres pg_restore -U "$USER" -d track2_restore --no-owner --exit-on-error /tmp/track2.dump +go run ./cmd/track2 -mode verify -database-url "$SRC" -restore-url "$DST" -out evidence/track2 +echo "track2 ok" diff --git a/student-tests/api_test.go b/student-tests/api_test.go new file mode 100644 index 00000000..c0f9c06f --- /dev/null +++ b/student-tests/api_test.go @@ -0,0 +1,433 @@ +// Собственные проверки lab2. Им нужен уже поднятый PostgreSQL и Redis +// (docker compose up), потому что контракт требует настоящую БД, а не sqlmock. +// +// Каждый тест пишет в лог, что именно проверяет и какой статус получил. +package studenttests + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "os" + "strings" + "sync" + "testing" + "time" + + "github.com/google/uuid" + + "mtusi2026lab2/internal/api" + "mtusi2026lab2/internal/auth" + "mtusi2026lab2/internal/session" + "mtusi2026lab2/internal/store" +) + +var ( + sharedStore *store.Store + sharedSessions *session.Store + sharedRedisURL string +) + +func TestMain(m *testing.M) { + ctx := context.Background() + dsn := getenv("DATABASE_URL", "postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable") + sharedRedisURL = getenv("REDIS_URL", "redis://127.0.0.1:6379/0") + hasher, err := auth.NewHasher() + if err != nil { + fmt.Fprintln(os.Stderr, "hasher:", err) + os.Exit(1) + } + sharedStore, err = store.Open(ctx, dsn, hasher) + if err != nil { + fmt.Fprintln(os.Stderr, "postgres:", err) + fmt.Fprintln(os.Stderr, "подсказка: docker compose --env-file .env up -d --build") + os.Exit(1) + } + defer sharedStore.Close() + if err := sharedStore.Migrate(ctx); err != nil { + fmt.Fprintln(os.Stderr, "migrate:", err) + os.Exit(1) + } + // Повтор миграции не должен падать и не должен дублировать данные. + if err := sharedStore.Migrate(ctx); err != nil { + fmt.Fprintln(os.Stderr, "migrate second:", err) + os.Exit(1) + } + sharedSessions, err = session.Open(sharedRedisURL, time.Hour) + if err != nil { + fmt.Fprintln(os.Stderr, "redis:", err) + os.Exit(1) + } + defer sharedSessions.Close() + os.Exit(m.Run()) +} + +func TestMalformedJSONAndValidation(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "битый JSON, лишнее поле, пустой текст, чужой чат") + + status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, "{") + logResult(t, status, body) + if status != http.StatusBadRequest || !strings.Contains(body, "invalid_request") { + t.Fatalf("malformed json: status=%d body=%s", status, body) + } + + status, body = do(t, srv, http.MethodPost, "/api/v1/users", nil, + `{"username":"abc","display_name":"Имя","password":"correct-horse-1","extra":1}`) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("extra field: status=%d", status) + } + + user := register(t, srv, "ok_user") + token := login(t, srv, user.username, user.password) + chat := createChat(t, srv, token, user.id, "Чат проверки") + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{"Authorization": "Bearer " + token}, `{"text":" "}`) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("blank message: status=%d", status) + } + + outsider := register(t, srv, "outsider") + outTok := login(t, srv, outsider.username, outsider.password) + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{"Authorization": "Bearer " + outTok}, `{"text":"чужое"}`) + logResult(t, status, body) + if status != http.StatusNotFound { + t.Fatalf("foreign chat: status=%d body=%s", status, body) + } + logOK(t, "валидация JSON, пустого текста и чужого чата") +} + +func TestWrongPasswordLogoutAndIgnoredUserHeader(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "неверный пароль, Basic на бизнес-методе, X-User-Id, logout") + user := register(t, srv, "auth_user") + other := register(t, srv, "auth_other") + + status, body, hdr := doRaw(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{ + "Authorization": "Basic " + basic(user.username, "wrong-password-1"), + }, "") + logResult(t, status, body) + if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Basic") { + t.Fatalf("wrong password: status=%d www=%q", status, hdr.Get("WWW-Authenticate")) + } + + token := login(t, srv, user.username, user.password) + status, body, hdr = doRaw(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{ + "Authorization": "Basic " + basic(user.username, user.password), + }, "") + logResult(t, status, body) + if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Bearer") { + t.Fatalf("basic on business endpoint: status=%d www=%q", status, hdr.Get("WWW-Authenticate")) + } + + status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"X-User-Id": user.id}, "") + logResult(t, status, body) + if status != http.StatusUnauthorized { + t.Fatalf("X-User-Id alone: status=%d", status) + } + + status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{ + "Authorization": "Bearer " + token, + "X-User-Id": other.id, + }, "") + logResult(t, status, body) + if status != http.StatusOK || !strings.Contains(body, user.id) || strings.Contains(body, other.id) { + t.Fatalf("X-User-Id overrode bearer: status=%d body=%s", status, body) + } + + status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "") + t.Logf("logout status=%d", status) + if status != http.StatusNoContent { + t.Fatalf("logout status=%d", status) + } + status, _ = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "") + if status != http.StatusUnauthorized { + t.Fatalf("token still valid after logout: %d", status) + } + status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "") + if status != http.StatusUnauthorized { + t.Fatalf("second logout status=%d", status) + } + logOK(t, "пароль, заголовки и отзыв сессии") +} + +func TestSessionExpiry(t *testing.T) { + srv := newAPI(t, 2*time.Second) + defer srv.Close() + logStep(t, "SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается") + user := register(t, srv, "ttl_user") + token := login(t, srv, user.username, user.password) + time.Sleep(2500 * time.Millisecond) + status, body := do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "") + logResult(t, status, body) + if status != http.StatusUnauthorized { + t.Fatalf("expired token status=%d body=%s", status, body) + } + logOK(t, "истёкшая сессия отклонена") +} + +func TestDuplicateUsernameRace(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + name := "race_" + uuid.NewString()[:8] + logStep(t, "8 параллельных регистраций username="+name) + const n = 8 + codes := make([]int, n) + var wg sync.WaitGroup + body := fmt.Sprintf(`{"username":%q,"display_name":"Гонка","password":"correct-horse-1"}`, name) + for i := 0; i < n; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + status, _ := do(t, srv, http.MethodPost, "/api/v1/users", nil, body) + codes[i] = status + }(i) + } + wg.Wait() + ok, conflict := 0, 0 + for _, c := range codes { + switch c { + case http.StatusCreated: + ok++ + case http.StatusConflict: + conflict++ + default: + t.Errorf("unexpected status %d", c) + } + } + t.Logf("created=%d conflict=%d", ok, conflict) + if ok != 1 || conflict != n-1 { + t.Fatalf("race result created=%d conflict=%d", ok, conflict) + } + logOK(t, "UNIQUE username выдержал гонку") +} + +func TestChatCreateRollsBack(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + user := register(t, srv, "roll_user") + token := login(t, srv, user.username, user.password) + title := "rollback-" + uuid.NewString() + missing := uuid.NewString() + logStep(t, "создание чата с несуществующим участником должно откатиться, title="+title) + raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q,%q]}`, title, user.id, missing) + status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("status=%d", status) + } + n, err := sharedStore.CountChatsByTitle(context.Background(), title) + if err != nil { + t.Fatal(err) + } + t.Logf("строк chats с этим title после ошибки: %d", n) + if n != 0 { + t.Fatalf("chat row survived rollback: %d", n) + } + logOK(t, "транзакция создания чата откатилась") +} + +func TestPaginationPages(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "три сообщения, две страницы limit=2, затем последняя") + user := register(t, srv, "page_user") + token := login(t, srv, user.username, user.password) + chat := createChat(t, srv, token, user.id, "Страницы") + auth := map[string]string{"Authorization": "Bearer " + token} + for _, text := range []string{"раз", "два", "три"} { + status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, fmt.Sprintf(`{"text":%q}`, text)) + if status != http.StatusCreated { + t.Fatalf("post message %s: %d %s", text, status, body) + } + } + status, body := do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2", auth, "") + logResult(t, status, body) + page := decode(t, body) + items, _ := page["items"].([]any) + if status != http.StatusOK || len(items) != 2 || page["next_cursor"] == nil { + t.Fatalf("page1: %+v", page) + } + cursor, _ := page["next_cursor"].(string) + status, body = do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2&cursor="+cursor, auth, "") + logResult(t, status, body) + page = decode(t, body) + items, _ = page["items"].([]any) + if len(items) != 1 || page["next_cursor"] != nil { + t.Fatalf("page2: %+v", page) + } + logOK(t, "keyset обошёл историю без зависания cursor") +} + +func TestRedisDownIsNotAnonymous(t *testing.T) { + logStep(t, "закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима") + closed, err := session.Open(sharedRedisURL, time.Hour) + if err != nil { + t.Fatal(err) + } + if err := closed.Close(); err != nil { + t.Fatal(err) + } + srv := httptest.NewServer(api.New(sharedStore, closed).Handler()) + defer srv.Close() + regSrv := newAPI(t, time.Hour) + defer regSrv.Close() + user := register(t, regSrv, "redis_down") + // register() opened another server; login against the closed-redis server. + status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{ + "Authorization": "Basic " + basic(user.username, user.password), + }, "") + logResult(t, status, body) + if status != http.StatusServiceUnavailable { + t.Fatalf("login with dead redis: status=%d body=%s", status, body) + } + status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{ + "Authorization": "Bearer " + strings.Repeat("ab", 32), + }, "") + logResult(t, status, body) + if status != http.StatusServiceUnavailable { + t.Fatalf("bearer with dead redis: status=%d body=%s", status, body) + } + logOK(t, "сбой Redis не стал анонимным доступом") +} + +type account struct { + id string + username string + password string +} + +func newAPI(t *testing.T, ttl time.Duration) *httptest.Server { + t.Helper() + sessions, err := session.Open(sharedRedisURL, ttl) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = sessions.Close() }) + return httptest.NewServer(api.New(sharedStore, sessions).Handler()) +} + +func register(t *testing.T, srv *httptest.Server, prefix string) account { + t.Helper() + username := prefix + "_" + uuid.NewString()[:8] + password := "correct-horse-1" + raw := fmt.Sprintf(`{"username":%q,"display_name":"Студент","password":%q}`, username, password) + status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, raw) + if status != http.StatusCreated { + t.Fatalf("register %s: %d %s", username, status, body) + } + var u struct { + ID string `json:"id"` + } + if err := json.Unmarshal([]byte(body), &u); err != nil { + t.Fatal(err) + } + t.Logf("создан %s id=%s", username, u.ID) + return account{id: u.ID, username: username, password: password} +} + +func login(t *testing.T, srv *httptest.Server, username, password string) string { + t.Helper() + status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{ + "Authorization": "Basic " + basic(username, password), + }, "") + if status != http.StatusCreated { + t.Fatalf("login %s: %d %s", username, status, body) + } + var s struct { + Token string `json:"token"` + } + if err := json.Unmarshal([]byte(body), &s); err != nil { + t.Fatal(err) + } + if len(s.Token) < 32 { + t.Fatalf("token too short: %d", len(s.Token)) + } + t.Logf("сессия выпущена, длина токена=%d (значение не печатаем)", len(s.Token)) + return s.Token +} + +func createChat(t *testing.T, srv *httptest.Server, token, userID, title string) string { + t.Helper() + raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q]}`, title, userID) + status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw) + if status != http.StatusCreated { + t.Fatalf("chat: %d %s", status, body) + } + var c struct { + ID string `json:"id"` + } + if err := json.Unmarshal([]byte(body), &c); err != nil { + t.Fatal(err) + } + return c.ID +} + +func do(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string) { + t.Helper() + status, body, _ := doRaw(t, srv, method, path, headers, raw) + return status, body +} + +func doRaw(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string, http.Header) { + t.Helper() + var rdr io.Reader + if raw != "" { + rdr = bytes.NewBufferString(raw) + } + req, err := http.NewRequest(method, srv.URL+path, rdr) + if err != nil { + t.Fatal(err) + } + if raw != "" && method != http.MethodGet { + 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() + b, _ := io.ReadAll(resp.Body) + return resp.StatusCode, string(b), resp.Header +} + +func decode(t *testing.T, body string) map[string]any { + t.Helper() + var m map[string]any + if err := json.Unmarshal([]byte(body), &m); err != nil { + t.Fatal(err) + } + return m +} + +func basic(user, pass string) string { + return base64.StdEncoding.EncodeToString([]byte(user + ":" + pass)) +} + +func logStep(t *testing.T, msg string) { t.Helper(); t.Logf("→ %s", msg) } +func logOK(t *testing.T, msg string) { t.Helper(); t.Logf("✓ %s", msg) } +func logResult(t *testing.T, status int, body string) { + t.Helper() + if len(body) > 400 { + body = body[:400] + "..." + } + t.Logf("status=%d body=%s", status, body) +} + +func getenv(k, def string) string { + if v := os.Getenv(k); v != "" { + return v + } + return def +}