diff --git a/.env.example b/.env.example index d99d26a2..6d162f97 100644 --- a/.env.example +++ b/.env.example @@ -1,20 +1,40 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +APP_ACCESS_LOG=1 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 -API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 -S3_ENDPOINT=http://s3:9000 -S3_REGION=us-east-1 -S3_BUCKET=messenger-attachments -S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id -S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key + +POSTGRES_USER=messenger +POSTGRES_PASSWORD=messenger +POSTGRES_DB=messenger + +# Внутри сети Compose. Хосту для student-tests — localhost после проброса портов. +DATABASE_URL=postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable +REDIS_URL=redis://redis:6379/0 +SESSION_STORE=redis + +# Число API-реплик за LB. Поднимать: scripts/up.sh или compose --scale api=N +API_REPLICAS=2 +# Лимиты одной API-реплики. +API_CPUS=0.50 +API_MEMORY=256M +# Пул соединений на одну реплику. Суммарно ≈ API_REPLICAS * DB_MAX_CONNS. +DB_MAX_CONNS=5 + +# Лимиты вложений (контракт lab4). MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 + +# MinIO (S3). Root — только для bootstrap (minio-init). API использует app-ключи. +MINIO_ROOT_USER=minioadmin +MINIO_ROOT_PASSWORD=minioadmin-secret +S3_ENDPOINT=minio:9000 +S3_USE_SSL=0 +S3_REGION=us-east-1 +S3_BUCKET=messenger-attachments +S3_ACCESS_KEY_ID=messenger-app +S3_SECRET_ACCESS_KEY=messenger-app-secret +# Grace period reconciler (секунды): свежие orphan/missing не трогаем. +S3_RECONCILE_GRACE_SECONDS=60 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..170f5c01 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,24 @@ +# syntax=docker/dockerfile:1.7 +FROM golang:1.24.2-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 +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/reconcile ./cmd/reconcile +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/s3bootstrap ./cmd/s3bootstrap + +FROM gcr.io/distroless/static-debian12:nonroot +COPY --from=build /out/server /server +COPY --from=build /out/reconcile /reconcile +COPY --from=build /out/s3bootstrap /s3bootstrap +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 5d86d171..9448480d 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,10 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover up down student-test private-bucket concurrent reconcile-demo help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "check: offline structure; validate: full OpenAPI; test: smoke; up/down: compose stand" check: $(PYTHON) scripts/check_contract.py @@ -28,3 +28,23 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +up: + bash scripts/up.sh + +down: + docker compose --env-file .env down + +student-test: + DATABASE_URL=postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable \ + REDIS_URL=redis://127.0.0.1:6379/0 \ + go test ./student-tests/ -count=1 -v + +private-bucket: + bash scripts/check-private-bucket.sh + +concurrent: + bash scripts/concurrent-uploads.sh + +reconcile-demo: + bash scripts/reconcile-demo.sh diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..1bb32a2f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,81 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Белоусов Анатолий Фахраддинович, БПИ2303 +- Целевая оценка; выбранный трек 5: **5, трек 2** (согласованность двух хранилищ / reconciler) +- Commit/PR: ветка `solution/bpi2303-belousov` +- Использованные источники, библиотеки и помощь ИИ: Go `net/http`, `pgx` v5, `go-redis` v9, `minio-go` v7, `madmin-go` v3, `golang.org/x/crypto/argon2`, `google/uuid`; MinIO community-образ `ghcr.io/coollabsio/minio` (официальные `minio/minio` сняты с Docker Hub); HAProxy 2.9; публичные `tests/`; Cursor/Composer. База — реализация lab3. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker, Go 1.24+ (student-tests), Python 3.9+. + +```sh +cp .env.example .env +bash scripts/up.sh +# postgres+redis+minio → s3bootstrap → migrate → API×N → LB :8080 +make test +make student-test +make private-bucket +make concurrent +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +bash scripts/restore-one.sh # после failover +make reconcile-demo # трек 5: dry-run → apply → fresh skip +``` + +Остановка без удаления данных: `docker compose --env-file .env stop`. +Удаление учебных volumes: `docker compose --env-file .env down -v`. + +Образы: сборка `golang:1.24.2-bookworm`, runtime `gcr.io/distroless/static-debian12:nonroot`, PostgreSQL `postgres:16.6`, Redis `redis:7.4.1` (AOF), HAProxy `haproxy:2.9.14-alpine`, MinIO `ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z`. Консоль MinIO не публикуется; API S3 — только `127.0.0.1:9000` для локальной проверки private bucket. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → HAProxy → API×2+ → PostgreSQL (метаданные) + Redis (сессии) + приватный MinIO (байты). + +Вложение: сервер назначает ключ `originals/`; `filename` только в метаданных. Порядок записи — **сначала S3 PUT, потом INSERT**; 201 только после обоих. Ошибка INSERT → немедленный Delete объекта; если Delete не удался — orphan подберёт reconciler после grace. + +Загрузка: spool во временный файл (не `ReadAll`), лимит `MaxUploadBytes+1`, MIME по содержимому, размеры PNG/JPEG из заголовка до декодирования пикселей, структурная проверка CRC/EOI. Download — proxy через API (проверка членства), без редиректа на S3. + +Перенесено из lab3: LB, Idempotency-Key, X-Instance-Id, Redis-сессии, failover hooks. Добавлено: миграция `003_attachments.sql`, routes attachments, `cmd/reconcile`, `cmd/s3bootstrap`, MinIO в compose. + +Переменные `.env.example` → compose `x-api-env` / Load / LoadS3: `DATABASE_URL`, `REDIS_URL`, `S3_*`, `MAX_UPLOAD_*`, `S3_RECONCILE_GRACE_SECONDS`. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke (checksum, ACL) | `make test` | PASS lab4 public API scenario | `evidence/smoke.txt` | +| Offline contract | `make check` | PASS | (stdout) | +| Student-tests вложений/негативы/S3↓ | `make student-test` | PASS | `evidence/student-tests.txt` | +| Private bucket | `make private-bucket` | anonymous GET → HTTP 403 | `evidence/private-bucket.txt` | +| Persistence + оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS (restart postgres redis minio api lb) | `evidence/persistence.txt` | +| Failover API + download через другую реплику | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS; 2 instance ids до отказа | `evidence/failover.txt` | +| ≥10 concurrent uploads + RSS | `make concurrent` | 12×201; RSS API до/пик/после | `evidence/concurrent-uploads.txt` | +| Трек 2 reconciler | `make reconcile-demo` | orphan deleted; missing unreferenced deleted; referenced kept; fresh skipped | `evidence/reconcile.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза (трек 2):** при grace period reconciler безопасно удаляет только «старые» orphan-объекты и нессылаемые missing-строки; повторный apply идемпотентен; свежий orphan не трогается. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +Методика: `scripts/reconcile-demo.sh` — SigV4 PUT orphan root-ключом; SQL INSERT missing без объекта; dry-run/`-apply` с `-grace-seconds=0`; затем fresh orphan и dry-run с grace=60s. + +Результаты (локальный прогон): orphan удалён; 2 missing без ссылок удалены; 2 missing с `message_attachments` сохранены; fresh orphan → `orphan_skip_fresh`. Обход: List S3 O(n) + keyset по attachments; elapsed dry-run ~10–30 ms на учебном объёме. + +**Concurrent uploads:** 12 параллельных PNG по ~3.0 MiB (1024², zlib level 0), spool в `/tmp`. +RSS суммарно по API-репликам: before ≈96 MiB, peak ≈98 MiB, after ≈97 MiB — пик не масштабируется +как `N × размер файла` (нет `ReadAll` в кучу). См. `evidence/concurrent-uploads.txt`. + +| Воздействие | Что ожидаем | Что наблюдали | Восстановление | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker stop` одной API | LB уводит трафик; download с другой реплики | PASS failover | `scripts/restore-one.sh` | +| `restart` всех хранилищ+API | сессия и файл на месте | PASS persistence | volumes сохранены | +| Anonymous GET MinIO | не 200 | 403 | — | +| S3 down (unit) | ready/upload 503 | PASS student-test | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Официальные образы MinIO/Docker Hub недоступны; закреплён community-образ coollabsio того же RELEASE — риск расхождения с upstream. +- Reconciler не чинит referenced missing (нет исходных байтов) — только детектит; восстановление из бэкапа S3 вне скоупа. +- Student-tests с in-memory blob пишут метаданные в общий Postgres без объектов в MinIO; на учебном стенде их подбирает reconciler (referenced → keep). +- Presigned direct upload (трек 1) не реализован — выбран трек 2. +- Учебные секреты в `.env.example`; в Git не коммитить `.env`. diff --git a/cmd/reconcile/main.go b/cmd/reconcile/main.go new file mode 100644 index 00000000..d9d15d48 --- /dev/null +++ b/cmd/reconcile/main.go @@ -0,0 +1,221 @@ +// Reconciler lab4 (трек 5 / согласованность двух хранилищ). +// +// Сверяет PostgreSQL (attachments) и приватный S3-bucket (префикс originals/). +// По умолчанию dry-run: только отчёт. Флаг -apply выполняет безопасные правки. +// +// Классы расхождений: +// +// orphan — объект в S3 без строки в БД. После grace period удаляется (-apply). +// missing — строка в БД без объекта. Если на вложение нет ссылок из сообщений +// и строка старше grace — удаляется. Ссылаемые (в сообщениях) только +// логируются: удалять их нельзя, файл уже «в истории». +// +// Свежие объекты/строки (моложе grace) не трогаются: гонка «PUT прошёл, INSERT ещё нет» +// не должна приводить к удалению чужой успешной загрузки. +package main + +import ( + "context" + "flag" + "fmt" + "log" + "os" + "os/signal" + "syscall" + "time" + + "github.com/google/uuid" + + "mtusi2026lab4/internal/auth" + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/config" + "mtusi2026lab4/internal/store" +) + +func main() { + apply := flag.Bool("apply", false, "apply safe fixes (default: dry-run)") + graceSec := flag.Int64("grace-seconds", -1, "override S3_RECONCILE_GRACE_SECONDS (-1 = from env)") + pageSize := flag.Int("page-size", 200, "DB page size for attachment refs") + flag.Parse() + + cfg, err := config.Load() + if err != nil { + log.Fatalf("config: %v", err) + } + grace := cfg.ReconcileGrace + if *graceSec >= 0 { + grace = time.Duration(*graceSec) * time.Second + } + s3cfg, err := config.LoadS3() + if err != nil { + log.Fatalf("s3 config: %v", err) + } + + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) + defer stop() + + hasher, err := auth.NewHasher() + if err != nil { + log.Fatalf("hasher: %v", err) + } + st, err := store.Open(ctx, cfg.DatabaseURL, hasher, cfg.MaxConns) + if err != nil { + log.Fatalf("postgres: %v", err) + } + defer st.Close() + + bl, err := blob.New(blob.Config{ + Endpoint: s3cfg.Endpoint, + UseSSL: s3cfg.UseSSL, + Region: s3cfg.Region, + Bucket: s3cfg.Bucket, + AccessKey: s3cfg.AccessKey, + SecretKey: s3cfg.SecretKey, + }) + if err != nil { + log.Fatalf("s3: %v", err) + } + if err := bl.Ping(ctx); err != nil { + log.Fatalf("s3 ping: %v", err) + } + + mode := "dry-run" + if *apply { + mode = "apply" + } + log.Printf("reconcile start mode=%s grace=%s bucket=%s page=%d", mode, grace, s3cfg.Bucket, *pageSize) + + started := time.Now() + rep, err := run(ctx, st, bl, grace, *pageSize, *apply) + if err != nil { + log.Fatalf("reconcile: %v", err) + } + elapsed := time.Since(started) + + fmt.Printf("reconcile_report mode=%s elapsed_ms=%d\n", mode, elapsed.Milliseconds()) + fmt.Printf("s3_objects=%d db_rows=%d\n", rep.S3Objects, rep.DBRows) + fmt.Printf("orphans_found=%d orphans_deleted=%d orphans_skipped_fresh=%d\n", + rep.OrphansFound, rep.OrphansDeleted, rep.OrphansSkippedFresh) + fmt.Printf("missing_found=%d missing_deleted=%d missing_referenced=%d missing_skipped_fresh=%d\n", + rep.MissingFound, rep.MissingDeleted, rep.MissingReferenced, rep.MissingSkippedFresh) + for _, line := range rep.Details { + fmt.Println(line) + } + os.Exit(0) +} + +type report struct { + S3Objects int + DBRows int + OrphansFound int + OrphansDeleted int + OrphansSkippedFresh int + MissingFound int + MissingDeleted int + MissingReferenced int + MissingSkippedFresh int + Details []string +} + +func run(ctx context.Context, st *store.Store, bl *blob.Client, grace time.Duration, pageSize int, apply bool) (*report, error) { + if pageSize < 1 || pageSize > 1000 { + pageSize = 200 + } + rep := &report{} + cutoff := time.Now().UTC().Add(-grace) + + objs, err := bl.ListKeys(ctx, blob.KeyPrefix) + if err != nil { + return nil, fmt.Errorf("list s3: %w", err) + } + rep.S3Objects = len(objs) + byKey := make(map[string]blob.ObjectInfo, len(objs)) + for _, o := range objs { + byKey[o.Key] = o + } + + dbKeys := make(map[string]store.AttachmentRef) + var after uuid.UUID + for { + page, err := st.ListAttachmentRefs(ctx, after, pageSize) + if err != nil { + return nil, fmt.Errorf("list db: %w", err) + } + if len(page) == 0 { + break + } + for _, r := range page { + dbKeys[r.ObjectKey] = r + rep.DBRows++ + after = r.ID + } + if len(page) < pageSize { + break + } + } + + // orphan: S3 без строки + for key, o := range byKey { + if _, ok := dbKeys[key]; ok { + continue + } + rep.OrphansFound++ + if o.LastModified.After(cutoff) { + rep.OrphansSkippedFresh++ + rep.Details = append(rep.Details, fmt.Sprintf("orphan_skip_fresh key=%s age<%s", key, grace)) + continue + } + // Повторная проверка: загрузка могла успеть записать строку после ListKeys. + exists, err := st.AttachmentKeyExists(ctx, key) + if err != nil { + return nil, err + } + if exists { + rep.Details = append(rep.Details, fmt.Sprintf("orphan_race_gone key=%s", key)) + continue + } + if apply { + if err := bl.Delete(ctx, key); err != nil { + return nil, fmt.Errorf("delete orphan %s: %w", key, err) + } + rep.OrphansDeleted++ + rep.Details = append(rep.Details, fmt.Sprintf("orphan_deleted key=%s size=%d", key, o.Size)) + } else { + rep.Details = append(rep.Details, fmt.Sprintf("orphan_would_delete key=%s size=%d", key, o.Size)) + } + } + + // missing: строка без объекта + for key, ref := range dbKeys { + if _, ok := byKey[key]; ok { + continue + } + rep.MissingFound++ + if ref.CreatedAt.After(cutoff) { + rep.MissingSkippedFresh++ + rep.Details = append(rep.Details, fmt.Sprintf("missing_skip_fresh id=%s key=%s", ref.ID, key)) + continue + } + if ref.Referenced { + rep.MissingReferenced++ + rep.Details = append(rep.Details, fmt.Sprintf("missing_referenced id=%s key=%s (kept)", ref.ID, key)) + continue + } + if apply { + ok, err := st.DeleteUnreferencedAttachment(ctx, ref.ID) + if err != nil { + return nil, fmt.Errorf("delete missing meta %s: %w", ref.ID, err) + } + if ok { + rep.MissingDeleted++ + rep.Details = append(rep.Details, fmt.Sprintf("missing_deleted id=%s key=%s", ref.ID, key)) + } else { + rep.MissingReferenced++ + rep.Details = append(rep.Details, fmt.Sprintf("missing_race_referenced id=%s key=%s", ref.ID, key)) + } + } else { + rep.Details = append(rep.Details, fmt.Sprintf("missing_would_delete id=%s key=%s", ref.ID, key)) + } + } + return rep, nil +} diff --git a/cmd/s3bootstrap/main.go b/cmd/s3bootstrap/main.go new file mode 100644 index 00000000..a614cb0a --- /dev/null +++ b/cmd/s3bootstrap/main.go @@ -0,0 +1,123 @@ +// Одноразовый bootstrap приватного S3-bucket и app-пользователя с ограниченной политикой. +// Нужен, потому что публичные образы minio/mc с Docker Hub сняты; admin API вызываем из Go. +package main + +import ( + "context" + "fmt" + "log" + "os" + "strings" + "time" + + "github.com/minio/madmin-go/v3" + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +func main() { + endpoint := env("MINIO_ENDPOINT", "minio:9000") + endpoint = strings.TrimPrefix(strings.TrimPrefix(endpoint, "https://"), "http://") + rootUser := mustEnv("MINIO_ROOT_USER") + rootPass := mustEnv("MINIO_ROOT_PASSWORD") + bucket := env("S3_BUCKET", "messenger-attachments") + appKey := mustEnv("S3_ACCESS_KEY_ID") + appSecret := mustEnv("S3_SECRET_ACCESS_KEY") + useSSL := env("S3_USE_SSL", "0") == "1" || strings.EqualFold(env("S3_USE_SSL", "0"), "true") + + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + + mc, err := minio.New(endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(rootUser, rootPass, ""), + Secure: useSSL, + }) + if err != nil { + log.Fatalf("minio client: %v", err) + } + + deadline := time.Now().Add(90 * time.Second) + for { + ok, err := mc.BucketExists(ctx, bucket) + if err == nil { + if !ok { + if err := mc.MakeBucket(ctx, bucket, minio.MakeBucketOptions{}); err != nil { + code := minio.ToErrorResponse(err).Code + if code != "BucketAlreadyOwnedByYou" && code != "BucketAlreadyExists" { + log.Fatalf("make bucket: %v", err) + } + } + } + break + } + if time.Now().After(deadline) { + log.Fatalf("minio not ready: %v", err) + } + log.Printf("waiting for minio: %v", err) + time.Sleep(time.Second) + } + + // Явно запрещаем анонимный доступ (на случай, если кто-то выставил public). + if err := mc.SetBucketPolicy(ctx, bucket, ""); err != nil { + log.Printf("clear bucket policy: %v (продолжаем)", err) + } + + admin, err := madmin.NewWithOptions(endpoint, &madmin.Options{ + Creds: credentials.NewStaticV4(rootUser, rootPass, ""), + Secure: useSSL, + }) + if err != nil { + log.Fatalf("madmin: %v", err) + } + + policyName := "app-attachments" + policy := fmt.Sprintf(`{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": ["s3:ListBucket"], + "Resource": ["arn:aws:s3:::%s"] + }, + { + "Effect": "Allow", + "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], + "Resource": ["arn:aws:s3:::%s/*"] + } + ] +}`, bucket, bucket) + + if err := admin.AddCannedPolicy(ctx, policyName, []byte(policy)); err != nil { + // Уже существует — ок. + log.Printf("add policy: %v", err) + } + if err := admin.AddUser(ctx, appKey, appSecret); err != nil { + log.Printf("add user: %v", err) + } + if _, err := admin.AttachPolicy(ctx, madmin.PolicyAssociationReq{ + Policies: []string{policyName}, + User: appKey, + }); err != nil { + // Старые версии madmin: SetPolicy + if err2 := admin.SetPolicy(ctx, policyName, appKey, false); err2 != nil { + log.Fatalf("attach policy: %v / set policy: %v", err, err2) + } + } + + log.Printf("bootstrap ok bucket=%s app_user=%s private=yes", bucket, appKey) +} + +func env(k, def string) string { + if v := strings.TrimSpace(os.Getenv(k)); v != "" { + return v + } + return def +} + +func mustEnv(k string) string { + v := strings.TrimSpace(os.Getenv(k)) + if v == "" { + log.Fatalf("missing %s", k) + } + return v +} diff --git a/cmd/server/main.go b/cmd/server/main.go new file mode 100644 index 00000000..a700e95f --- /dev/null +++ b/cmd/server/main.go @@ -0,0 +1,214 @@ +// Точка входа HTTP API и одноразового мигратора lab4. +// +// Режимы: +// +// (по умолчанию) — API-реплика: Postgres + Redis + S3, миграции НЕ применяет; +// -migrate — применить SQL и выйти (S3 не нужен); +// -healthcheck — локальный probe /health/ready. +package main + +import ( + "context" + "flag" + "fmt" + "io" + "log" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "mtusi2026lab4/internal/api" + "mtusi2026lab4/internal/auth" + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/config" + "mtusi2026lab4/internal/session" + "mtusi2026lab4/internal/store" +) + +func main() { + healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit") + migrateOnly := flag.Bool("migrate", false, "apply SQL migrations 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() + + st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher, cfg.MaxConns) + if err != nil { + log.Fatalf("postgres: %v", err) + } + defer st.Close() + + if *migrateOnly || cfg.RunMigrations { + if err := st.Migrate(rootCtx); err != nil { + log.Fatalf("migrate: %v", err) + } + log.Printf("migrations applied") + if *migrateOnly { + return + } + } + + sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL) + if err != nil { + log.Fatalf("redis: %v", err) + } + defer sessions.Close() + + s3cfg, err := config.LoadS3() + if err != nil { + log.Fatalf("s3 config: %v", err) + } + blobs, err := waitS3(rootCtx, s3cfg) + if err != nil { + log.Fatalf("s3: %v", err) + } + + srvAPI := api.New(st, sessions, blobs, cfg.InstanceID) + srvAPI.MaxUploadBytes = cfg.MaxUploadBytes + srvAPI.MaxImagePixels = cfg.MaxImagePixels + + httpServer := &http.Server{ + Addr: cfg.Addr(), + Handler: srvAPI.Handler(), + ReadHeaderTimeout: 5 * time.Second, + // Upload до 10 MiB: даём запас на медленный клиент. + ReadTimeout: 60 * time.Second, + WriteTimeout: 60 * time.Second, + IdleTimeout: 60 * time.Second, + } + + errCh := make(chan error, 1) + go func() { + log.Printf("listening on %s env=%s instance=%s session_ttl=%s db_max_conns=%d bucket=%s", + cfg.Addr(), cfg.Env, cfg.InstanceID, cfg.SessionTTL, cfg.MaxConns, s3cfg.Bucket) + 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 instance=%s", cfg.InstanceID) + 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, maxConns int32) (*store.Store, error) { + deadline := time.Now().Add(45 * time.Second) + var last error + for { + st, err := store.Open(ctx, dsn, hasher, maxConns) + 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 waitS3(ctx context.Context, cfg config.S3) (*blob.Client, error) { + deadline := time.Now().Add(45 * time.Second) + var last error + for { + c, err := blob.New(blob.Config{ + Endpoint: cfg.Endpoint, + UseSSL: cfg.UseSSL, + Region: cfg.Region, + Bucket: cfg.Bucket, + AccessKey: cfg.AccessKey, + SecretKey: cfg.SecretKey, + }) + if err == nil { + if err = c.Ping(ctx); err == nil { + return c, nil + } + last = err + } else { + last = err + } + if ctx.Err() != nil || time.Now().After(deadline) { + return nil, last + } + log.Printf("s3 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/compose.yaml b/compose.yaml new file mode 100644 index 00000000..7eac7ce6 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,203 @@ +# Локальный стенд lab4: Клиент → HAProxy → API×N → PostgreSQL + Redis + приватный MinIO. +# Публикуется только LB (:8080). Порты API наружу не публикуются. +# MinIO API на 127.0.0.1:9000 — только для локальной проверки private bucket; консоль не публикуется. +# Запуск: bash scripts/up.sh +x-api-env: &api-env + 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} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DB_MAX_CONNS: ${DB_MAX_CONNS:-5} + DATABASE_URL: postgres://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-messenger}@postgres:5432/${POSTGRES_DB:-messenger}?sslmode=disable + REDIS_URL: redis://redis:6379/0 + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + S3_ENDPOINT: ${S3_ENDPOINT:-minio:9000} + S3_USE_SSL: ${S3_USE_SSL:-0} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger-app} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger-app-secret} + S3_RECONCILE_GRACE_SECONDS: ${S3_RECONCILE_GRACE_SECONDS:-60} + +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 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + + redis: + image: redis:7.4.1 + 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 + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + # Публичные minio/minio с Docker Hub сняты (2026). Собираем из community-образа + # ghcr.io/coollabsio/minio — бинарь последнего community RELEASE. + minio: + image: ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z + command: ["server", "/data", "--address", ":9000", "--console-address", ":9001"] + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin-secret} + volumes: + - miniodata:/data + ports: + - "127.0.0.1:9000:9000" + # Консоль :9001 намеренно не публикуется (уровень 4). + # В образе нет curl; TCP-probe + bootstrap ретраит MakeBucket. + healthcheck: + test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/9000"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 10s + stop_grace_period: 10s + deploy: + resources: + limits: + cpus: "0.50" + memory: 512M + + # Bootstrap без mc: бинарь /s3bootstrap из нашего образа (minio-go + madmin). + minio-init: + build: . + entrypoint: ["/s3bootstrap"] + environment: + MINIO_ENDPOINT: minio:9000 + MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin-secret} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger-app} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger-app-secret} + S3_USE_SSL: ${S3_USE_SSL:-0} + depends_on: + minio: + condition: service_healthy + restart: "no" + healthcheck: + disable: true + + migrate: + build: . + command: ["-migrate"] + environment: + <<: *api-env + depends_on: + postgres: + condition: service_healthy + restart: "no" + healthcheck: + disable: true + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + api: + build: . + environment: + <<: *api-env + expose: + - "8080" + depends_on: + redis: + condition: service_healthy + postgres: + condition: service_healthy + minio: + condition: service_healthy + minio-init: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "/server", "-healthcheck"] + interval: 2s + timeout: 2s + retries: 10 + start_period: 15s + stop_grace_period: 10s + restart: "no" + deploy: + resources: + limits: + cpus: ${API_CPUS:-0.50} + memory: ${API_MEMORY:-256M} + + reconcile: + build: . + entrypoint: ["/reconcile"] + environment: + <<: *api-env + depends_on: + postgres: + condition: service_healthy + minio: + condition: service_healthy + minio-init: + condition: service_completed_successfully + restart: "no" + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + lb: + image: haproxy:2.9.14-alpine + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + - "127.0.0.1:8080:8080" + depends_on: + api: + condition: service_healthy + healthcheck: + test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"] + interval: 10s + timeout: 3s + retries: 5 + start_period: 5s + stop_grace_period: 10s + deploy: + resources: + limits: + cpus: "0.50" + memory: 128M + +volumes: + pgdata: + redisdata: + miniodata: diff --git a/evidence/concurrent-uploads.txt b/evidence/concurrent-uploads.txt new file mode 100644 index 00000000..6769b38a --- /dev/null +++ b/evidence/concurrent-uploads.txt @@ -0,0 +1,8 @@ +concurrent=12 +upload_bytes=3147060 +ok_201=12 +results=[201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201] +elapsed_s=1.717 +api_rss_kb_before=96654 +api_rss_kb_peak=98006 +api_rss_kb_after=97197 diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..a4c73971 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 112, "failed_attempts": 1, "first_recovery_seconds": 2.928} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. 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/private-bucket.txt b/evidence/private-bucket.txt new file mode 100644 index 00000000..08767083 --- /dev/null +++ b/evidence/private-bucket.txt @@ -0,0 +1,2 @@ +GET http://127.0.0.1:9000/messenger-attachments/originals/does-not-exist → HTTP 403 body_bytes=381 +PASS: anonymous access denied (HTTP 403) diff --git a/evidence/reconcile.txt b/evidence/reconcile.txt new file mode 100644 index 00000000..61d55664 --- /dev/null +++ b/evidence/reconcile.txt @@ -0,0 +1,129 @@ +=== seed orphan object via root PutObject (python/minio not required: curl+aws style via go) === +orphan_put 200 +=== seed missing metadata (DB row, no S3 object) === +DO +=== dry-run grace=0 === +#1 [internal] load local bake definitions +#1 reading from stdin 683B done +#1 DONE 0.0s + +#2 [internal] load build definition from Dockerfile +#2 transferring dockerfile: 927B done +#2 DONE 0.0s + +#3 resolve image config for docker-image://docker.io/docker/dockerfile:1.7 +#3 DONE 1.0s + +#4 docker-image://docker.io/docker/dockerfile:1.7@sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e +#4 resolve docker.io/docker/dockerfile:1.7@sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e done +#4 CACHED + +#5 [internal] load metadata for docker.io/library/golang:1.24.2-bookworm +#5 DONE 0.6s + +#6 [internal] load metadata for gcr.io/distroless/static-debian12:nonroot +#6 DONE 0.7s + +#7 [internal] load .dockerignore +#7 transferring context: 196B done +#7 DONE 0.0s + +#8 [stage-1 1/4] FROM gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab +#8 resolve gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab 0.0s done +#8 DONE 0.0s + +#9 [build 1/9] FROM docker.io/library/golang:1.24.2-bookworm@sha256:79390b5e5af9ee6e7b1173ee3eac7fadf6751a545297672916b59bfa0ecf6f71 +#9 resolve docker.io/library/golang:1.24.2-bookworm@sha256:79390b5e5af9ee6e7b1173ee3eac7fadf6751a545297672916b59bfa0ecf6f71 0.0s done +#9 DONE 0.0s + +#10 [internal] load build context +#10 transferring context: 1.21kB 0.0s done +#10 DONE 0.0s + +#11 [stage-1 2/4] COPY --from=build /out/server /server +#11 CACHED + +#12 [stage-1 3/4] COPY --from=build /out/reconcile /reconcile +#12 CACHED + +#13 [build 6/9] COPY internal ./internal +#13 CACHED + +#14 [build 4/9] RUN go mod download +#14 CACHED + +#15 [build 2/9] WORKDIR /src +#15 CACHED + +#16 [build 8/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/reconcile ./cmd/reconcile +#16 CACHED + +#17 [build 9/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/s3bootstrap ./cmd/s3bootstrap +#17 CACHED + +#18 [build 3/9] COPY go.mod go.sum ./ +#18 CACHED + +#19 [build 5/9] COPY cmd ./cmd +#19 CACHED + +#20 [build 7/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server +#20 CACHED + +#21 [stage-1 4/4] COPY --from=build /out/s3bootstrap /s3bootstrap +#21 CACHED + +#22 exporting to image +#22 exporting layers 0.0s done +#22 exporting manifest sha256:b3e7db748d123d1baf965ab1e27b5d2a2bea64f3e68fe93798166da5c67b58f3 0.1s done +#22 exporting config sha256:76f75b546642e6ee2a4f055c5a45f1f406f5698112cd37c26b7301bcdcf8839f +#22 exporting config sha256:76f75b546642e6ee2a4f055c5a45f1f406f5698112cd37c26b7301bcdcf8839f 0.0s done +#22 exporting attestation manifest sha256:a877a0a7985478d45981bc5e291b0bc16bf401bfedfe03691ee01f5f50cf1606 +#22 exporting attestation manifest sha256:a877a0a7985478d45981bc5e291b0bc16bf401bfedfe03691ee01f5f50cf1606 0.0s done +#22 exporting manifest list sha256:e53705a39a996dc932198dc966f069d8bb83bba703dbcb6db0fe25d733a4fab7 0.0s done +#22 naming to docker.io/library/mtusi2026lab4-reconcile:latest done +#22 unpacking to docker.io/library/mtusi2026lab4-reconcile:latest done +#22 DONE 0.4s + +#23 resolving provenance for metadata file +#23 DONE 0.0s +2026/11/12 15:06:31 reconcile start mode=dry-run grace=0s bucket=messenger-attachments page=200 +reconcile_report mode=dry-run elapsed_ms=33 +s3_objects=16 db_rows=19 +orphans_found=1 orphans_deleted=0 orphans_skipped_fresh=0 +missing_found=4 missing_deleted=0 missing_referenced=2 missing_skipped_fresh=0 +orphan_would_delete key=originals/00000000-0000-4000-8000-0000000000aa size=12 +missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept) +missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept) +missing_would_delete id=ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 key=originals/ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 +missing_would_delete id=11111111-1111-4111-8111-111111111111 key=originals/11111111-1111-4111-8111-111111111111 +=== apply grace=0 === +2026/11/12 15:06:33 reconcile start mode=apply grace=0s bucket=messenger-attachments page=200 +reconcile_report mode=apply elapsed_ms=17 +s3_objects=16 db_rows=19 +orphans_found=1 orphans_deleted=1 orphans_skipped_fresh=0 +missing_found=4 missing_deleted=2 missing_referenced=2 missing_skipped_fresh=0 +orphan_deleted key=originals/00000000-0000-4000-8000-0000000000aa size=12 +missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept) +missing_deleted id=ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 key=originals/ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 +missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept) +missing_deleted id=11111111-1111-4111-8111-111111111111 key=originals/11111111-1111-4111-8111-111111111111 +=== second apply (idempotent) === +2026/11/12 15:06:34 reconcile start mode=apply grace=0s bucket=messenger-attachments page=200 +reconcile_report mode=apply elapsed_ms=7 +s3_objects=15 db_rows=17 +orphans_found=0 orphans_deleted=0 orphans_skipped_fresh=0 +missing_found=2 missing_deleted=0 missing_referenced=2 missing_skipped_fresh=0 +missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept) +missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept) +=== fresh orphan skipped with default grace === +fresh_put 200 +2026/11/12 15:06:35 reconcile start mode=dry-run grace=1m0s bucket=messenger-attachments page=200 +reconcile_report mode=dry-run elapsed_ms=13 +s3_objects=16 db_rows=17 +orphans_found=1 orphans_deleted=0 orphans_skipped_fresh=1 +missing_found=2 missing_deleted=0 missing_referenced=0 missing_skipped_fresh=2 +orphan_skip_fresh key=originals/00000000-0000-4000-8000-0000000000bb age<1m0s +missing_skip_fresh id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b +missing_skip_fresh id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 +wrote evidence/reconcile.txt diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..1e7b9ff4 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..3e6b06d0 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,250 @@ +DATABASE_URL=postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable \ + REDIS_URL=redis://127.0.0.1:6379/0 \ + go test ./student-tests/ -count=1 -v +=== RUN TestMalformedJSONAndValidation + api_test.go:76: → битый JSON, хвост после объекта, лишнее поле, пустой текст, чужой чат +2026/11/12 18:06:18 method=POST path=/api/v1/users status=400 request_id=8c1902bd-a429-4b6c-9a41-39b3dc20c4e8 duration_ms=0 + api_test.go:79: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"8c1902bd-a429-4b6c-9a41-39b3dc20c4e8"}} +2026/11/12 18:06:18 method=POST path=/api/v1/users status=400 request_id=f01f3adb-78bb-4722-8c40-fcb5939899ec duration_ms=0 + api_test.go:86: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"f01f3adb-78bb-4722-8c40-fcb5939899ec"}} +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=50bdc461-ab51-4108-9e5c-58495ab5edeb duration_ms=52 + api_test.go:91: создан ok_user_327b0fdb id=926f8271-4f8e-4379-b69b-e424e83919d7 +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=4483c457-abce-4d52-9d97-df7fe1ceed40 duration_ms=39 + api_test.go:92: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:18 method=POST path=/api/v1/chats status=201 request_id=5ee4d4df-80bf-4212-9b11-15a8beaa22d8 duration_ms=8 +2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=788d8cb8-5474-470e-b39c-d7fce6962987 duration_ms=3 + api_test.go:99: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"788d8cb8-5474-470e-b39c-d7fce6962987"}} +2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=d4632ebb-a886-4338-8372-5d73e2239842 duration_ms=0 + api_test.go:99: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"d4632ebb-a886-4338-8372-5d73e2239842"}} +2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=09b6498f-3e15-49b7-9266-ecf84d2a7916 duration_ms=0 + api_test.go:106: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"09b6498f-3e15-49b7-9266-ecf84d2a7916"}} +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=87a631af-6c30-46eb-a783-5b81d3db8d7e duration_ms=36 + api_test.go:111: создан outsider_24331385 id=225d868f-362a-41d4-996b-1881ccf6cd8a +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=168ea6f0-a4b0-44fa-b272-3ca6fa92fdb8 duration_ms=35 + api_test.go:112: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=404 request_id=d6eebb84-6115-4163-9d68-0a5f4870ac33 duration_ms=5 + api_test.go:114: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"d6eebb84-6115-4163-9d68-0a5f4870ac33"}} + api_test.go:118: ✓ валидация JSON, хвоста, пустого текста и чужого чата +--- PASS: TestMalformedJSONAndValidation (0.19s) +=== RUN TestMessageTextPreservedAndLengthOnOriginal + api_test.go:124: → пробелы по краям сохраняются; длина считается по исходному тексту +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=35882536-5698-47e4-aa4d-b26ca05eccf2 duration_ms=28 + api_test.go:125: создан text_user_b0b3691c id=4d721a90-d23e-4812-bc50-4b91b972f4a9 +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=68fe42a9-aa1d-4219-89d0-0bea4485c691 duration_ms=52 + api_test.go:126: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:18 method=POST path=/api/v1/chats status=201 request_id=d2fdb0f8-f7e6-4a7a-906e-bd5a7575c658 duration_ms=73 +2026/11/12 18:06:18 method=POST path=/api/v1/chats/5af6de80-5d24-4e1c-85ba-6064483eee06/messages status=201 request_id=e87c5fb7-9da0-4db4-b3d3-5c2fde5a1f9c duration_ms=31 + api_test.go:133: status=201 body={"attachment_ids":[],"chat_id":"5af6de80-5d24-4e1c-85ba-6064483eee06","created_at":"2026-11-12T15:06:18.586Z","id":"fb22f748-419d-4e21-bad1-15eefd3541fc","sender_id":"4d721a90-d23e-4812-bc50-4b91b972f4a9","text":" строка\nс пробелами "} +2026/11/12 18:06:18 method=POST path=/api/v1/chats/5af6de80-5d24-4e1c-85ba-6064483eee06/messages status=400 request_id=fb0600ea-7684-4546-948c-758bd6de9fe7 duration_ms=0 + api_test.go:145: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"fb0600ea-7684-4546-948c-758bd6de9fe7"}} + api_test.go:149: ✓ текст сохранён целиком, обход лимита через TrimSpace закрыт +--- PASS: TestMessageTextPreservedAndLengthOnOriginal (0.19s) +=== RUN TestSessionRejectsJSONBody + api_test.go:155: → POST /auth/sessions с телом должен быть 400 даже при верном Basic +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=fb41ef9f-6a7e-40d9-9a7b-1a6b999f146a duration_ms=33 + api_test.go:156: создан body_user_f034de4e id=34ffe3cc-0fad-43ef-9c71-167de51999db +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=400 request_id=64964195-0966-4ef3-a09e-90cc2feddbe4 duration_ms=0 + api_test.go:160: status=400 body={"error":{"code":"invalid_request","message":"session create must not have a body","request_id":"64964195-0966-4ef3-a09e-90cc2feddbe4"}} + api_test.go:164: ✓ вход без JSON body +--- PASS: TestSessionRejectsJSONBody (0.04s) +=== RUN TestWrongPasswordLogoutAndIgnoredUserHeader + api_test.go:170: → неверный пароль, Basic на бизнес-методе, X-User-Id, logout +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=db2797ae-6acd-42c7-a935-5180d9f3f9c7 duration_ms=34 + api_test.go:171: создан auth_user_ceeda3df id=9a73b5de-ea1c-452d-a52a-ceada48a8bcb +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=4abdf37f-d666-4ffa-aca5-96358c777f19 duration_ms=35 + api_test.go:172: создан auth_other_029a2c01 id=84485afe-e12b-4811-abd5-6a323a4a11b0 +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=401 request_id=561b7123-f836-4e1b-86e5-3202dd168c02 duration_ms=40 + api_test.go:177: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"561b7123-f836-4e1b-86e5-3202dd168c02"}} +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=ff0c1cd3-6893-498b-8a85-1ddcfaea198e duration_ms=37 + api_test.go:182: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=fa44aa80-40c9-460c-8318-fbcdd6127ef5 duration_ms=0 + api_test.go:186: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"fa44aa80-40c9-460c-8318-fbcdd6127ef5"}} +2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=f76f04a1-a69e-4d4a-b6d9-6cefff6de333 duration_ms=0 + api_test.go:192: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"f76f04a1-a69e-4d4a-b6d9-6cefff6de333"}} +2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=200 request_id=57b7a10b-bcce-4f69-b4eb-84d7dbfe333d duration_ms=5 + api_test.go:201: status=200 body={"created_at":"2026-11-12T15:06:18.678Z","display_name":"Студент","id":"9a73b5de-ea1c-452d-a52a-ceada48a8bcb","username":"auth_user_ceeda3df"} +2026/11/12 18:06:18 method=DELETE path=/api/v1/auth/sessions/current status=204 request_id=ed4b6610-d10e-4f08-933c-0da4c63e1db5 duration_ms=1 + api_test.go:207: logout status=204 +2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=c51a2f42-758f-4a9d-9995-28d1fb1bd0e1 duration_ms=0 +2026/11/12 18:06:18 method=DELETE path=/api/v1/auth/sessions/current status=401 request_id=800ac6d0-86dd-46eb-baab-24c6f45c4993 duration_ms=1 + api_test.go:219: ✓ пароль, заголовки и отзыв сессии +--- PASS: TestWrongPasswordLogoutAndIgnoredUserHeader (0.17s) +=== RUN TestSessionExpiry + api_test.go:225: → SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается +2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=bcb1c96f-65df-40a8-bdac-94727a1cb041 duration_ms=35 + api_test.go:226: создан ttl_user_325de81d id=484fbed9-09a4-4166-8f92-4f69a1fc1689 +2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=2088a908-3d83-4faf-bd43-84ee481db9cb duration_ms=25 + api_test.go:227: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=401 request_id=0ba4365e-3bb4-4f55-886d-31698f49dc34 duration_ms=2 + api_test.go:230: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"0ba4365e-3bb4-4f55-886d-31698f49dc34"}} + api_test.go:234: ✓ истёкшая сессия отклонена +--- PASS: TestSessionExpiry (2.58s) +=== RUN TestDuplicateUsernameRace + api_test.go:241: → 8 параллельных регистраций username=race_6ed0656c +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=5402c615-aab8-4b07-a21d-46946f22785b duration_ms=83 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=e860a8f7-fd25-4c0d-abd9-31b50a08db96 duration_ms=85 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=dd17c014-02b9-4fb0-9481-7d4d3d840193 duration_ms=90 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=9a31aa27-6548-4e36-8505-5ec0334ebd76 duration_ms=92 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=d841c975-d516-4b63-b699-661a26ec2175 duration_ms=90 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=c2bf9c03-a386-4ad2-a49d-2749a633654a duration_ms=94 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=cf6d6c68-1668-4991-ab7b-ae77cc69aa47 duration_ms=98 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=025c3a4d-21c6-48ff-89e6-03e6b8f69f62 duration_ms=99 + api_test.go:266: created=1 conflict=7 + api_test.go:270: ✓ UNIQUE username выдержал гонку +--- PASS: TestDuplicateUsernameRace (0.12s) +=== RUN TestChatCreateRollsBack +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=57132288-7a2a-49e0-91d3-1b3b2ad8ad5b duration_ms=35 + api_test.go:276: создан roll_user_55538244 id=510834db-6bf3-44ce-9c3e-bc5a3654ffd7 +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=2d0bfbec-5b2f-435d-90f4-183fed112d83 duration_ms=30 + api_test.go:277: сессия выпущена, длина токена=64 (значение не печатаем) + api_test.go:280: → создание чата с несуществующим участником должно откатиться, title=rollback-2162ebe8-7d02-467d-a256-23b859075201 +2026/11/12 18:06:21 method=POST path=/api/v1/chats status=400 request_id=21f2b61a-aa7d-4c17-9190-50a2070ca522 duration_ms=5 + api_test.go:283: status=400 body={"error":{"code":"invalid_request","message":"unknown member","request_id":"21f2b61a-aa7d-4c17-9190-50a2070ca522"}} + api_test.go:291: строк chats с этим title после ошибки: 0 + api_test.go:295: ✓ транзакция создания чата откатилась +--- PASS: TestChatCreateRollsBack (0.08s) +=== RUN TestPaginationPages + api_test.go:301: → три сообщения, две страницы limit=2, затем последняя +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=0a6b83e1-0421-4574-811e-4da75eb44a3f duration_ms=26 + api_test.go:302: создан page_user_0c9c3ed1 id=687fac60-91d1-42d3-84fc-4a49378c362c +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=646ba194-eeb2-45d8-b535-6afed48abf8d duration_ms=25 + api_test.go:303: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=a3495c84-c564-4d1c-af3b-374ac0c843e7 duration_ms=2 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=4cff46d2-34c6-4473-93f0-7473eaccda7a duration_ms=7 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=54dcd688-e45f-405f-a849-4c9b540c558b duration_ms=2 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=4b4c1969-acd3-4785-b0a3-a7e1fc6f3d9b duration_ms=2 +2026/11/12 18:06:21 method=GET path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=200 request_id=490be6d4-e04b-49d2-8f10-d45cbbc013df duration_ms=2 + api_test.go:313: status=200 body={"items":[{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.645Z","id":"6e24502d-79d4-4f6c-be3d-ba3480fb7608","sender_id":"687fac60-91d1-42d3-84fc-4a49378c362c","text":"раз"},{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.649Z","id":"88e5a96b-e468-473a-9c4b-92e6ba4f4329","sender_id":"6... +2026/11/12 18:06:21 method=GET path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=200 request_id=1c4e85bf-6325-48e0-81a3-cbd6daeed98b duration_ms=1 + api_test.go:321: status=200 body={"items":[{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.652Z","id":"0f9e9233-a586-4204-a5d8-71afd9d314be","sender_id":"687fac60-91d1-42d3-84fc-4a49378c362c","text":"три"}],"next_cursor":null} + api_test.go:327: ✓ keyset обошёл историю без зависания cursor +--- PASS: TestPaginationPages (0.07s) +=== RUN TestRedisDownIsNotAnonymous + api_test.go:331: → закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=beeadeed-af0b-47b4-b0e4-7e6421f1f496 duration_ms=25 + api_test.go:343: создан redis_down_bef9688c id=89644793-1ece-4a4a-a601-a29a56d1a4d8 +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=503 request_id=9762b8fa-434c-445c-823f-0acc5704f4be duration_ms=24 + api_test.go:347: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"9762b8fa-434c-445c-823f-0acc5704f4be"}} +2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=503 request_id=badd3986-bcb8-41c6-a0ba-618ffac05af1 duration_ms=0 + api_test.go:354: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"badd3986-bcb8-41c6-a0ba-618ffac05af1"}} + api_test.go:358: ✓ сбой Redis не стал анонимным доступом +--- PASS: TestRedisDownIsNotAnonymous (0.05s) +=== RUN TestPostgresDownIsNotAnonymous + api_test.go:362: → закрытый пул PostgreSQL: ready/me/login дают 503, без тела пользователя +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=a021c019-6aa8-41ce-a7d5-42b488cb43d9 duration_ms=26 + api_test.go:365: создан pg_down_2520dcae id=20f9f190-3b5a-4ff7-ae47-2897b7f18ea4 +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=fea01055-7d40-4324-9aed-ca5fc456adfd duration_ms=26 + api_test.go:366: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:21 method=GET path=/health/ready status=503 request_id=32035732-a60e-4d41-b9df-0f94ff733650 duration_ms=0 + api_test.go:387: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"32035732-a60e-4d41-b9df-0f94ff733650"}} +2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=503 request_id=0193b1dd-49dd-4647-9a44-5cdca3091ed0 duration_ms=0 + api_test.go:394: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"0193b1dd-49dd-4647-9a44-5cdca3091ed0"}} +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=503 request_id=f6fbf5d1-9f1c-452d-951a-3ee09749f6cd duration_ms=0 + api_test.go:401: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"f6fbf5d1-9f1c-452d-951a-3ee09749f6cd"}} + api_test.go:405: ✓ сбой PostgreSQL не стал анонимным доступом +--- PASS: TestPostgresDownIsNotAnonymous (0.09s) +=== RUN TestIdempotencyReplayAndConflict + api_test.go:412: → повтор того же Idempotency-Key возвращает то же сообщение; другой body — 409 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=ba481c3a-d59e-4f1c-b109-273d9cf8f376 duration_ms=27 + api_test.go:413: создан idem_user_5e962710 id=3b9c80ec-af5b-4fcb-8612-df5adf66e7b0 +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=c7504a83-5f6a-40fd-a47a-6f7a5e611f88 duration_ms=25 + api_test.go:414: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=6fecfacf-5cf0-42fc-8ae6-cd3499868da5 duration_ms=2 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=201 request_id=ebb16497-7dc3-4b1d-a352-2ec117b1c588 duration_ms=2 + api_test.go:422: status=201 body={"attachment_ids":[],"chat_id":"bf42b0ff-2d72-4083-888f-d46b0d4bba6b","created_at":"2026-11-12T15:06:21.861Z","id":"76a0823b-deb0-4087-820f-6d8d5d955062","sender_id":"3b9c80ec-af5b-4fcb-8612-df5adf66e7b0","text":"один раз"} +2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=201 request_id=3b737653-a43e-4b6b-901b-80de4724d31b duration_ms=1 + api_test.go:428: status=201 body={"attachment_ids":[],"chat_id":"bf42b0ff-2d72-4083-888f-d46b0d4bba6b","created_at":"2026-11-12T15:06:21.861Z","id":"76a0823b-deb0-4087-820f-6d8d5d955062","sender_id":"3b9c80ec-af5b-4fcb-8612-df5adf66e7b0","text":"один раз"} +2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=409 request_id=5be94615-9308-4e4f-9b02-04ca003f6e16 duration_ms=1 + api_test.go:437: status=409 body={"error":{"code":"conflict","message":"idempotency key reused with different body","request_id":"5be94615-9308-4e4f-9b02-04ca003f6e16"}} + api_test.go:441: ✓ replay и conflict по Idempotency-Key +--- PASS: TestIdempotencyReplayAndConflict (0.06s) +=== RUN TestIdempotencyKeyRequiredAndConcurrent + api_test.go:447: → нет ключа → 400; 8 параллельных POST с одним ключом → ровно одно сообщение +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=2ab93c5e-9ffd-4260-a5dc-b04f6ae5660b duration_ms=25 + api_test.go:448: создан idem_race_f0f21140 id=53f6a58c-3ce4-410c-bf6d-088084ebf4c2 +2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=45711062-65f8-4aac-8563-4790fdc89a3b duration_ms=25 + api_test.go:449: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=2df6eccd-30af-4e17-80e0-4b52fb771e18 duration_ms=4 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=400 request_id=26e381a2-4bc0-4eee-b668-9816b9ad2839 duration_ms=0 + api_test.go:467: status=400 body={"error":{"code":"invalid_request","message":"invalid or missing Idempotency-Key","request_id":"26e381a2-4bc0-4eee-b668-9816b9ad2839"}} +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=88713995-6e81-4644-8e0b-7b4c394ca9af duration_ms=7 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=baaee528-b553-4633-b6f4-2f09abb4b01a duration_ms=10 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=e283a5e9-ce51-44b2-9a7c-23edbb41b3ba duration_ms=12 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=68be161c-a944-4b64-ad56-8f14c3068b6e duration_ms=14 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=45041db6-7633-438e-8e6e-3657e6a4a915 duration_ms=16 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=191a3c6d-26ac-4359-88e7-d04bf59e7367 duration_ms=17 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=2c81685c-5ee7-4d2e-81ab-5153014708d3 duration_ms=19 +2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=5f23de1d-3352-4864-a40d-fa959abd420e duration_ms=20 + api_test.go:499: unique message ids=1 + api_test.go:503: ✓ ключ обязателен; конкурентный повтор не плодит дубли +--- PASS: TestIdempotencyKeyRequiredAndConcurrent (0.08s) +=== RUN TestInstanceIDHeaderPresent + api_test.go:509: → каждый ответ содержит непустой X-Instance-Id + api_test.go:511: status=200 body={"status":"ok"} + api_test.go:515: ✓ X-Instance-Id=test-instance +--- PASS: TestInstanceIDHeaderPresent (0.00s) +=== RUN TestAttachmentUploadDownloadAndACL + attachments_test.go:38: → upload PNG → 201 ready → download checksum; посторонний — 404 +2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=50e4a1af-fd0c-4f79-8dda-70a15bb9acd4 duration_ms=28 + attachments_test.go:40: создан att_owner_26e19e85 id=2aaf31d8-5457-4aa8-97fd-5e30ab916418 +2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=c7bf2c56-6b37-46c0-b26a-9fdea9c650c2 duration_ms=27 + attachments_test.go:41: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=a1edcb49-d0cd-40fa-af3a-0d67d0b2ea8b duration_ms=27 + attachments_test.go:42: создан att_stranger_bb876443 id=88bd447e-69a4-448f-96d2-f359e2bfdfe3 +2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=2249a833-a589-425a-aab2-76eb560ae04d duration_ms=27 + attachments_test.go:43: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=f46c6061-855f-4113-afc6-1c5735e5f0d1 duration_ms=5 +2026/11/12 18:06:22 method=POST path=/api/v1/chats/0dacdbe6-5b95-41e8-817d-6b31549a20c9/attachments status=201 request_id=c74261b2-25cc-4995-a15e-8dff9f19f456 duration_ms=3 +2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498 status=200 request_id=210ea277-a957-43d8-a45b-529cafc1ecd0 duration_ms=1 + attachments_test.go:50: status=200 body={"chat_id":"0dacdbe6-5b95-41e8-817d-6b31549a20c9","content_type":"image/png","created_at":"2026-11-12T15:06:22.067Z","error_code":null,"filename":"pic.png","id":"867bc3f8-3656-4138-a787-b5fc8fc85498","owner_id":"2aaf31d8-5457-4aa8-97fd-5e30ab916418","sha256":"2e9b06dc65a4dec84a3eb3124553ec93ca27c78221e64ab2177d0f1412cfcb20","size_bytes":69,"status":"ready","updated_at":"2026-11-12T15:06:22.067Z","... +2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498/content status=200 request_id=d52949e3-d49d-4cc6-a0ae-d406e07a4db1 duration_ms=0 +2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498 status=404 request_id=1e7cf8e4-64dd-4542-a225-01ae04bbd5ae duration_ms=0 + attachments_test.go:74: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"1e7cf8e4-64dd-4542-a225-01ae04bbd5ae"}} +2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498/content status=404 request_id=51e58b03-52c7-4ad1-b15f-56a49c443ec1 duration_ms=0 +2026/11/12 18:06:22 method=POST path=/api/v1/chats/0dacdbe6-5b95-41e8-817d-6b31549a20c9/messages status=201 request_id=ae5b57bc-14b1-4d8a-a40d-a71cb4f71935 duration_ms=5 + attachments_test.go:86: status=201 body={"attachment_ids":["867bc3f8-3656-4138-a787-b5fc8fc85498"],"chat_id":"0dacdbe6-5b95-41e8-817d-6b31549a20c9","created_at":"2026-11-12T15:06:22.074Z","id":"0ea80b9c-c870-4e74-a23a-2a3b804970af","sender_id":"2aaf31d8-5457-4aa8-97fd-5e30ab916418","text":"с файлом"} + attachments_test.go:95: ✓ upload/download/ACL и message.attachment_ids +--- PASS: TestAttachmentUploadDownloadAndACL (0.13s) +=== RUN TestAttachmentRejectsBadInput + attachments_test.go:102: → битый PNG, подмена MIME, опасный filename, чужой чат → 4xx не 500 +2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=4c3e8cba-a49e-417b-8a4d-da66dc3cdf18 duration_ms=28 + attachments_test.go:104: создан att_bad_21539b6c id=f5e5ea5c-5c89-4aba-8393-1d418136d0d7 +2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=db8cea49-9800-450d-8c80-cd85f21fef4c duration_ms=27 + attachments_test.go:105: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=c37b00b8-95e8-466b-b0bb-c90397b4913c duration_ms=5 +2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=400 request_id=791df656-1869-4832-8e16-d145f3e12568 duration_ms=1 + attachments_test.go:109: status=400 body={"error":{"code":"invalid_request","message":"invalid filename","request_id":"791df656-1869-4832-8e16-d145f3e12568"}} +2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=415 request_id=f8d9fdcc-524a-4c81-a08d-b72803745bdc duration_ms=3 + attachments_test.go:115: status=415 body={"error":{"code":"unsupported_media_type","message":"invalid or unsupported image","request_id":"f8d9fdcc-524a-4c81-a08d-b72803745bdc"}} +2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=415 request_id=6da7b2bc-c552-4885-bd4c-dd888b3a6a4b duration_ms=1 + attachments_test.go:121: status=415 body={"error":{"code":"unsupported_media_type","message":"invalid or unsupported image","request_id":"6da7b2bc-c552-4885-bd4c-dd888b3a6a4b"}} +2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=413 request_id=55dfe90c-9de2-4a34-942d-5e29abb6a181 duration_ms=1 + attachments_test.go:138: status=413 body={"error":{"code":"payload_too_large","message":"file is too large","request_id":"55dfe90c-9de2-4a34-942d-5e29abb6a181"}} +2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=c4d7a58a-254b-49c8-954d-f69c37badb7b duration_ms=28 + attachments_test.go:143: создан att_other_f29f128d id=3186c693-b42d-4040-82b2-aa46cdf35c10 +2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=17898378-42f5-4bac-a69e-d3673070bc82 duration_ms=28 + attachments_test.go:144: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=106a6135-6033-49d0-a3af-cdffa50138f3 duration_ms=2 +2026/11/12 18:06:22 method=POST path=/api/v1/chats/48d9e9da-2e02-4663-941b-b1e8fe8f587a/attachments status=404 request_id=a1749a57-1189-4505-b6c7-26726bab488b duration_ms=0 + attachments_test.go:147: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"a1749a57-1189-4505-b6c7-26726bab488b"}} +2026/11/12 18:06:22 method=POST path=/api/v1/chats/48d9e9da-2e02-4663-941b-b1e8fe8f587a/attachments status=201 request_id=75b83de8-96a1-4b6d-88f3-8c47d1d337d8 duration_ms=1 +2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/messages status=404 request_id=9202daed-c840-4dad-aaad-57c641b5b60e duration_ms=1 + attachments_test.go:156: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"9202daed-c840-4dad-aaad-57c641b5b60e"}} + attachments_test.go:160: ✓ негативные сценарии вложений → клиентские 4xx +--- PASS: TestAttachmentRejectsBadInput (0.14s) +=== RUN TestAttachmentS3DownIs503 + attachments_test.go:168: → S3 недоступен: ready и upload → 503 +2026/11/12 18:06:22 method=GET path=/health/ready status=503 request_id=3d89fdba-9a9c-4584-a4c6-3f80db705e0a duration_ms=0 + attachments_test.go:171: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"3d89fdba-9a9c-4584-a4c6-3f80db705e0a"}} +2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=4e83fd55-0b6c-4d86-9af6-f2fa3c2bdbf2 duration_ms=25 + attachments_test.go:176: создан s3_down_e2a7e91a id=54340923-2d7d-4a06-b2e2-ffaa7d8740bd +2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=0e4ab943-38bb-4a14-a97f-63fbb3290957 duration_ms=25 + attachments_test.go:177: сессия выпущена, длина токена=64 (значение не печатаем) +2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=71b90d66-3e07-4558-b3a8-9e7b53dd2692 duration_ms=3 +2026/11/12 18:06:22 request_id=f6f288b3-755c-458e-8d82-ab72fafb64f8 s3_unavailable +2026/11/12 18:06:22 method=POST path=/api/v1/chats/83ee260c-6369-47be-a18e-7fc24884dc4e/attachments status=503 request_id=f6f288b3-755c-458e-8d82-ab72fafb64f8 duration_ms=1 + attachments_test.go:180: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"f6f288b3-755c-458e-8d82-ab72fafb64f8"}} + attachments_test.go:184: ✓ падение S3 → 503 +--- PASS: TestAttachmentS3DownIs503 (0.06s) +PASS +ok mtusi2026lab4/student-tests 4.450s diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..b39d2f7f --- /dev/null +++ b/go.mod @@ -0,0 +1,54 @@ +module mtusi2026lab4 + +go 1.24.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.7.4 + github.com/minio/madmin-go/v3 v3.0.107 + github.com/minio/minio-go/v7 v7.0.90 + github.com/redis/go-redis/v9 v9.7.3 + golang.org/x/crypto v0.37.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-ini/ini v1.67.0 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/goccy/go-json v0.10.5 // indirect + github.com/golang-jwt/jwt/v4 v4.5.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/klauspost/cpuid/v2 v2.2.10 // indirect + github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/minio/crc64nvme v1.0.1 // indirect + github.com/minio/md5-simd v1.1.2 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.63.0 // indirect + github.com/prometheus/procfs v0.16.0 // indirect + github.com/prometheus/prom2json v1.4.2 // indirect + github.com/prometheus/prometheus v0.303.0 // indirect + github.com/rs/xid v1.6.0 // indirect + github.com/safchain/ethtool v0.5.10 // indirect + github.com/secure-io/sio-go v0.3.1 // indirect + github.com/shirou/gopsutil/v3 v3.24.5 // indirect + github.com/shoenig/go-m1cpu v0.1.6 // indirect + github.com/tinylib/msgp v1.2.5 // indirect + github.com/tklauser/go-sysconf v0.3.15 // indirect + github.com/tklauser/numcpus v0.10.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + golang.org/x/net v0.39.0 // indirect + golang.org/x/sync v0.13.0 // indirect + golang.org/x/sys v0.32.0 // indirect + golang.org/x/text v0.24.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..96afdc89 --- /dev/null +++ b/go.sum @@ -0,0 +1,128 @@ +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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.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.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= +github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= +github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +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/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= +github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc= +github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg= +github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= +github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/minio/crc64nvme v1.0.1 h1:DHQPrYPdqK7jQG/Ls5CTBZWeex/2FMS3G5XGkycuFrY= +github.com/minio/crc64nvme v1.0.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= +github.com/minio/madmin-go/v3 v3.0.107 h1:MZNlPmJWsbxIvgIACSxmMq4T3PXK9/wil3pMSaTz5HI= +github.com/minio/madmin-go/v3 v3.0.107/go.mod h1:WOe2kYmYl1OIlY2DSRHVQ8j1v4OItARQ6jGyQqcCud8= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.90 h1:TmSj1083wtAD0kEYTx7a5pFsv3iRYMsOJ6A4crjA1lE= +github.com/minio/minio-go/v7 v7.0.90/go.mod h1:uvMUcGrpgeSAAI6+sD3818508nUyMULw94j2Nxku/Go= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k= +github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18= +github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2bbsM= +github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg= +github.com/prometheus/prom2json v1.4.2 h1:PxCTM+Whqi/eykO1MKsEL0p/zMpxp9ybpsmdFamw6po= +github.com/prometheus/prom2json v1.4.2/go.mod h1:zuvPm7u3epZSbXPWHny6G+o8ETgu6eAK3oPr6yFkRWE= +github.com/prometheus/prometheus v0.303.0 h1:wsNNsbd4EycMCphYnTmNY9JASBVbp7NWwJna857cGpA= +github.com/prometheus/prometheus v0.303.0/go.mod h1:8PMRi+Fk1WzopMDeb0/6hbNs9nV6zgySkU/zds5Lu3o= +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/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= +github.com/safchain/ethtool v0.5.10 h1:Im294gZtuf4pSGJRAOGKaASNi3wMeFaGaWuSaomedpc= +github.com/safchain/ethtool v0.5.10/go.mod h1:w9jh2Lx7YBR4UwzLkzCmWl85UY0W2uZdd7/DckVE5+c= +github.com/secure-io/sio-go v0.3.1 h1:dNvY9awjabXTYGsTF1PiCySl9Ltofk9GA3VdWlo7rRc= +github.com/secure-io/sio-go v0.3.1/go.mod h1:+xbkjDzPjwh4Axd07pRKSNriS9SCiYksWnZqdnfpQxs= +github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI= +github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk= +github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM= +github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ= +github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU= +github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k= +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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= +github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4= +github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4= +github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso= +github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE= +golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY= +golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610= +golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20= +golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= +golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +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/infra/README.md b/infra/README.md index 5a39e862..8a3e5840 100644 --- a/infra/README.md +++ b/infra/README.md @@ -1,7 +1,8 @@ -# Инфраструктура студента +# Инфраструктура lab4 -Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли. - -В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд. - -Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику. +- `haproxy/haproxy.cfg` — LB перед API-репликами (lab3). +- MinIO: образ `ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z` (официальные + `minio/minio` с Docker Hub сняты в 2026; community-сборка того же RELEASE). +- Bootstrap bucket/app-user: бинарь `/s3bootstrap` в образе API (minio-go + madmin), + без зависимости от снятого `minio/mc`. Политика — только List/Get/Put/Delete на + `messenger-attachments`. Консоль MinIO (`:9001`) **не публикуется**. diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..4782bd3e --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,52 @@ +# HAProxy — единственная публичная точка входа lab3. +# +# Backend-адреса берутся из Docker DNS имени сервиса `api` (A-записи всех реплик). +# server-template + resolvers перечитывает DNS; option httpchk снимает реплику, +# у которой /health/ready != 200 (в т.ч. после BeginDrain на SIGTERM). +# +# Оценка обнаружения отказа: +# inter 1s * fall 2 = ~2s по healthcheck + hold valid 2s у DNS ≈ до ~4s. +# Краткие 502/503 в это окно допустимы контрактом failover-теста. + +global + log stdout format raw local0 + maxconn 512 + +defaults + log global + mode http + option httplog + option dontlognull + timeout connect 2s + timeout client 15s + timeout server 15s + timeout check 1s + timeout http-keep-alive 10s + retries 2 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 2s + hold other 2s + hold refused 2s + hold nx 2s + hold timeout 2s + hold obsolete 2s + +frontend fe_http + bind *:8080 + default_backend be_api + +backend be_api + balance roundrobin + option httpchk + option redispatch + retry-on conn-failure empty-response response-timeout + http-check send meth GET uri /health/ready + http-check expect status 200 + # До 8 слотов под --scale api=N. init-addr last,libc,none ждёт DNS при старте. + # fall 3: чуть терпимее к краткому DNS-мерцанию при docker stop одной реплики. + server-template api 8 api:8080 check inter 1s fall 3 rise 1 resolvers docker resolve-prefer ipv4 init-addr last,libc,none diff --git a/infra/minio/app-policy.json b/infra/minio/app-policy.json new file mode 100644 index 00000000..4469eb80 --- /dev/null +++ b/infra/minio/app-policy.json @@ -0,0 +1,17 @@ +{ + "Version": "2012-10-17", + "Statement": [ + { + "Sid": "ListBucket", + "Effect": "Allow", + "Action": ["s3:ListBucket"], + "Resource": ["arn:aws:s3:::messenger-attachments"] + }, + { + "Sid": "ObjectRW", + "Effect": "Allow", + "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], + "Resource": ["arn:aws:s3:::messenger-attachments/*"] + } + ] +} diff --git a/infra/minio/bootstrap.sh b/infra/minio/bootstrap.sh new file mode 100755 index 00000000..c0e1e2e9 --- /dev/null +++ b/infra/minio/bootstrap.sh @@ -0,0 +1,32 @@ +#!/bin/sh +# Идемпотентный bootstrap приватного bucket и app-пользователя с ограниченной политикой. +# Root-ключи только здесь; API работает от S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY. +set -eu + +echo "waiting for minio..." +i=0 +until mc alias set local "http://${MINIO_ENDPOINT}" "${MINIO_ROOT_USER}" "${MINIO_ROOT_PASSWORD}" >/dev/null 2>&1; do + i=$((i + 1)) + if [ "$i" -gt 60 ]; then + echo "minio not ready" >&2 + exit 1 + fi + sleep 1 +done + +mc mb -p "local/${S3_BUCKET}" || true +mc anonymous set none "local/${S3_BUCKET}" + +# Пользователь приложения: повторный add не обязан быть успешен. +if ! mc admin user info local "${S3_ACCESS_KEY_ID}" >/dev/null 2>&1; then + mc admin user add local "${S3_ACCESS_KEY_ID}" "${S3_SECRET_ACCESS_KEY}" +fi +# Политика: create падает, если уже есть — это ок. +mc admin policy create local app-attachments /policy.json 2>/dev/null || \ + mc admin policy add local app-attachments /policy.json 2>/dev/null || true +mc admin policy attach local app-attachments --user "${S3_ACCESS_KEY_ID}" 2>/dev/null || \ + mc admin policy set local app-attachments user="${S3_ACCESS_KEY_ID}" 2>/dev/null || true + +echo "bucket=${S3_BUCKET} private=yes app_user=${S3_ACCESS_KEY_ID}" +mc anonymous get "local/${S3_BUCKET}" || true +echo "bootstrap done" diff --git a/internal/api/attachments.go b/internal/api/attachments.go new file mode 100644 index 00000000..fdea4ea9 --- /dev/null +++ b/internal/api/attachments.go @@ -0,0 +1,448 @@ +package api + +// Вложения lab4: загрузка, метаданные, скачивание. +// +// Загрузка (POST /chats/{id}/attachments?filename=...) идёт строго по шагам, и каждый шаг +// отсекает запрос как можно раньше и дешевле: +// +// 1. Bearer-аутентификация (requireUser), затем членство в чате: посторонний получает 404; +// 2. filename: 1–255 code points, без «/», «\», NUL и управляющих символов — иначе 400; +// 3. заявленный Content-Type — только image/png или image/jpeg, иначе 415; +// 4. тело копируется в спул (временный файл, при его отказе — память) с одновременным SHA-256 +// и жёстким лимитом MaxUploadBytes+1: больше лимита — 413. Тело не буферизуется целиком +// в куче через ReadAll, поэтому пик RAM на загрузку — буфер копирования, а не размер файла; +// 5. тип по содержимому (http.DetectContentType) обязан совпасть с заявленным, иначе 415 (подмена MIME); +// 6. размеры берутся из заголовка PNG/JPEG БЕЗ декодирования пикселей; больше +// MaxImagePixels — 413. Это делается до любой «распаковки»: bomb 60000×60000 весит килобайты; +// 7. дешёвая структурная проверка (PNG: CRC всех чанков и IEND, JPEG: EOI) ловит обрезанные +// и повреждённые файлы — 415; +// 8. PUT в S3 по серверному ключу originals/, затем INSERT метаданных. Только после +// обоих шагов — 201. Если INSERT не удался, объект удаляется сразу, а при отказе удаления +// его подберёт reconciler (cmd/reconcile) после grace period. +// +// До шага 8 в S3 ничего не пишется, поэтому оборванная загрузка клиента не оставляет объектов. + +import ( + "bufio" + "bytes" + "context" + "crypto/sha256" + "encoding/binary" + "encoding/hex" + "errors" + "hash/crc32" + "image" + _ "image/jpeg" // регистрирует декодер JPEG для image.DecodeConfig + "io" + "log" + "mime" + "net/http" + "os" + "strconv" + "strings" + "time" + "unicode" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/store" +) + +const ( + maxMessageAttachments = 10 + maxFilenameRunes = 255 + // После превышения лимита дочитываем (и выбрасываем) не больше этого объёма: + // клиент успевает получить 413, а не «connection reset» посреди своей отправки. + drainOnOverflow = 64 << 20 +) + +var ( + errBadImage = errors.New("not a valid png/jpeg image") + errTooManyPixels = errors.New("image has too many pixels") + errTooLarge = errors.New("upload exceeds size limit") +) + +func (s *Server) handleUploadAttachment(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 + } + uid := userFrom(r) + if err := s.Store.EnsureChatMember(r.Context(), chatID, uid); err != nil { + s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found") + return + } + + filename := r.URL.Query().Get("filename") + if !validFilename(filename) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid filename") + return + } + declared, ok := declaredImageType(r.Header.Get("Content-Type")) + if !ok { + writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "only image/png and image/jpeg are accepted") + return + } + // Клиент заранее заявил размер сильно больше лимита — не читаем ни байта. + if r.ContentLength > s.MaxUploadBytes+drainOnOverflow { + writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file is too large") + return + } + + sp, err := spoolBody(r.Body, s.MaxUploadBytes) + if err != nil { + switch { + case errors.Is(err, errTooLarge): + writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file is too large") + default: + // Обрыв чтения тела или таймаут клиента. Ничего не записано ни в S3, ни в БД. + writeError(w, r, http.StatusBadRequest, "invalid_request", "could not read request body") + } + return + } + defer sp.Close() + + if err := inspectImage(sp.reader(), sp.size, declared, s.MaxImagePixels); err != nil { + switch { + case errors.Is(err, errTooManyPixels): + writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "image has too many pixels") + default: + writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "invalid or unsupported image") + } + return + } + + id := uuid.New() + att := &store.Attachment{ + ID: id, + ChatID: chatID, + OwnerID: uid, + Filename: filename, + ContentType: declared, + SizeBytes: sp.size, + SHA256: sp.sum, + ObjectKey: blob.KeyPrefix + id.String(), + } + + // 1) S3. Тело отдаём как ReadSeeker: minio-go шлёт один PUT без буферизации в памяти. + if err := s.Blob.Put(r.Context(), att.ObjectKey, sp.reader(), sp.size, declared); err != nil { + s.writeBlobErr(w, r, err) + return + } + // 2) PostgreSQL. Ошибка здесь оставила бы объект без строки — убираем его сразу. + if err := s.Store.CreateAttachment(r.Context(), att); err != nil { + s.compensateOrphan(r, att.ObjectKey) + s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found") + return + } + writeJSON(w, http.StatusCreated, attachmentDTO(att)) +} + +// compensateOrphan удаляет объект, для которого не удалось записать метаданные. +// Контекст отвязан от запроса: клиент мог отключиться, а чистить всё равно нужно. +// Если и удаление не удалось (S3 мигнул), объект останется до reconciler — это допустимо. +func (s *Server) compensateOrphan(r *http.Request, key string) { + ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), 5*time.Second) + defer cancel() + if err := s.Blob.Delete(ctx, key); err != nil { + log.Printf("request_id=%s orphan_cleanup_failed key=%s (reconciler will remove after grace)", requestID(r), key) + } +} + +func (s *Server) handleGetAttachment(w http.ResponseWriter, r *http.Request) { + att, ok := s.loadAttachment(w, r) + if !ok { + return + } + writeJSON(w, http.StatusOK, attachmentDTO(att)) +} + +// handleDownloadAttachment отдаёт оригинал побайтно через API, без редиректа на S3: +// приватный bucket сам по себе не заменяет проверку членства в чате. +func (s *Server) handleDownloadAttachment(w http.ResponseWriter, r *http.Request) { + att, ok := s.loadAttachment(w, r) + if !ok { + return + } + // variant по умолчанию original. В lab4 вариантов нет (variants=[]), значит любой + // другой — «отсутствующий вариант ready-объекта», то есть 404. + if v := r.URL.Query().Get("variant"); v != "" && v != "original" { + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + switch att.Status { + case "ready": + default: + writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready") + return + } + rc, err := s.Blob.Get(r.Context(), att.ObjectKey) + if err != nil { + if errors.Is(err, blob.ErrNotFound) { + // Строка есть, объекта нет — несогласованность, её чинит reconciler. + log.Printf("request_id=%s attachment_object_missing id=%s", requestID(r), att.ID) + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + s.writeBlobErr(w, r, err) + return + } + defer rc.Close() + h := w.Header() + h.Set("Content-Type", att.ContentType) + h.Set("Content-Length", strconv.FormatInt(att.SizeBytes, 10)) + h.Set("X-Content-Type-Options", "nosniff") + h.Set("Cache-Control", "private, no-store") + w.WriteHeader(http.StatusOK) + if _, err := io.Copy(w, rc); err != nil { + // Заголовки уже ушли; клиент увидит обрыв. В лог — без деталей S3. + log.Printf("request_id=%s attachment_stream_error id=%s", requestID(r), att.ID) + } +} + +// loadAttachment разбирает {attachment_id} и проверяет членство в чате вложения. +func (s *Server) loadAttachment(w http.ResponseWriter, r *http.Request) (*store.Attachment, bool) { + id, err := uuid.Parse(r.PathValue("attachment_id")) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id") + return nil, false + } + att, err := s.Store.GetAttachment(r.Context(), id, userFrom(r)) + if err != nil { + s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found") + return nil, false + } + return att, true +} + +// writeBlobErr: недоступный S3 — 503, остальное — 500. Текст ошибки клиенту не уходит. +func (s *Server) writeBlobErr(w http.ResponseWriter, r *http.Request, err error) { + if errors.Is(err, blob.ErrUnavailable) { + log.Printf("request_id=%s s3_unavailable", requestID(r)) + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable") + return + } + log.Printf("request_id=%s blob_error_type=%T", requestID(r), err) + writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error") +} + +func attachmentDTO(a *store.Attachment) map[string]any { + var errCode any + if a.ErrorCode != nil { + errCode = *a.ErrorCode + } + return map[string]any{ + "id": a.ID.String(), + "chat_id": a.ChatID.String(), + "owner_id": a.OwnerID.String(), + "filename": a.Filename, + "content_type": a.ContentType, + "size_bytes": a.SizeBytes, + "sha256": a.SHA256, + "status": a.Status, + "variants": []any{}, + "error_code": errCode, + "created_at": formatTime(a.CreatedAt), + "updated_at": formatTime(a.UpdatedAt), + } +} + +// validFilename: 1–255 code points, валидный UTF-8, не «пустой» после TrimSpace. +// «/», «\», NUL и управляющие символы запрещены: имя только отображается и никогда не +// становится путём или ключом S3. «.» и «..» отвергаются как заведомо опасные. +func validFilename(name string) bool { + if !utf8.ValidString(name) || strings.TrimSpace(name) == "" { + return false + } + if n := utf8.RuneCountInString(name); n < 1 || n > maxFilenameRunes { + return false + } + if name == "." || name == ".." { + return false + } + for _, c := range name { + if c == '/' || c == '\\' || c == 0 || unicode.IsControl(c) { + return false + } + } + return true +} + +// declaredImageType возвращает заявленный Content-Type без параметров, если он разрешён. +func declaredImageType(header string) (string, bool) { + mt, _, err := mime.ParseMediaType(header) + if err != nil { + return "", false + } + switch mt { + case "image/png", "image/jpeg": + return mt, true + } + return "", false +} + +// spooled — принятое тело: размер, SHA-256 и произвольный доступ для проверок и PUT. +type spooled struct { + ra io.ReaderAt + size int64 + sum string + cleanup func() +} + +func (s *spooled) reader() *io.SectionReader { return io.NewSectionReader(s.ra, 0, s.size) } +func (s *spooled) Close() { s.cleanup() } + +// spoolBody читает тело не больше max байт. Временный файл защищает кучу от 10 одновременных +// загрузок по 10 MiB; если /tmp недоступен, откатываемся на память (всё равно ограниченную max). +func spoolBody(body io.Reader, max int64) (*spooled, error) { + h := sha256.New() + f, ferr := os.CreateTemp("", "upload-*") + var ( + dst io.Writer + buf *bytes.Buffer + cleanup = func() {} + ) + if ferr == nil { + cleanup = func() { _ = f.Close(); _ = os.Remove(f.Name()) } + dst = io.MultiWriter(f, h) + } else { + buf = &bytes.Buffer{} + dst = io.MultiWriter(buf, h) + } + n, err := io.Copy(dst, io.LimitReader(body, max+1)) + if err != nil { + cleanup() + return nil, err + } + if n > max { + cleanup() + _, _ = io.CopyN(io.Discard, body, drainOnOverflow) + return nil, errTooLarge + } + sp := &spooled{size: n, sum: hex.EncodeToString(h.Sum(nil)), cleanup: cleanup} + if f != nil && ferr == nil { + sp.ra = f + } else { + sp.ra = bytes.NewReader(buf.Bytes()) + } + return sp, nil +} + +// inspectImage проверяет содержимое. Порядок важен: тип → размеры из заголовка (лимит +// пикселей до любой распаковки) → структура файла. +func inspectImage(sr *io.SectionReader, size int64, declared string, maxPixels int64) error { + head := make([]byte, 512) + n, _ := sr.ReadAt(head, 0) + detected := "" + if n > 0 { + detected = http.DetectContentType(head[:n]) + } + if size < 1 || (detected != "image/png" && detected != "image/jpeg") || detected != declared { + return errBadImage + } + + var w, h int64 + switch detected { + case "image/png": + // IHDR всегда первый чанк: 8 байт сигнатуры, 4 длина, 4 тип, затем width/height. + // Читаем сами: image/png.DecodeConfig отвергает файл с битым CRC раньше, чем + // мы успели бы честно ответить «слишком много пикселей». + if n < 24 || string(head[12:16]) != "IHDR" || binary.BigEndian.Uint32(head[8:12]) != 13 { + return errBadImage + } + w = int64(binary.BigEndian.Uint32(head[16:20])) + h = int64(binary.BigEndian.Uint32(head[20:24])) + case "image/jpeg": + cfg, _, err := image.DecodeConfig(io.NewSectionReader(sr, 0, size)) + if err != nil { + return errBadImage + } + w, h = int64(cfg.Width), int64(cfg.Height) + } + if w < 1 || h < 1 { + return errBadImage + } + if w*h > maxPixels { + return errTooManyPixels + } + + if detected == "image/png" { + return verifyPNG(io.NewSectionReader(sr, 0, size), size) + } + return verifyJPEGTail(sr, size) +} + +// verifyPNG обходит чанки и проверяет их CRC без декомпрессии IDAT: обрезанный или +// испорченный PNG отвергается за один линейный проход по файлу. +func verifyPNG(r io.Reader, size int64) error { + br := bufio.NewReaderSize(r, 64<<10) + if _, err := br.Discard(8); err != nil { // сигнатура уже проверена DetectContentType + return errBadImage + } + consumed := int64(8) + var ( + hdr [8]byte + crcBuf [4]byte + first = true + sawIDAT bool + sawIEND bool + crcHasher = crc32.NewIEEE() + ) + for !sawIEND { + if _, err := io.ReadFull(br, hdr[:]); err != nil { + return errBadImage + } + length := int64(binary.BigEndian.Uint32(hdr[0:4])) + ctype := string(hdr[4:8]) + if length > size-consumed-12 { + return errBadImage + } + if first && ctype != "IHDR" { + return errBadImage + } + first = false + crcHasher.Reset() + _, _ = crcHasher.Write(hdr[4:8]) + if _, err := io.CopyN(crcHasher, br, length); err != nil { + return errBadImage + } + if _, err := io.ReadFull(br, crcBuf[:]); err != nil { + return errBadImage + } + if crcHasher.Sum32() != binary.BigEndian.Uint32(crcBuf[:]) { + return errBadImage + } + consumed += 12 + length + switch ctype { + case "IDAT": + sawIDAT = true + case "IEND": + sawIEND = true + } + } + // Данные после IEND — признак полиглота или склейки файлов, не принимаем. + if !sawIDAT || consumed != size { + return errBadImage + } + return nil +} + +// verifyJPEGTail требует маркер конца изображения EOI (FF D9) в хвосте файла. +// Допускаются нулевые/мусорные байты выравнивания после него (до 1 KiB). +func verifyJPEGTail(sr *io.SectionReader, size int64) error { + tailLen := int64(1024) + if size < tailLen { + tailLen = size + } + tail := make([]byte, tailLen) + if _, err := sr.ReadAt(tail, size-tailLen); err != nil && !errors.Is(err, io.EOF) { + return errBadImage + } + if bytes.LastIndex(tail, []byte{0xFF, 0xD9}) < 0 { + return errBadImage + } + return nil +} diff --git a/internal/api/server.go b/internal/api/server.go new file mode 100644 index 00000000..ef0857bb --- /dev/null +++ b/internal/api/server.go @@ -0,0 +1,780 @@ +// Package api — HTTP-слой lab4 (поверх lab3: LB, идемпотентность, сессии в Redis). +// +// Порядок обработки запроса: +// 1. X-Request-Id и X-Instance-Id на каждый ответ, включая ошибки; +// 2. журнал method/path/status без текста сообщений и без токена; +// 3. маршрут; +// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают. +// +// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL, Redis и S3: +// без них нельзя честно принять запись или узнать, кто делает запрос. +// +// POST сообщения требует Idempotency-Key; результат хранится в общей БД, а не в памяти реплики. +// +// Вложения (attachments.go): сырой PNG/JPEG в теле POST, байты в приватном S3, метаданные в +// PostgreSQL. Скачивание — только через этот API, без редиректа на S3. +package api + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "log" + "net/http" + "os" + "strconv" + "strings" + "sync/atomic" + "time" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/session" + "mtusi2026lab4/internal/store" +) + +type ctxKey int + +const ( + userKey ctxKey = iota + tokenKey + requestIDKey +) + +const ( + challengeBasic = `Basic realm="messenger", charset="UTF-8"` + challengeBearer = `Bearer realm="messenger"` +) + +// Лимиты вложений по контракту lab4. +const ( + DefaultMaxUploadBytes int64 = 10 << 20 // 10 MiB = 10 485 760 + DefaultMaxImagePixels int64 = 40_000_000 +) + +// BlobStore — то, что API требует от S3-клиента. *blob.Client его реализует; +// интерфейс нужен, чтобы тест мог подставить недоступное хранилище. +type BlobStore interface { + Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error + Get(ctx context.Context, key string) (io.ReadCloser, error) + Delete(ctx context.Context, key string) error + Ping(ctx context.Context) error +} + +var _ BlobStore = (*blob.Client)(nil) + +// Server связывает HTTP с PostgreSQL, Redis и S3. +type Server struct { + Store *store.Store + Sessions *session.Store + Blob BlobStore + InstanceID string + // Лимиты загрузки. По умолчанию контрактные; main.go может только ужесточить. + MaxUploadBytes int64 + MaxImagePixels int64 + ready atomic.Bool +} + +// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready. +// instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса. +func New(st *store.Store, sessions *session.Store, bl BlobStore, instanceID string) *Server { + s := &Server{ + Store: st, Sessions: sessions, Blob: bl, InstanceID: instanceID, + MaxUploadBytes: DefaultMaxUploadBytes, + MaxImagePixels: DefaultMaxImagePixels, + } + s.ready.Store(true) + return s +} + +// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready. +// HAProxy/Traefik с httpchk на /health/ready перестаёт слать трафик на эту реплику. +func (s *Server) BeginDrain() { s.ready.Store(false) } + +// Handler собирает маршруты lab4. +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)) + mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", s.requireUser(s.handleUploadAttachment)) + mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", s.requireUser(s.handleGetAttachment)) + mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", s.requireUser(s.handleDownloadAttachment)) + return s.withInstanceID(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 + } + // S3 — обязательная зависимость синхронного пути (загрузка и скачивание вложений). + if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil || + s.Blob.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) { + // Контракт: только Basic, без JSON body. Любые байты в теле — 400, не тихий игнор. + rawBody, err := io.ReadAll(io.LimitReader(r.Body, 4096)) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid body") + return + } + if len(bytes.TrimSpace(rawBody)) != 0 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "session create must not have a body") + return + } + 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 + } + idemKey := r.Header.Get("Idempotency-Key") + if !validIdempotencyKey(idemKey) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing Idempotency-Key") + return + } + var body struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` + } + if err := decodeStrict(r, &body); err != nil { + writeDecodeErr(w, r, err) + return + } + // attachment_ids: 0–10 уникальных UUID; отсутствующий ключ, null и [] равны для хэша. + if len(body.AttachmentIDs) > maxMessageAttachments { + writeError(w, r, http.StatusBadRequest, "invalid_request", "too many attachments") + return + } + attachmentIDs := make([]uuid.UUID, 0, len(body.AttachmentIDs)) + canonicalIDs := make([]string, 0, len(body.AttachmentIDs)) + seenAtt := make(map[uuid.UUID]struct{}, len(body.AttachmentIDs)) + for _, raw := range body.AttachmentIDs { + id, err := uuid.Parse(raw) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id") + return + } + if _, dup := seenAtt[id]; dup { + writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate attachment id") + return + } + seenAtt[id] = struct{}{} + attachmentIDs = append(attachmentIDs, id) + canonicalIDs = append(canonicalIDs, id.String()) + } + // Длина — по исходному тексту. Непустота — по TrimSpace, но только если вложений нет: + // text="" с хотя бы одним вложением разрешён контрактом lab4. + // Пробелы по краям сохраняются как есть, иначе «пробел + 4000 букв» проходил бы как 4000. + if utf8.RuneCountInString(body.Text) > 4000 || + (len(attachmentIDs) == 0 && strings.TrimSpace(body.Text) == "") { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text") + return + } + path := "/api/v1/chats/" + chatID.String() + "/messages" + reqHash := idempotencyRequestHash(body.Text, canonicalIDs) + result, err := s.Store.CreateMessageIdempotent( + r.Context(), chatID, userFrom(r), body.Text, attachmentIDs, + http.MethodPost, path, idemKey, reqHash, + ) + if errors.Is(err, store.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "object not found") + return + } + if errors.Is(err, store.ErrIdempotencyConflict) { + writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body") + return + } + if errors.Is(err, store.ErrNotReady) { + writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready") + return + } + if err != nil { + s.writeStoreErr(w, r, err, 0, "", "") + return + } + writeJSON(w, http.StatusCreated, messageDTO(result.Message)) +} + +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))) + }) +} + +func (s *Server) withInstanceID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Instance-Id", s.InstanceID) + next.ServeHTTP(w, r) + }) +} + +// validIdempotencyKey — ASCII [A-Za-z0-9._:-]{1,128}. +func validIdempotencyKey(key string) bool { + if len(key) < 1 || len(key) > 128 { + return false + } + for i := 0; i < len(key); i++ { + c := key[i] + switch { + case c >= 'A' && c <= 'Z', c >= 'a' && c <= 'z', c >= '0' && c <= '9': + case c == '.', c == '_', c == ':', c == '-': + default: + return false + } + } + return true +} + +// idempotencyRequestHash канонизирует тело: порядок ключей JSON не важен, +// отсутствующий attachment_ids равен []. Хэш — SHA-256 hex. +func idempotencyRequestHash(text string, attachmentIDs []string) string { + if attachmentIDs == nil { + attachmentIDs = []string{} + } + payload, _ := json.Marshal(struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` + }{Text: text, AttachmentIDs: attachmentIDs}) + sum := sha256.Sum256(payload) + return hex.EncodeToString(sum[:]) +} + +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 + } + // Читаем тело целиком: Decoder.More() не ловит хвост вида {"text":"x"}} — + // после одного объекта More()=false, а лишняя скобка всё равно остаётся. + raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) + if err != nil { + return errMalformed + } + dec := json.NewDecoder(bytes.NewReader(raw)) + dec.DisallowUnknownFields() + if err := dec.Decode(dst); err != nil { + return errMalformed + } + rest := bytes.TrimSpace(raw[dec.InputOffset():]) + if len(rest) != 0 { + 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 { + // Всегда массив, даже пустой: клиент lab3 без вложений видит [] (контракт 1.4.0). + att := make([]string, len(m.AttachmentIDs)) + for i, id := range m.AttachmentIDs { + att[i] = id.String() + } + return map[string]any{ + "id": m.ID.String(), + "chat_id": m.ChatID.String(), + "sender_id": m.SenderID.String(), + "text": m.Text, + "attachment_ids": att, + "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.ErrIdempotencyConflict): + writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body") + 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/blob/memory.go b/internal/blob/memory.go new file mode 100644 index 00000000..86780877 --- /dev/null +++ b/internal/blob/memory.go @@ -0,0 +1,162 @@ +package blob + +import ( + "bytes" + "context" + "io" + "sync" + "time" +) + +// Memory — in-memory BlobStore для student-tests без живого MinIO. +// Не для production: нет persistence между процессами. +type Memory struct { + mu sync.Mutex + objects map[string]memObj + down bool + bucketOK bool + now func() time.Time +} + +type memObj struct { + data []byte + modTime time.Time +} + +// NewMemory создаёт пустое хранилище с «живым» бакетом. +func NewMemory() *Memory { + return &Memory{ + objects: make(map[string]memObj), + bucketOK: true, + now: time.Now, + } +} + +// SetUnavailable имитирует падение S3 (Ping/Put/Get → ErrUnavailable). +func (m *Memory) SetUnavailable(v bool) { m.mu.Lock(); m.down = v; m.mu.Unlock() } + +func (m *Memory) Bucket() string { return "memory" } + +func (m *Memory) Ping(ctx context.Context) error { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down || !m.bucketOK { + return ErrUnavailable + } + return nil +} + +func (m *Memory) Put(ctx context.Context, key string, r io.Reader, size int64, _ string) error { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down { + return ErrUnavailable + } + data, err := io.ReadAll(io.LimitReader(r, size+1)) + if err != nil { + return err + } + if int64(len(data)) != size { + return ErrUnavailable + } + m.objects[key] = memObj{data: append([]byte(nil), data...), modTime: m.now()} + return nil +} + +func (m *Memory) Get(ctx context.Context, key string) (io.ReadCloser, error) { + select { + case <-ctx.Done(): + return nil, ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down { + return nil, ErrUnavailable + } + o, ok := m.objects[key] + if !ok { + return nil, ErrNotFound + } + return io.NopCloser(bytes.NewReader(o.data)), nil +} + +func (m *Memory) Stat(ctx context.Context, key string) (ObjectInfo, error) { + select { + case <-ctx.Done(): + return ObjectInfo{}, ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down { + return ObjectInfo{}, ErrUnavailable + } + o, ok := m.objects[key] + if !ok { + return ObjectInfo{}, ErrNotFound + } + return ObjectInfo{Key: key, Size: int64(len(o.data)), LastModified: o.modTime}, nil +} + +func (m *Memory) Delete(ctx context.Context, key string) error { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down { + return ErrUnavailable + } + delete(m.objects, key) + return nil +} + +func (m *Memory) ListKeys(ctx context.Context, prefix string) ([]ObjectInfo, error) { + select { + case <-ctx.Done(): + return nil, ctx.Err() + default: + } + m.mu.Lock() + defer m.mu.Unlock() + if m.down { + return nil, ErrUnavailable + } + var out []ObjectInfo + for k, o := range m.objects { + if len(prefix) == 0 || (len(k) >= len(prefix) && k[:len(prefix)] == prefix) { + out = append(out, ObjectInfo{Key: k, Size: int64(len(o.data)), LastModified: o.modTime}) + } + } + return out, nil +} + +// Seed кладёт объект напрямую (для тестов reconciler). +func (m *Memory) Seed(key string, data []byte, modTime time.Time) { + m.mu.Lock() + defer m.mu.Unlock() + if modTime.IsZero() { + modTime = m.now() + } + m.objects[key] = memObj{data: append([]byte(nil), data...), modTime: modTime} +} + +var _ interface { + Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error + Get(ctx context.Context, key string) (io.ReadCloser, error) + Delete(ctx context.Context, key string) error + Ping(ctx context.Context) error +} = (*Memory)(nil) diff --git a/internal/blob/minio.go b/internal/blob/minio.go new file mode 100644 index 00000000..c1527bc8 --- /dev/null +++ b/internal/blob/minio.go @@ -0,0 +1,197 @@ +// Package blob — тонкая обёртка над MinIO (S3 API) для оригиналов вложений lab4. +// +// Байты файлов живут только здесь, а не в PostgreSQL и не на диске API-реплики. +// Ключ объекта назначает сервер (originals/); filename клиента в ключ не попадает. +// Bucket приватный: прямого доступа без подписи нет, скачивание идёт через авторизованный API. +// +// Ошибки сведены к двум классам, чтобы HTTP-слой не знал про minio-go: +// ErrNotFound — объекта нет (404/500 по контексту), ErrUnavailable — S3 недоступен (503). +package blob + +import ( + "context" + "errors" + "fmt" + "io" + "net" + "net/http" + "time" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +// KeyPrefix — префикс ключей оригиналов. Reconciler обходит только его. +const KeyPrefix = "originals/" + +var ( + // ErrNotFound — такого объекта в бакете нет. + ErrNotFound = errors.New("blob: not found") + // ErrUnavailable — S3 не отвечает, отказал в доступе или вернул неожиданную ошибку. + ErrUnavailable = errors.New("blob: unavailable") +) + +// Config — параметры подключения. Секреты приходят из окружения/файла, в логи не попадают. +type Config struct { + Endpoint string // host:port без схемы, например minio:9000 + UseSSL bool + Region string + Bucket string + AccessKey string + SecretKey string +} + +// ObjectInfo — то, что reconciler и тесты знают об объекте. +type ObjectInfo struct { + Key string + Size int64 + LastModified time.Time +} + +// Client — клиент одного бакета. +type Client struct { + mc *minio.Client + bucket string +} + +// New создаёт клиента. Сеть не трогает: доступность проверяют Ping/EnsureBucket. +// +// Таймауты заданы явно. Без них connection refused ретраится minio-go десяток раз, +// и «S3 лежит» вместо быстрого 503 превращается в зависший запрос. +func New(cfg Config) (*Client, error) { + if cfg.Endpoint == "" || cfg.Bucket == "" { + return nil, fmt.Errorf("blob: endpoint and bucket are required") + } + tr := &http.Transport{ + Proxy: nil, + DialContext: (&net.Dialer{ + Timeout: 2 * time.Second, + KeepAlive: 30 * time.Second, + }).DialContext, + MaxIdleConns: 64, + MaxIdleConnsPerHost: 32, + IdleConnTimeout: 60 * time.Second, + TLSHandshakeTimeout: 3 * time.Second, + ResponseHeaderTimeout: 20 * time.Second, + } + mc, err := minio.New(cfg.Endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""), + Secure: cfg.UseSSL, + Region: cfg.Region, + Transport: tr, + MaxRetries: 2, + }) + if err != nil { + return nil, fmt.Errorf("blob: init client: %w", err) + } + return &Client{mc: mc, bucket: cfg.Bucket}, nil +} + +// Bucket возвращает имя бакета (для логов и отчётов). +func (c *Client) Bucket() string { return c.bucket } + +// EnsureBucket создаёт бакет, если его нет. Идемпотентно. +// В Compose бакет создаёт minio-init с root-правами, а у app-пользователя прав на +// создание нет — функция нужна локальным тестам и ручному запуску на «голом» MinIO. +func (c *Client) EnsureBucket(ctx context.Context) error { + ok, err := c.mc.BucketExists(ctx, c.bucket) + if err != nil { + return classify(err) + } + if ok { + return nil + } + if err := c.mc.MakeBucket(ctx, c.bucket, minio.MakeBucketOptions{}); err != nil { + // Гонка двух инициализаторов: бакет уже создан соседом. + code := minio.ToErrorResponse(err).Code + if code == "BucketAlreadyOwnedByYou" || code == "BucketAlreadyExists" { + return nil + } + return classify(err) + } + return nil +} + +// Ping — проверка для /health/ready. Короткий таймаут: readiness не должна висеть. +func (c *Client) Ping(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond) + defer cancel() + ok, err := c.mc.BucketExists(ctx, c.bucket) + if err != nil || !ok { + return ErrUnavailable + } + return nil +} + +// Put кладёт объект известного размера. r должен уметь Seek (файл или bytes.Reader): +// тогда minio-go отправляет тело одним запросом без буферизации в памяти. +func (c *Client) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error { + _, err := c.mc.PutObject(ctx, c.bucket, key, r, size, minio.PutObjectOptions{ + ContentType: contentType, + // Один PUT для файлов до лимита lab4 (10 MiB): multipart не нужен. + DisableMultipart: true, + }) + return classify(err) +} + +// Get открывает объект на чтение. Существование проверяется сразу (Stat), чтобы HTTP-слой +// успел вернуть 404/503 до отправки заголовков 200. +func (c *Client) Get(ctx context.Context, key string) (io.ReadCloser, error) { + obj, err := c.mc.GetObject(ctx, c.bucket, key, minio.GetObjectOptions{}) + if err != nil { + return nil, classify(err) + } + if _, err := obj.Stat(); err != nil { + _ = obj.Close() + return nil, classify(err) + } + return obj, nil +} + +// Stat возвращает метаданные объекта или ErrNotFound. +func (c *Client) Stat(ctx context.Context, key string) (ObjectInfo, error) { + st, err := c.mc.StatObject(ctx, c.bucket, key, minio.StatObjectOptions{}) + if err != nil { + return ObjectInfo{}, classify(err) + } + return ObjectInfo{Key: st.Key, Size: st.Size, LastModified: st.LastModified}, nil +} + +// Delete удаляет объект. Отсутствие объекта — не ошибка (S3 DELETE идемпотентен). +func (c *Client) Delete(ctx context.Context, key string) error { + err := c.mc.RemoveObject(ctx, c.bucket, key, minio.RemoveObjectOptions{}) + if err != nil && errors.Is(classify(err), ErrNotFound) { + return nil + } + return classify(err) +} + +// ListKeys возвращает все объекты с префиксом (рекурсивно). Для reconciler: +// стоимость обхода — O(число объектов), память — по записи на объект. +func (c *Client) ListKeys(ctx context.Context, prefix string) ([]ObjectInfo, error) { + var out []ObjectInfo + for o := range c.mc.ListObjects(ctx, c.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) { + if o.Err != nil { + return nil, classify(o.Err) + } + out = append(out, ObjectInfo{Key: o.Key, Size: o.Size, LastModified: o.LastModified}) + } + return out, nil +} + +// classify сводит ошибки minio-go к ErrNotFound/ErrUnavailable. Текст исходной ошибки +// наружу не возвращаем: в нём могут быть endpoint и имя бакета. +func classify(err error) error { + if err == nil { + return nil + } + switch minio.ToErrorResponse(err).Code { + case "NoSuchKey", "NotFound": + return ErrNotFound + } + if minio.ToErrorResponse(err).StatusCode == http.StatusNotFound && + minio.ToErrorResponse(err).Code != "NoSuchBucket" { + return ErrNotFound + } + return ErrUnavailable +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..9caac942 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,189 @@ +// Package config читает настройки процесса из окружения. +// +// Для lab4 добавлены S3_* и лимиты вложений. +// +// Прямые 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 + InstanceID string + MaxConns int32 + RunMigrations bool + IdempotencyTTL time.Duration + + // Лимиты вложений (lab4). Контракт: 10 MiB и 40 млн пикселей. + MaxUploadBytes int64 + MaxImagePixels int64 + // ReconcileGrace — минимальный возраст объекта/строки, прежде чем reconciler их тронет. + ReconcileGrace time.Duration +} + +// S3 — параметры подключения к S3-совместимому хранилищу. +type S3 struct { + Endpoint string + UseSSL bool + Region string + Bucket string + AccessKey string + SecretKey string +} + +// 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 + + idemTTL, err := strconv.Atoi(getenv("IDEMPOTENCY_TTL_SECONDS", "86400")) + if err != nil || idemTTL < 60 || idemTTL > 7*24*3600 { + return cfg, fmt.Errorf("invalid IDEMPOTENCY_TTL_SECONDS") + } + cfg.IdempotencyTTL = time.Duration(idemTTL) * time.Second + + maxConns, err := strconv.Atoi(getenv("DB_MAX_CONNS", "5")) + if err != nil || maxConns < 1 || maxConns > 50 { + return cfg, fmt.Errorf("invalid DB_MAX_CONNS") + } + cfg.MaxConns = int32(maxConns) + + 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 + } + + cfg.InstanceID = strings.TrimSpace(os.Getenv("INSTANCE_ID")) + if cfg.InstanceID == "" { + host, herr := os.Hostname() + if herr != nil || strings.TrimSpace(host) == "" { + return cfg, fmt.Errorf("set INSTANCE_ID or ensure hostname is available") + } + cfg.InstanceID = host + } + + cfg.MaxUploadBytes, err = getenvInt64("MAX_UPLOAD_BYTES", 10485760, 1, 10485760) + if err != nil { + return cfg, err + } + cfg.MaxImagePixels, err = getenvInt64("MAX_IMAGE_PIXELS", 40000000, 1, 40000000) + if err != nil { + return cfg, err + } + graceSec, err := getenvInt64("S3_RECONCILE_GRACE_SECONDS", 60, 0, 7*24*3600) + if err != nil { + return cfg, err + } + cfg.ReconcileGrace = time.Duration(graceSec) * time.Second + + cfg.RunMigrations = truthy(os.Getenv("RUN_MIGRATIONS")) + return cfg, nil +} + +// LoadS3 читает настройки S3. Ключи — из S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY +// либо из файлов *_FILE. Пустые ключи — ошибка запуска API (migrate без S3 обходится). +func LoadS3() (S3, error) { + var ( + c S3 + err error + ) + c.Endpoint = getenv("S3_ENDPOINT", "minio:9000") + // Endpoint может прийти со схемой http:// — minio-go ждёт host:port. + c.Endpoint = strings.TrimPrefix(c.Endpoint, "https://") + c.Endpoint = strings.TrimPrefix(c.Endpoint, "http://") + c.Region = getenv("S3_REGION", "us-east-1") + c.Bucket = getenv("S3_BUCKET", "messenger-attachments") + c.UseSSL = truthy(os.Getenv("S3_USE_SSL")) + c.AccessKey, err = getenvOrFile("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE") + if err != nil { + return c, err + } + c.SecretKey, err = getenvOrFile("S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE") + if err != nil { + return c, err + } + return c, 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 getenvInt64(key string, fallback, lo, hi int64) (int64, error) { + raw := strings.TrimSpace(os.Getenv(key)) + if raw == "" { + return fallback, nil + } + n, err := strconv.ParseInt(raw, 10, 64) + if err != nil || n < lo || n > hi { + return 0, fmt.Errorf("invalid %s", key) + } + return n, nil +} + +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 +} + +func truthy(v string) bool { + switch strings.ToLower(strings.TrimSpace(v)) { + case "1", "true", "yes", "on": + return true + default: + return false + } +} 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/attachments.go b/internal/store/attachments.go new file mode 100644 index 00000000..7dfde9d5 --- /dev/null +++ b/internal/store/attachments.go @@ -0,0 +1,209 @@ +// Вложения lab4: метаданные в PostgreSQL, байты в S3 (пакет blob). +// +// Согласованность двух хранилищ строится на порядке «сначала S3, потом БД»: +// 1. PUT объекта в S3 по серверному ключу; +// 2. INSERT строки attachments. +// +// Если PUT прошёл, а INSERT нет, остаётся объект без строки (orphan). API пытается удалить +// его сразу, а если не вышло, его удалит reconciler после grace period. Обратный порядок +// опаснее: строка без объекта отдавала бы клиенту 201 на файл, которого нет. +package store + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" +) + +// ErrNotReady — вложение существует в этом чате, но ещё не ready (в lab4 недостижимо, +// зарезервировано под асинхронную обработку lab5). +var ErrNotReady = errors.New("attachment not ready") + +// Attachment — метаданные оригинала. ObjectKey во внешний JSON не попадает. +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + ContentType string + SizeBytes int64 + SHA256 string + ObjectKey string + Status string + ErrorCode *string + CreatedAt time.Time + UpdatedAt time.Time +} + +// CreateAttachment пишет метаданные после успешного PUT в S3. ID и ObjectKey задаёт вызывающий: +// ключ нужен до записи в БД. Членство в чате проверяется в самом INSERT — если автора уже +// нет в чате, строка не появится и вернётся ErrNotFound. +func (s *Store) CreateAttachment(ctx context.Context, a *Attachment) error { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + now := nowUTC() + a.Status = "ready" + a.ErrorCode = nil + a.CreatedAt, a.UpdatedAt = now, now + tag, err := s.pool.Exec(ctx, ` + INSERT INTO attachments ( + id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + object_key, status, error_code, created_at, updated_at + ) + SELECT $1, $2, $3, $4, $5, $6, $7, $8, $9, NULL, $10, $10 + WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3)`, + a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, + a.ObjectKey, a.Status, a.CreatedAt) + if err != nil { + return mapWriteErr(err) + } + if tag.RowsAffected() != 1 { + return ErrNotFound + } + return nil +} + +// GetAttachment отдаёт вложение только участнику его чата. Чужому и несуществующему — +// одинаковый ErrNotFound (HTTP 404): наличие чужого файла не раскрываем. +func (s *Store) GetAttachment(ctx context.Context, id, userID uuid.UUID) (*Attachment, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var a Attachment + err := s.pool.QueryRow(ctx, ` + SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, + a.object_key, a.status, a.error_code, a.created_at, a.updated_at + FROM attachments a + JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2 + WHERE a.id = $1`, id, userID).Scan( + &a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, + &a.ObjectKey, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, mapWriteErr(err) + } + return &a, nil +} + +// EnsureChatMember — публичная проверка «пользователь состоит в чате» (ErrNotFound иначе). +func (s *Store) EnsureChatMember(ctx context.Context, chatID, userID uuid.UUID) error { + return s.ensureMember(ctx, chatID, userID) +} + +// ListAttachmentIDsForMessage возвращает ID вложений сообщения в порядке запроса. +// Пустой результат — непустой срез нулевой длины, чтобы JSON дал [], а не null. +func (s *Store) ListAttachmentIDsForMessage(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + byMsg, err := attachmentIDsByMessage(ctx, s.pool, []uuid.UUID{messageID}) + if err != nil { + return nil, err + } + return byMsg[messageID], nil +} + +// querier — общая часть pgxpool.Pool и pgx.Tx. +type querier interface { + Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) +} + +// attachmentIDsByMessage — один запрос на страницу сообщений (без N+1). +// Все ключи результата заполнены: у сообщений без вложений значение — пустой срез. +// +// q — пул или транзакция: внутри транзакции запрос обязан идти по её соединению, иначе при +// маленьком пуле транзакция занимает соединение и ждёт второе. +func attachmentIDsByMessage(ctx context.Context, q querier, messageIDs []uuid.UUID) (map[uuid.UUID][]uuid.UUID, error) { + out := make(map[uuid.UUID][]uuid.UUID, len(messageIDs)) + if len(messageIDs) == 0 { + return out, nil + } + strs := make([]string, len(messageIDs)) + for i, id := range messageIDs { + out[id] = []uuid.UUID{} + strs[i] = id.String() + } + rows, err := q.Query(ctx, ` + SELECT message_id, attachment_id + FROM message_attachments + WHERE message_id = ANY($1::uuid[]) + ORDER BY message_id, position`, strs) + if err != nil { + return nil, mapWriteErr(err) + } + defer rows.Close() + for rows.Next() { + var mid, aid uuid.UUID + if err := rows.Scan(&mid, &aid); err != nil { + return nil, mapWriteErr(err) + } + out[mid] = append(out[mid], aid) + } + return out, mapWriteErr(rows.Err()) +} + +// AttachmentRef — строка attachments для reconciler: только то, что нужно для сверки с S3. +type AttachmentRef struct { + ID uuid.UUID + ObjectKey string + SizeBytes int64 + CreatedAt time.Time + Referenced bool // есть ли хотя бы одно сообщение со ссылкой на файл +} + +// ListAttachmentRefs — keyset-страница по id. Страницы небольшие: у соединения +// statement_timeout 3 с, один огромный SELECT на большой таблице под него не уложится. +func (s *Store) ListAttachmentRefs(ctx context.Context, after uuid.UUID, limit int) ([]AttachmentRef, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + rows, err := s.pool.Query(ctx, ` + SELECT a.id, a.object_key, a.size_bytes, a.created_at, + EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id) + FROM attachments a + WHERE a.id > $1 + ORDER BY a.id + LIMIT $2`, after, limit) + if err != nil { + return nil, mapWriteErr(err) + } + defer rows.Close() + var out []AttachmentRef + for rows.Next() { + var r AttachmentRef + if err := rows.Scan(&r.ID, &r.ObjectKey, &r.SizeBytes, &r.CreatedAt, &r.Referenced); err != nil { + return nil, mapWriteErr(err) + } + out = append(out, r) + } + return out, mapWriteErr(rows.Err()) +} + +// AttachmentKeyExists — повторная проверка перед удалением orphan: между листингом S3 +// и удалением объект мог получить строку (загрузка закончилась). Это страховка поверх grace. +func (s *Store) AttachmentKeyExists(ctx context.Context, objectKey string) (bool, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + var ok bool + err := s.pool.QueryRow(ctx, + `SELECT EXISTS (SELECT 1 FROM attachments WHERE object_key = $1)`, objectKey).Scan(&ok) + return ok, mapWriteErr(err) +} + +// DeleteUnreferencedAttachment удаляет строку, только если на неё нет ссылок из сообщений. +// Условие NOT EXISTS в самом DELETE закрывает гонку «сообщение прикрепили, пока мы решали». +// Возвращает true, если строка была удалена. +func (s *Store) DeleteUnreferencedAttachment(ctx context.Context, id uuid.UUID) (bool, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + tag, err := s.pool.Exec(ctx, ` + DELETE FROM attachments a + WHERE a.id = $1 + AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id)`, id) + if err != nil { + return false, mapWriteErr(err) + } + return tag.RowsAffected() == 1, nil +} 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/migrations/002_idempotency.sql b/internal/store/migrations/002_idempotency.sql new file mode 100644 index 00000000..b03c86a5 --- /dev/null +++ b/internal/store/migrations/002_idempotency.sql @@ -0,0 +1,23 @@ +-- Идемпотентность POST сообщения (lab3). +-- Область ключа: (user_id, method, path, key). +-- Разные пользователи и чаты могут независимо использовать одну строку Idempotency-Key. +-- request_hash — SHA-256 канонического тела. +-- Другой body при том же ключе даёт HTTP 409. +-- response_* фиксируются только для успешного 201 в той же транзакции, что и INSERT messages. +-- Транзиентный 5xx не сохраняется как окончательный результат. + +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + method text NOT NULL, + path text NOT NULL, + key text NOT NULL, + request_hash text NOT NULL, + response_status integer NOT NULL, + response_body jsonb NOT NULL, + message_id uuid NOT NULL REFERENCES messages (id), + created_at timestamptz NOT NULL, + PRIMARY KEY (user_id, method, path, key) +); + +-- Индекс по времени — для будущей очистки хвоста старше 24 часов. +CREATE INDEX IF NOT EXISTS idempotency_keys_created_idx ON idempotency_keys (created_at); diff --git a/internal/store/migrations/003_attachments.sql b/internal/store/migrations/003_attachments.sql new file mode 100644 index 00000000..af091554 --- /dev/null +++ b/internal/store/migrations/003_attachments.sql @@ -0,0 +1,33 @@ +-- Вложения lab4. Метаданные в PostgreSQL, байты в приватном S3-bucket (MinIO). +-- Ключ объекта назначает сервер: originals/. +-- filename только для отображения, в ключ не попадает. +-- +-- ВНИМАНИЕ: файл режется по символу точки с запятой (см. splitSQL в migrate.go), +-- поэтому в комментариях и литералах здесь нет этого символа. + +CREATE TABLE IF NOT EXISTS attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + owner_id uuid NOT NULL REFERENCES users (id), + filename text NOT NULL, + content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')), + size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760), + sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + object_key text COLLATE "C" NOT NULL, + status text NOT NULL DEFAULT 'ready' CHECK (status IN ('ready')), + error_code text, + created_at timestamptz NOT NULL, + updated_at timestamptz NOT NULL, + CONSTRAINT attachments_object_key_unique UNIQUE (object_key) +); + +CREATE INDEX IF NOT EXISTS attachments_chat_idx ON attachments (chat_id); + +CREATE TABLE IF NOT EXISTS message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id), + attachment_id uuid NOT NULL REFERENCES attachments (id), + position smallint NOT NULL CHECK (position >= 0), + PRIMARY KEY (message_id, attachment_id) +); + +CREATE INDEX IF NOT EXISTS message_attachments_attachment_idx ON message_attachments (attachment_id); diff --git a/internal/store/store.go b/internal/store/store.go new file mode 100644 index 00000000..55517f1c --- /dev/null +++ b/internal/store/store.go @@ -0,0 +1,723 @@ +// Package store — пользователи, чаты, сообщения и ключи идемпотентности в PostgreSQL. +// +// Источник истины — только эти таблицы. Память процесса после рестарта пуста, +// поэтому ни одного map с данными здесь нет. Каждый запрос параметризован ($1, $2): +// текст сообщения не склеивается в SQL. +// +// Создание чата — одна транзакция: строка чата и все участники фиксируются вместе +// либо не фиксируются вообще. Уникальность username обеспечивает UNIQUE, а не проверка +// «сначала SELECT, потом INSERT» (та проверка проигрывает гонке). +// +// Вложения (lab4) — файл attachments.go: метаданные в PostgreSQL, байты в S3. Сообщение +// ссылается на вложения через message_attachments; ссылки пишутся в той же транзакции, +// что и само сообщение и ключ идемпотентности. +// +// Идемпотентность сообщения тоже живёт в PostgreSQL, а не в памяти реплики: +// два параллельных POST с одним ключом через разные API-контейнеры видят один PK. +package store + +import ( + "context" + "crypto/sha256" + "encoding/binary" + "encoding/json" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "mtusi2026lab4/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") + // ErrIdempotencyConflict — тот же ключ, но другое тело запроса. + ErrIdempotencyConflict = errors.New("idempotency conflict") + // ErrAttachmentNotReady — вложение существует, но ещё не ready (409 по контракту). + // В lab4 все вложения создаются сразу ready; проверка нужна для lab5+ и защищает + // от прикрепления недообработанного файла. + ErrAttachmentNotReady = errors.New("attachment not ready") +) + +// 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 назначает сервер. +// AttachmentIDs всегда непустой срез нулевой длины, если вложений нет (JSON даёт []). +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + AttachmentIDs []uuid.UUID + 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, +// а не висела до клиентского таймаута теста. +// maxConns — на одну реплику; при N репликах суммарный пул ≈ N*maxConns. +func Open(ctx context.Context, databaseURL string, hasher *auth.Hasher, maxConns int32) (*Store, error) { + if maxConns < 1 { + maxConns = 5 + } + cfg, err := pgxpool.ParseConfig(databaseURL) + if err != nil { + return nil, fmt.Errorf("parse database url: %w", err) + } + cfg.MaxConns = maxConns + 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 строки. Следующее чтение видит её без кэша истории. +// Без идемпотентности — только для внутренних/тестовых случаев; HTTP использует CreateMessageIdempotent. +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(), + AttachmentIDs: []uuid.UUID{}, + } + 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 +} + +// IdempotentMessage — либо только что созданное, либо ранее сохранённое по ключу сообщение. +type IdempotentMessage struct { + Message *Message + Replayed bool +} + +// CreateMessageIdempotent атомарно создаёт сообщение со вложениями и запоминает ответ по ключу. +// +// Алгоритм (общая БД, любые реплики): +// 1. BEGIN; +// 2. pg_advisory_xact_lock по хешу (user, method, path, key) — сериализует конкурентов +// ещё до INSERT messages, иначе два победителя гонки успели бы создать два сообщения; +// 3. SELECT сохранённого ключа — если есть, сравнить hash и вернуть Message (с его вложениями); +// 4. иначе проверить членство в чате и вложения: каждое должно существовать, лежать +// в ЭТОМ чате и быть ready (чужое/неизвестное — ErrNotFound, не ready — ErrNotReady); +// 5. INSERT message + message_attachments + idempotency_keys в той же транзакции; +// 6. COMMIT (advisory lock снимается вместе с транзакцией). +// +// attachmentIDs уже без дубликатов (проверяет HTTP-слой), порядок сохраняется. +// Пустой текст допустим только вместе с вложениями — это тоже проверяет HTTP-слой. +// Другой request_hash → ErrIdempotencyConflict. Транзиентный 5xx сюда не попадает: +// запись ключа только после успешной подготовки 201. +func (s *Store) CreateMessageIdempotent( + ctx context.Context, + chatID, senderID uuid.UUID, + text string, + attachmentIDs []uuid.UUID, + method, path, idemKey, requestHash string, +) (*IdempotentMessage, error) { + ctx, cancel := context.WithTimeout(ctx, queryTimeout) + defer cancel() + if attachmentIDs == nil { + attachmentIDs = []uuid.UUID{} + } + + tx, err := s.pool.Begin(ctx) + if err != nil { + return nil, mapWriteErr(err) + } + defer func() { _ = tx.Rollback(ctx) }() + + lockKey := idempotencyLockKey(senderID, method, path, idemKey) + if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock($1)`, lockKey); err != nil { + return nil, mapWriteErr(err) + } + + var ( + storedHash string + msgID uuid.UUID + msgChat uuid.UUID + msgSender uuid.UUID + msgText string + msgCreated time.Time + ) + err = tx.QueryRow(ctx, ` + SELECT i.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM idempotency_keys i + JOIN messages m ON m.id = i.message_id + WHERE i.user_id = $1 AND i.method = $2 AND i.path = $3 AND i.key = $4`, + senderID, method, path, idemKey, + ).Scan(&storedHash, &msgID, &msgChat, &msgSender, &msgText, &msgCreated) + if err == nil { + if storedHash != requestHash { + return nil, ErrIdempotencyConflict + } + byMsg, err := attachmentIDsByMessage(ctx, tx, []uuid.UUID{msgID}) + if err != nil { + return nil, err + } + if err := tx.Commit(ctx); err != nil { + return nil, mapWriteErr(err) + } + return &IdempotentMessage{ + Message: &Message{ + ID: msgID, + ChatID: msgChat, + SenderID: msgSender, + Text: msgText, + AttachmentIDs: byMsg[msgID], + CreatedAt: msgCreated, + }, + Replayed: true, + }, nil + } + if !errors.Is(err, pgx.ErrNoRows) { + return nil, mapWriteErr(err) + } + + var member int + if err := tx.QueryRow(ctx, ` + SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, mapWriteErr(err) + } + + attStrs := make([]string, len(attachmentIDs)) + for i, id := range attachmentIDs { + attStrs[i] = id.String() + } + if len(attStrs) > 0 { + // chat_id = $2 — вложение другого чата неотличимо от несуществующего (404, не 403). + rows, err := tx.Query(ctx, ` + SELECT status FROM attachments WHERE id = ANY($1::uuid[]) AND chat_id = $2`, attStrs, chatID) + if err != nil { + return nil, mapWriteErr(err) + } + found, notReady := 0, false + for rows.Next() { + var status string + if err := rows.Scan(&status); err != nil { + rows.Close() + return nil, mapWriteErr(err) + } + found++ + if status != "ready" { + notReady = true + } + } + rows.Close() + if err := rows.Err(); err != nil { + return nil, mapWriteErr(err) + } + if found != len(attStrs) { + return nil, ErrNotFound + } + if notReady { + return nil, ErrNotReady + } + } + + msg := &Message{ + ID: uuid.New(), + ChatID: chatID, + SenderID: senderID, + Text: text, + AttachmentIDs: append([]uuid.UUID{}, attachmentIDs...), + CreatedAt: nowUTC(), + } + if _, err := tx.Exec(ctx, ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5)`, + msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return nil, mapWriteErr(err) + } + if len(attStrs) > 0 { + // WITH ORDINALITY сохраняет порядок attachment_ids из запроса. + if _, err := tx.Exec(ctx, ` + INSERT INTO message_attachments (message_id, attachment_id, position) + SELECT $1, u.id, (u.ord - 1)::smallint + FROM unnest($2::uuid[]) WITH ORDINALITY AS u(id, ord)`, msg.ID, attStrs); err != nil { + return nil, mapWriteErr(err) + } + } + + // response_body заполняем каноническим Message JSON уже здесь, чтобы replay + // не зависел от повторной сериализации в HTTP-слое с другим порядком полей. + bodyJSON, err := json.Marshal(map[string]any{ + "id": msg.ID.String(), + "chat_id": msg.ChatID.String(), + "sender_id": msg.SenderID.String(), + "text": msg.Text, + "attachment_ids": attStrs, + "created_at": msg.CreatedAt.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z"), + }) + if err != nil { + return nil, err + } + if _, err = tx.Exec(ctx, ` + INSERT INTO idempotency_keys ( + user_id, method, path, key, request_hash, + response_status, response_body, message_id, created_at + ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, + senderID, method, path, idemKey, requestHash, + 201, bodyJSON, msg.ID, msg.CreatedAt); err != nil { + return nil, mapWriteErr(err) + } + if err := tx.Commit(ctx); err != nil { + return nil, mapWriteErr(err) + } + return &IdempotentMessage{Message: msg, Replayed: false}, nil +} + +// idempotencyLockKey — стабильный int64 для pg_advisory_xact_lock из области ключа. +func idempotencyLockKey(userID uuid.UUID, method, path, key string) int64 { + sum := sha256.Sum256([]byte(userID.String() + "|" + method + "|" + path + "|" + key)) + return int64(binary.BigEndian.Uint64(sum[:8])) +} + +// 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 + }) + // Вложения страницы — одним запросом, а не по запросу на сообщение. + ids := make([]uuid.UUID, len(items)) + for i := range items { + ids[i] = items[i].ID + } + byMsg, err := attachmentIDsByMessage(ctx, s.pool, ids) + if err != nil { + return nil, nil, err + } + for i := range items { + items[i].AttachmentIDs = byMsg[items[i].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, "closed pool") || + 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-private-bucket.sh b/scripts/check-private-bucket.sh new file mode 100755 index 00000000..fc7f98fc --- /dev/null +++ b/scripts/check-private-bucket.sh @@ -0,0 +1,31 @@ +#!/bin/sh +# Уровень 4: прямое неаутентифицированное чтение объекта из bucket должно отказать. +# Ожидание: HTTP 403 (или отказ соединения / 400 Signature) — не 200 с телом файла. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" + +BUCKET=${S3_BUCKET:-messenger-attachments} +ENDPOINT=${S3_PUBLIC_ENDPOINT:-http://127.0.0.1:9000} +# Любой ключ: даже несуществующий при private bucket не должен отдаваться анониму как 200+тело. +URL="${ENDPOINT}/${BUCKET}/originals/does-not-exist" + +code=$(curl -sS -o /tmp/private-bucket-body.$$ -w '%{http_code}' "$URL" || echo "000") +body_len=$(wc -c < /tmp/private-bucket-body.$$ | tr -d ' ') +rm -f /tmp/private-bucket-body.$$ + +echo "GET $URL → HTTP $code body_bytes=$body_len" +case "$code" in + 200) + echo "FAIL: anonymous GET returned 200" >&2 + exit 1 + ;; + 000) + echo "FAIL: could not reach MinIO at $ENDPOINT" >&2 + exit 1 + ;; + *) + echo "PASS: anonymous access denied (HTTP $code)" + exit 0 + ;; +esac diff --git a/scripts/concurrent-uploads.sh b/scripts/concurrent-uploads.sh new file mode 100755 index 00000000..8af43750 --- /dev/null +++ b/scripts/concurrent-uploads.sh @@ -0,0 +1,130 @@ +#!/bin/sh +# Уровень 4: ≥10 одновременных загрузок + пик RSS API-реплик. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +export BASE_URL=${BASE_URL:-http://127.0.0.1:8080} +export N=${N:-12} +export OUT=${OUT:-evidence/concurrent-uploads.txt} +mkdir -p evidence + +python3 - <<'PY' +import base64, binascii, json, os, struct, subprocess, sys, threading, time, urllib.request, uuid, zlib + +base = os.environ["BASE_URL"] +n = int(os.environ["N"]) +out = os.environ["OUT"] + +def req(method, path, data=None, headers=None, timeout=60): + h = dict(headers or {}) + body = data + if isinstance(data, (dict, list)): + body = json.dumps(data).encode() + h.setdefault("Content-Type", "application/json") + r = urllib.request.Request(base + path, data=body, headers=h, method=method) + with urllib.request.urlopen(r, timeout=timeout) as resp: + return resp.status, resp.read() + +def chunk(tag, data): + return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", binascii.crc32(tag + data) & 0xffffffff) + +# 1024×1024 RGB, zlib level 0 → ~3 MiB: заметнее для RSS, всё ещё ≪ 10 MiB лимита. +w = h = 1024 +ihdr = struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, 0) +raw = b"".join(b"\x00" + bytes(w * 3) for _ in range(h)) +big = b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw, 0)) + chunk(b"IEND", b"") +print(f"upload_size_bytes={len(big)}", flush=True) + +uname = "cu_" + uuid.uuid4().hex[:10] +password = "correct-horse-1" +st, body = req("POST", "/api/v1/users", {"username": uname, "display_name": "CU", "password": password}) +assert st == 201, body +uid = json.loads(body)["id"] +basic = base64.b64encode(f"{uname}:{password}".encode()).decode() +st, body = req("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {basic}"}) +assert st == 201, body +token = json.loads(body)["token"] +st, body = req("POST", "/api/v1/chats", {"title": "concurrent", "member_ids": [uid]}, + headers={"Authorization": f"Bearer {token}"}) +assert st == 201, body +chat = json.loads(body)["id"] + +def api_rss_kb(): + try: + ids = subprocess.check_output( + ["docker", "compose", "--env-file", ".env", "ps", "-q", "api"], text=True + ).split() + total = 0 + for i in ids: + line = subprocess.check_output( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", i], text=True + ).strip() + part = line.split("/")[0].strip() + num = float("".join(ch for ch in part if ch.isdigit() or ch == ".")) + if "GiB" in part: + total += int(num * 1024 * 1024) + elif "MiB" in part: + total += int(num * 1024) + else: + total += int(num) + return total + except Exception as e: + print("rss_err", e, flush=True) + return -1 + +rss_before = api_rss_kb() +peak = {"v": rss_before} +stop = threading.Event() + +def monitor(): + while not stop.is_set(): + v = api_rss_kb() + if v > peak["v"]: + peak["v"] = v + time.sleep(0.2) + +mon = threading.Thread(target=monitor, daemon=True) +mon.start() +results = [None] * n +barrier = threading.Barrier(n) + +def worker(i): + barrier.wait(60) + try: + r = urllib.request.Request( + f"{base}/api/v1/chats/{chat}/attachments?filename=c{i}.png", + data=big, + headers={"Authorization": f"Bearer {token}", "Content-Type": "image/png"}, + method="POST", + ) + with urllib.request.urlopen(r, timeout=120) as resp: + results[i] = resp.status + except Exception as e: + results[i] = str(e) + +threads = [threading.Thread(target=worker, args=(i,)) for i in range(n)] +t0 = time.time() +for th in threads: + th.start() +for th in threads: + th.join() +elapsed = time.time() - t0 +stop.set() +mon.join(timeout=1) +rss_after = api_rss_kb() +ok = sum(1 for r in results if r == 201) +text = "\n".join([ + f"concurrent={n}", + f"upload_bytes={len(big)}", + f"ok_201={ok}", + f"results={results}", + f"elapsed_s={elapsed:.3f}", + f"api_rss_kb_before={rss_before}", + f"api_rss_kb_peak={peak['v']}", + f"api_rss_kb_after={rss_after}", +]) + "\n" +print(text, end="") +open(out, "w").write(text) +sys.exit(0 if ok == n else 1) +PY +echo "wrote $OUT" diff --git a/scripts/reconcile-demo.sh b/scripts/reconcile-demo.sh new file mode 100755 index 00000000..7bc99c6a --- /dev/null +++ b/scripts/reconcile-demo.sh @@ -0,0 +1,146 @@ +#!/bin/sh +# Трек 5: внедрить orphan + missing, показать dry-run и apply, доказать защиту fresh. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +OUT=${OUT:-evidence/reconcile.txt} +mkdir -p evidence +: >"$OUT" + +log() { echo "$@" | tee -a "$OUT"; } + +BUCKET=$(grep -E '^S3_BUCKET=' .env | cut -d= -f2-) +BUCKET=${BUCKET:-messenger-attachments} +ROOT_USER=$(grep -E '^MINIO_ROOT_USER=' .env | cut -d= -f2-) +ROOT_PASS=$(grep -E '^MINIO_ROOT_PASSWORD=' .env | cut -d= -f2-) +ROOT_USER=${ROOT_USER:-minioadmin} +ROOT_PASS=${ROOT_PASS:-minioadmin-secret} +ORPHAN_KEY="originals/00000000-0000-4000-8000-0000000000aa" + +log "=== seed orphan object via root PutObject (python/minio not required: curl+aws style via go) ===" +# Используем временный контейнер с нашим s3bootstrap-окружением нельзя для PUT. +# Кладём объект через API MinIO SDK в одноразовом python boto? Проще — docker run с +# нашим образом и маленьким go-one-liner... Пишем через awscli-совместимый путь: +# minio client отсутствует → используем python3 + urllib подписанный запрос слишком сложен. +# Простой путь: временный Go в scripts/seed_orphan — нет. Используем docker compose run +# с entrypoint /s3bootstrap нельзя. Добавим флаг... +# Практика: python boto3 если есть, иначе raw Put через minio-go в compose run server? +# Самое простое — python3 и hashlib hmac для SigV4. + +python3 - <&1 | tee -a "$OUT" + +log "=== apply grace=0 ===" +docker compose --env-file .env run --rm --no-deps reconcile -apply -grace-seconds=0 2>&1 | tee -a "$OUT" + +log "=== second apply (idempotent) ===" +docker compose --env-file .env run --rm --no-deps reconcile -apply -grace-seconds=0 2>&1 | tee -a "$OUT" + +log "=== fresh orphan skipped with default grace ===" +python3 - <&1 | tee -a "$OUT" + +log "wrote $OUT" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..9f0235ae --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Перезапуск API (всех реплик), LB и всех хранилищ без удаления volumes. +# Важно: именно restart, а не up -d — иначе PID/StartedAt у живых контейнеров не меняются. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +docker compose --env-file .env restart postgres redis minio api lb diff --git a/scripts/restore-one.sh b/scripts/restore-one.sh new file mode 100755 index 00000000..56e6b2df --- /dev/null +++ b/scripts/restore-one.sh @@ -0,0 +1,42 @@ +#!/bin/sh +# Поднимает недостающие / остановленные API-реплики до API_REPLICAS после stop-one. +# Не трогает volumes и не делает down -v. Миграции уже применены — не пересоздаём migrate. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" +API_REPLICAS=$(grep -E '^API_REPLICAS=' .env 2>/dev/null | cut -d= -f2- || true) +API_REPLICAS=${API_REPLICAS:-2} + +# Стартуем остановленные контейнеры сервиса api и добираем scale при нехватке. +docker compose --env-file .env start api 2>/dev/null || true +docker compose --env-file .env up -d --no-deps --scale "api=${API_REPLICAS}" api + +deadline=$(( $(date +%s) + 90 )) +while :; do + if curl -fsS "http://127.0.0.1:8080/health/ready" >/dev/null 2>&1; then + # Ждём, пока LB реально видит ≥2 instance id (не только один backend). + ids=$( + python3 - <<'PY' +import urllib.request +ids=set() +for _ in range(24): + try: + with urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=1) as r: + i=r.headers.get('X-Instance-Id') + if i: ids.add(i) + except Exception: + pass +print(len(ids)) +PY + ) + if [ "$ids" -ge 2 ] || [ "$API_REPLICAS" -lt 2 ]; then + exit 0 + fi + fi + if [ "$(date +%s)" -ge "$deadline" ]; then + echo "restore timeout (replicas visible via LB: ${ids:-0})" >&2 + docker compose --env-file .env ps >&2 || true + exit 1 + fi + sleep 1 +done diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..049a3785 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,44 @@ +#!/bin/sh +# Останавливает РОВНО одну API-реплику, чей X-Instance-Id = TARGET_INSTANCE_ID. +# Реплика остаётся остановленной; восстановление — scripts/restore-one.sh или compose up. +# Не трогает postgres/redis/lb/volumes. Должен завершиться за <10 с. +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" + +ids=$(docker compose --env-file .env ps -q api) +if [ -z "$ids" ]; then + echo "no api containers" >&2 + exit 1 +fi + +found=0 +for id in $ids; do + # Совпадает с config.InstanceID: hostname контейнера, если INSTANCE_ID не задан. + hostname=$(docker inspect -f '{{.Config.Hostname}}' "$id") + env_id=$(docker inspect -f '{{range .Config.Env}}{{println .}}{{end}}' "$id" | sed -n 's/^INSTANCE_ID=//p' | head -n1) + match=$hostname + if [ -n "$env_id" ]; then + match=$env_id + fi + if [ "$match" = "$TARGET_INSTANCE_ID" ]; then + # Явный stop контейнера; restart: "no" у api гарантирует, что он не вернётся сам. + docker stop -t 8 "$id" >/dev/null + # Подтверждаем, что контейнер действительно не running — иначе failover-тест врёт. + state=$(docker inspect -f '{{.State.Running}}' "$id") + if [ "$state" = "true" ]; then + echo "container still running after stop" >&2 + exit 1 + fi + found=1 + break + fi +done + +if [ "$found" -ne 1 ]; then + echo "TARGET_INSTANCE_ID not found among api replicas" >&2 + exit 1 +fi +exit 0 diff --git a/scripts/up.sh b/scripts/up.sh new file mode 100755 index 00000000..51bd2f2a --- /dev/null +++ b/scripts/up.sh @@ -0,0 +1,38 @@ +#!/bin/sh +# Единая последовательность запуска стенда lab4. +# 1) postgres+redis+minio 2) bootstrap bucket 3) миграции 4) API×N 5) HAProxy +set -eu +ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd) +cd "$ROOT" + +if [ ! -f .env ]; then + cp .env.example .env + echo "created .env from .env.example" >&2 +fi + +API_REPLICAS=$(grep -E '^API_REPLICAS=' .env | cut -d= -f2- || true) +API_REPLICAS=${API_REPLICAS:-2} + +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build postgres redis minio +docker compose --env-file .env run --rm minio-init +docker compose --env-file .env run --rm --build migrate +docker compose --env-file .env up -d --build --scale "api=${API_REPLICAS}" --no-deps api +docker compose --env-file .env up -d --no-deps lb + +echo "waiting for http://127.0.0.1:8080/health/ready via LB..." +deadline=$(( $(date +%s) + 180 )) +while :; do + if curl -fsS "http://127.0.0.1:8080/health/ready" >/dev/null 2>&1; then + echo "ready" + docker compose --env-file .env ps + exit 0 + fi + if [ "$(date +%s)" -ge "$deadline" ]; then + echo "timeout waiting for readiness" >&2 + docker compose --env-file .env ps >&2 || true + docker compose --env-file .env logs --tail=80 api lb minio minio-init >&2 || true + exit 1 + fi + sleep 1 +done diff --git a/student-tests/api_test.go b/student-tests/api_test.go new file mode 100644 index 00000000..ab0a303e --- /dev/null +++ b/student-tests/api_test.go @@ -0,0 +1,664 @@ +// Собственные проверки lab3 (плюс регрессия lab2). Им нужен уже поднятый +// PostgreSQL и Redis (docker compose up / scripts/up.sh): контракт требует +// настоящую БД, а не sqlmock. HTTP бьём в httptest.Server поверх того же Store, +// что и реплики — идемпотентность и гонки видны без обхода LB. +// +// Каждый тест пишет в лог, что именно проверяет и какой статус получил. +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" + + "mtusi2026lab4/internal/api" + "mtusi2026lab4/internal/auth" + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/session" + "mtusi2026lab4/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, 5) + 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, "Чат проверки") + auth := map[string]string{"Authorization": "Bearer " + token} + + // Decoder.More() это не ловит: один объект декодируется, лишняя скобка остаётся. + for _, raw := range []string{`{"text":"valid"}}`, `{"text":"valid"}]`} { + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, raw) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("trailing garbage %q: status=%d body=%s", raw, status, body) + } + } + + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"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 TestMessageTextPreservedAndLengthOnOriginal(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "пробелы по краям сохраняются; длина считается по исходному тексту") + user := register(t, srv, "text_user") + token := login(t, srv, user.username, user.password) + chat := createChat(t, srv, token, user.id, "Текст") + auth := map[string]string{"Authorization": "Bearer " + token} + + original := " строка\nс пробелами " + status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, + fmt.Sprintf(`{"text":%q}`, original)) + logResult(t, status, body) + if status != http.StatusCreated { + t.Fatalf("preserve spaces: status=%d", status) + } + got := decode(t, body) + if got["text"] != original { + t.Fatalf("text mutated: got %q want %q", got["text"], original) + } + + tooLong := " " + strings.Repeat("a", 4000) // 4001 code points + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, + fmt.Sprintf(`{"text":%q}`, tooLong)) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("length after trim bypass: status=%d body=%s", status, body) + } + logOK(t, "текст сохранён целиком, обход лимита через TrimSpace закрыт") +} + +func TestSessionRejectsJSONBody(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "POST /auth/sessions с телом должен быть 400 даже при верном Basic") + user := register(t, srv, "body_user") + status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{ + "Authorization": "Basic " + basic(user.username, user.password), + }, `{"extra":1}`) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("session with body: status=%d body=%s", status, body) + } + logOK(t, "вход без JSON body") +} + +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, blob.NewMemory(), "test-closed-redis").Handler()) + defer srv.Close() + regSrv := newAPI(t, time.Hour) + defer regSrv.Close() + user := register(t, regSrv, "redis_down") + 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 не стал анонимным доступом") +} + +func TestPostgresDownIsNotAnonymous(t *testing.T) { + logStep(t, "закрытый пул PostgreSQL: ready/me/login дают 503, без тела пользователя") + regSrv := newAPI(t, time.Hour) + defer regSrv.Close() + user := register(t, regSrv, "pg_down") + token := login(t, regSrv, user.username, user.password) + + hasher, err := auth.NewHasher() + if err != nil { + t.Fatal(err) + } + dsn := getenv("DATABASE_URL", "postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable") + broken, err := store.Open(context.Background(), dsn, hasher, 5) + if err != nil { + t.Fatal(err) + } + broken.Close() + sessions, err := session.Open(sharedRedisURL, time.Hour) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = sessions.Close() }) + srv := httptest.NewServer(api.New(broken, sessions, blob.NewMemory(), "test-broken-pg").Handler()) + defer srv.Close() + + status, body := do(t, srv, http.MethodGet, "/health/ready", nil, "") + logResult(t, status, body) + if status != http.StatusServiceUnavailable { + t.Fatalf("ready with dead postgres: %d", status) + } + status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{ + "Authorization": "Bearer " + token, + }, "") + logResult(t, status, body) + if status != http.StatusServiceUnavailable || strings.Contains(body, `"username"`) { + t.Fatalf("me with dead postgres: status=%d body=%s", status, body) + } + 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 postgres: status=%d body=%s", status, body) + } + logOK(t, "сбой PostgreSQL не стал анонимным доступом") +} + + +func TestIdempotencyReplayAndConflict(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "повтор того же Idempotency-Key возвращает то же сообщение; другой body — 409") + user := register(t, srv, "idem_user") + token := login(t, srv, user.username, user.password) + chat := createChat(t, srv, token, user.id, "Идемпотентность") + key := "key-" + uuid.NewString() + auth := map[string]string{ + "Authorization": "Bearer " + token, + "Idempotency-Key": key, + } + status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"один раз"}`) + logResult(t, status, body) + if status != http.StatusCreated { + t.Fatalf("first: %d %s", status, body) + } + first := decode(t, body) + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"один раз"}`) + logResult(t, status, body) + if status != http.StatusCreated { + t.Fatalf("replay: %d %s", status, body) + } + second := decode(t, body) + if first["id"] != second["id"] || first["text"] != second["text"] { + t.Fatalf("replay differs: first=%v second=%v", first, second) + } + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"другой body"}`) + logResult(t, status, body) + if status != http.StatusConflict { + t.Fatalf("conflict: %d %s", status, body) + } + logOK(t, "replay и conflict по Idempotency-Key") +} + +func TestIdempotencyKeyRequiredAndConcurrent(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "нет ключа → 400; 8 параллельных POST с одним ключом → ровно одно сообщение") + user := register(t, srv, "idem_race") + token := login(t, srv, user.username, user.password) + chat := createChat(t, srv, token, user.id, "Гонка ключа") + + // Явно без ключа: хелпер doRaw подставляет ключ только если заголовок пуст — + // поэтому бьём в doRaw с пустым Idempotency-Key, переопределив после... + // Проще: отдельный raw-запрос. + req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/chats/"+chat+"/messages", strings.NewReader(`{"text":"без ключа"}`)) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", "Bearer "+token) + req.Header.Set("Content-Type", "application/json") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + b, _ := io.ReadAll(resp.Body) + resp.Body.Close() + logResult(t, resp.StatusCode, string(b)) + if resp.StatusCode != http.StatusBadRequest { + t.Fatalf("missing key: %d", resp.StatusCode) + } + + key := "race-" + uuid.NewString() + const n = 8 + ids := make([]string, n) + var wg sync.WaitGroup + for i := 0; i < n; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{ + "Authorization": "Bearer " + token, + "Idempotency-Key": key, + }, `{"text":"параллельно"}`) + if status != http.StatusCreated { + t.Errorf("worker %d status=%d body=%s", i, status, body) + return + } + ids[i] = decode(t, body)["id"].(string) + }(i) + } + wg.Wait() + uniq := map[string]struct{}{} + for _, id := range ids { + if id == "" { + t.Fatalf("empty id in race") + } + uniq[id] = struct{}{} + } + t.Logf("unique message ids=%d", len(uniq)) + if len(uniq) != 1 { + t.Fatalf("expected 1 message, got %d ids=%v", len(uniq), ids) + } + logOK(t, "ключ обязателен; конкурентный повтор не плодит дубли") +} + +func TestInstanceIDHeaderPresent(t *testing.T) { + srv := newAPI(t, time.Hour) + defer srv.Close() + logStep(t, "каждый ответ содержит непустой X-Instance-Id") + status, body, hdr := doRaw(t, srv, http.MethodGet, "/health/live", nil, "") + logResult(t, status, body) + if status != http.StatusOK || hdr.Get("X-Instance-Id") == "" { + t.Fatalf("live instance header missing: %q status=%d", hdr.Get("X-Instance-Id"), status) + } + logOK(t, "X-Instance-Id="+hdr.Get("X-Instance-Id")) +} + +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, blob.NewMemory(), "test-instance").Handler()) +} + +func newAPIBlob(t *testing.T, ttl time.Duration, bl api.BlobStore) *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, bl, "test-instance").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) + } + // Lab3: POST сообщений без ключа — 400. В хелперах подставляем уникальный ключ, + // если тест сам его не задал (негативные проверки ключа делают это явно). + if method == http.MethodPost && strings.Contains(path, "/messages") && req.Header.Get("Idempotency-Key") == "" { + req.Header.Set("Idempotency-Key", uuid.NewString()) + } + 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 +} diff --git a/student-tests/attachments_test.go b/student-tests/attachments_test.go new file mode 100644 index 00000000..2cb3dd86 --- /dev/null +++ b/student-tests/attachments_test.go @@ -0,0 +1,244 @@ +package studenttests + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "net/url" + "testing" + "time" + + "mtusi2026lab4/internal/api" + "mtusi2026lab4/internal/blob" + "mtusi2026lab4/internal/session" +) + +// 1×1 PNG (valid IHDR + IDAT + IEND, CRC проверены). +var tinyPNG = []byte{ + 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, + 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, + 0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41, + 0x54, 0x78, 0xda, 0x63, 0xf8, 0xcf, 0xc0, 0x00, + 0x00, 0x03, 0x01, 0x01, 0x00, 0xf7, 0x03, 0x41, + 0x43, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, + 0x44, 0xae, 0x42, 0x60, 0x82, +} + +func TestAttachmentUploadDownloadAndACL(t *testing.T) { + mem := blob.NewMemory() + srv := newAPIBlob(t, time.Hour, mem) + defer srv.Close() + logStep(t, "upload PNG → 201 ready → download checksum; посторонний — 404") + + owner := register(t, srv, "att_owner") + ownerTok := login(t, srv, owner.username, owner.password) + stranger := register(t, srv, "att_stranger") + strangerTok := login(t, srv, stranger.username, stranger.password) + chat := createChat(t, srv, ownerTok, owner.id, "Вложения") + + attID, sha := uploadPNG(t, srv, ownerTok, chat, "pic.png", tinyPNG) + status, body := do(t, srv, http.MethodGet, "/api/v1/attachments/"+attID, map[string]string{ + "Authorization": "Bearer " + ownerTok, + }, "") + logResult(t, status, body) + if status != http.StatusOK { + t.Fatalf("meta: %d %s", status, body) + } + meta := decode(t, body) + if meta["status"] != "ready" || meta["sha256"] != sha { + t.Fatalf("meta unexpected: %+v", meta) + } + + statusCode, raw, hdr := downloadBytes(t, srv, ownerTok, attID) + if statusCode != http.StatusOK { + t.Fatalf("download: %d", statusCode) + } + if hdr.Get("Content-Type") != "image/png" { + t.Fatalf("content-type: %q", hdr.Get("Content-Type")) + } + sum := sha256.Sum256(raw) + if hex.EncodeToString(sum[:]) != sha { + t.Fatalf("checksum mismatch") + } + + status, body = do(t, srv, http.MethodGet, "/api/v1/attachments/"+attID, map[string]string{ + "Authorization": "Bearer " + strangerTok, + }, "") + logResult(t, status, body) + if status != http.StatusNotFound { + t.Fatalf("stranger meta: %d", status) + } + statusCode, _, _ = downloadBytes(t, srv, strangerTok, attID) + if statusCode != http.StatusNotFound { + t.Fatalf("stranger download: %d", statusCode) + } + + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{ + "Authorization": "Bearer " + ownerTok, + }, fmt.Sprintf(`{"text":"с файлом","attachment_ids":[%q]}`, attID)) + logResult(t, status, body) + if status != http.StatusCreated { + t.Fatalf("message with att: %d %s", status, body) + } + msg := decode(t, body) + ids, _ := msg["attachment_ids"].([]any) + if len(ids) != 1 || ids[0] != attID { + t.Fatalf("attachment_ids: %+v", msg["attachment_ids"]) + } + logOK(t, "upload/download/ACL и message.attachment_ids") +} + +func TestAttachmentRejectsBadInput(t *testing.T) { + mem := blob.NewMemory() + srv := newAPIBlob(t, time.Hour, mem) + defer srv.Close() + logStep(t, "битый PNG, подмена MIME, опасный filename, чужой чат → 4xx не 500") + + user := register(t, srv, "att_bad") + tok := login(t, srv, user.username, user.password) + chat := createChat(t, srv, tok, user.id, "Отказы") + + status, body := uploadRaw(t, srv, tok, chat, "../x.png", "image/png", tinyPNG) + logResult(t, status, body) + if status != http.StatusBadRequest { + t.Fatalf("bad filename: %d", status) + } + + status, body = uploadRaw(t, srv, tok, chat, "x.jpg", "image/jpeg", tinyPNG) + logResult(t, status, body) + if status != http.StatusUnsupportedMediaType { + t.Fatalf("mime mismatch: %d", status) + } + + status, body = uploadRaw(t, srv, tok, chat, "bad.png", "image/png", tinyPNG[:20]) + logResult(t, status, body) + if status != http.StatusUnsupportedMediaType { + t.Fatalf("truncated: %d", status) + } + + // Отдельный сервер с маленьким лимитом: реально шлём 2 KiB, ожидаем 413. + small := blob.NewMemory() + sessions, err := session.Open(sharedRedisURL, time.Hour) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = sessions.Close() }) + apiSrv := api.New(sharedStore, sessions, small, "test-small-limit") + apiSrv.MaxUploadBytes = 1024 + limSrv := httptest.NewServer(apiSrv.Handler()) + defer limSrv.Close() + status, body = uploadRaw(t, limSrv, tok, chat, "huge.png", "image/png", make([]byte, 2048)) + logResult(t, status, body) + if status != http.StatusRequestEntityTooLarge { + t.Fatalf("too large body: %d", status) + } + + other := register(t, srv, "att_other") + otherTok := login(t, srv, other.username, other.password) + otherChat := createChat(t, srv, otherTok, other.id, "Чужой") + status, body = uploadRaw(t, srv, tok, otherChat, "x.png", "image/png", tinyPNG) + logResult(t, status, body) + if status != http.StatusNotFound { + t.Fatalf("foreign chat upload: %d", status) + } + + attID, _ := uploadPNG(t, srv, otherTok, otherChat, "o.png", tinyPNG) + status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{ + "Authorization": "Bearer " + tok, + }, fmt.Sprintf(`{"text":"steal","attachment_ids":[%q]}`, attID)) + logResult(t, status, body) + if status != http.StatusNotFound { + t.Fatalf("foreign attachment_id: %d %s", status, body) + } + logOK(t, "негативные сценарии вложений → клиентские 4xx") +} + +func TestAttachmentS3DownIs503(t *testing.T) { + mem := blob.NewMemory() + mem.SetUnavailable(true) + srv := newAPIBlob(t, time.Hour, mem) + defer srv.Close() + logStep(t, "S3 недоступен: ready и upload → 503") + + status, body := do(t, srv, http.MethodGet, "/health/ready", nil, "") + logResult(t, status, body) + if status != http.StatusServiceUnavailable { + t.Fatalf("ready: %d", status) + } + + user := register(t, srv, "s3_down") + tok := login(t, srv, user.username, user.password) + chat := createChat(t, srv, tok, user.id, "S3 down") + status, body = uploadRaw(t, srv, tok, chat, "x.png", "image/png", tinyPNG) + logResult(t, status, body) + if status != http.StatusServiceUnavailable { + t.Fatalf("upload with s3 down: %d %s", status, body) + } + logOK(t, "падение S3 → 503") +} + +func uploadPNG(t *testing.T, srv *httptest.Server, token, chatID, filename string, data []byte) (id, sha string) { + t.Helper() + status, body := uploadRaw(t, srv, token, chatID, filename, "image/png", data) + if status != http.StatusCreated { + t.Fatalf("upload: %d %s", status, body) + } + var att struct { + ID string `json:"id"` + SHA256 string `json:"sha256"` + Status string `json:"status"` + } + if err := json.Unmarshal([]byte(body), &att); err != nil { + t.Fatal(err) + } + if att.Status != "ready" || att.ID == "" { + t.Fatalf("upload body: %s", body) + } + sum := sha256.Sum256(data) + want := hex.EncodeToString(sum[:]) + if att.SHA256 != want { + t.Fatalf("sha got=%s want=%s", att.SHA256, want) + } + return att.ID, att.SHA256 +} + +func uploadRaw(t *testing.T, srv *httptest.Server, token, chatID, filename, ctype string, data []byte) (int, string) { + t.Helper() + u := srv.URL + "/api/v1/chats/" + chatID + "/attachments?filename=" + url.QueryEscape(filename) + req, err := http.NewRequest(http.MethodPost, u, bytes.NewReader(data)) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", "Bearer "+token) + req.Header.Set("Content-Type", ctype) + 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) +} + +func downloadBytes(t *testing.T, srv *httptest.Server, token, attID string) (int, []byte, http.Header) { + t.Helper() + req, err := http.NewRequest(http.MethodGet, srv.URL+"/api/v1/attachments/"+attID+"/content", nil) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", "Bearer "+token) + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + b, _ := io.ReadAll(resp.Body) + return resp.StatusCode, b, resp.Header.Clone() +}