From 36d9b0c8f6af2657c5b69984d70fe930388eb020 Mon Sep 17 00:00:00 2001 From: kk10 Date: Fri, 13 Nov 2026 15:52:39 +0300 Subject: [PATCH 01/23] feat: port lab4 implementation --- .dockerignore | 1 + .env.example | 18 +- .gitignore | 1 + Dockerfile | 21 ++ Dockerfile.migrate | 8 + Dockerfile.reconcile | 14 + Dockerfile.s3config | 13 + Makefile | 2 + cmd/reconcile/main.go | 133 +++++++ cmd/s3config/main.go | 19 + cmd/server/main.go | 18 + compose.yaml | 196 ++++++++++ db/migrations/00001_init.sql | 51 +++ db/migrations/00002_add_idempotency_keys.sql | 17 + db/migrations/00003_attachments.sql | 38 ++ db/queries/attachments.sql | 95 +++++ db/queries/chats.sql | 73 ++++ db/queries/idempotency_keys.sql | 36 ++ db/queries/messages.sql | 34 ++ db/queries/sessions.sql | 24 ++ db/queries/users.sql | 21 ++ deploy/nginx.conf | 33 ++ go.mod | 41 +++ go.sum | 83 +++++ internal/app/app.go | 165 +++++++++ internal/app/cleanup.go | 149 ++++++++ internal/app/healthcheck.go | 46 +++ internal/app/router.go | 72 ++++ internal/config/config.go | 230 ++++++++++++ internal/credentials/credentials.go | 51 +++ internal/db/attachments.sql.go | 365 +++++++++++++++++++ internal/db/chats.sql.go | 232 ++++++++++++ internal/db/db.go | 32 ++ internal/db/idempotency_keys.sql.go | 120 ++++++ internal/db/messages.sql.go | 145 ++++++++ internal/db/models.go | 164 +++++++++ internal/db/sessions.sql.go | 81 ++++ internal/db/users.sql.go | 101 +++++ internal/dto/attachment.go | 79 ++++ internal/dto/chat.go | 50 +++ internal/dto/error.go | 25 ++ internal/dto/health.go | 5 + internal/dto/message.go | 64 ++++ internal/dto/session.go | 10 + internal/dto/user.go | 44 +++ internal/handler/attachment.go | 140 +++++++ internal/handler/auth.go | 80 ++++ internal/handler/chat.go | 150 ++++++++ internal/handler/health.go | 62 ++++ internal/handler/message.go | 188 ++++++++++ internal/handler/user.go | 95 +++++ internal/httpx/auth.go | 37 ++ internal/httpx/pagination.go | 34 ++ internal/httpx/request.go | 49 +++ internal/httpx/response.go | 68 ++++ internal/logger/logger.go | 14 + internal/middleware/auth.go | 50 +++ internal/middleware/concurrency.go | 41 +++ internal/middleware/instance_id.go | 14 + internal/middleware/logging.go | 53 +++ internal/middleware/request_id.go | 30 ++ internal/middleware/timeout.go | 17 + internal/model/attachment.go | 34 ++ internal/model/chat.go | 14 + internal/model/message.go | 16 + internal/model/session.go | 9 + internal/model/user.go | 14 + internal/postgres/errors.go | 25 ++ internal/postgres/pool.go | 34 ++ internal/reconcile/reconcile.go | 295 +++++++++++++++ internal/redis/client.go | 32 ++ internal/s3/client.go | 279 ++++++++++++++ internal/s3/config.go | 99 +++++ internal/service/attachment.go | 286 +++++++++++++++ internal/service/auth.go | 188 ++++++++++ internal/service/chat.go | 204 +++++++++++ internal/service/cursor.go | 41 +++ internal/service/message.go | 289 +++++++++++++++ internal/service/tx.go | 11 + internal/service/user.go | 83 +++++ scripts/restart.sh | 5 + scripts/stop-one.sh | 8 + sqlc.yaml | 34 ++ student-tests/attachment_failover_test.go | 92 +++++ student-tests/attachment_helpers_test.go | 106 ++++++ student-tests/attachment_load_test.go | 180 +++++++++ student-tests/attachment_test.go | 139 +++++++ student-tests/chat_rollback_test.go | 55 +++ student-tests/contract_test.go | 134 +++++++ student-tests/dependency_failure_test.go | 156 ++++++++ student-tests/helpers_test.go | 236 ++++++++++++ student-tests/idempotency_test.go | 169 +++++++++ student-tests/load_action_test.go | 150 ++++++++ student-tests/load_test.go | 162 ++++++++ student-tests/race_test.go | 100 +++++ student-tests/reconcile_test.go | 169 +++++++++ student-tests/registration_race_test.go | 77 ++++ student-tests/session_expiry_test.go | 42 +++ student-tests/session_test.go | 58 +++ student.mk | 44 +++ web/swagger/index.html | 21 ++ 101 files changed, 8426 insertions(+), 6 deletions(-) create mode 100644 Dockerfile create mode 100644 Dockerfile.migrate create mode 100644 Dockerfile.reconcile create mode 100644 Dockerfile.s3config create mode 100644 cmd/reconcile/main.go create mode 100644 cmd/s3config/main.go create mode 100644 cmd/server/main.go create mode 100644 compose.yaml create mode 100644 db/migrations/00001_init.sql create mode 100644 db/migrations/00002_add_idempotency_keys.sql create mode 100644 db/migrations/00003_attachments.sql create mode 100644 db/queries/attachments.sql create mode 100644 db/queries/chats.sql create mode 100644 db/queries/idempotency_keys.sql create mode 100644 db/queries/messages.sql create mode 100644 db/queries/sessions.sql create mode 100644 db/queries/users.sql create mode 100644 deploy/nginx.conf create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/app/app.go create mode 100644 internal/app/cleanup.go create mode 100644 internal/app/healthcheck.go create mode 100644 internal/app/router.go create mode 100644 internal/config/config.go create mode 100644 internal/credentials/credentials.go create mode 100644 internal/db/attachments.sql.go create mode 100644 internal/db/chats.sql.go create mode 100644 internal/db/db.go create mode 100644 internal/db/idempotency_keys.sql.go create mode 100644 internal/db/messages.sql.go create mode 100644 internal/db/models.go create mode 100644 internal/db/sessions.sql.go create mode 100644 internal/db/users.sql.go create mode 100644 internal/dto/attachment.go create mode 100644 internal/dto/chat.go create mode 100644 internal/dto/error.go create mode 100644 internal/dto/health.go create mode 100644 internal/dto/message.go create mode 100644 internal/dto/session.go create mode 100644 internal/dto/user.go create mode 100644 internal/handler/attachment.go create mode 100644 internal/handler/auth.go create mode 100644 internal/handler/chat.go create mode 100644 internal/handler/health.go create mode 100644 internal/handler/message.go create mode 100644 internal/handler/user.go create mode 100644 internal/httpx/auth.go create mode 100644 internal/httpx/pagination.go create mode 100644 internal/httpx/request.go create mode 100644 internal/httpx/response.go create mode 100644 internal/logger/logger.go create mode 100644 internal/middleware/auth.go create mode 100644 internal/middleware/concurrency.go create mode 100644 internal/middleware/instance_id.go create mode 100644 internal/middleware/logging.go create mode 100644 internal/middleware/request_id.go create mode 100644 internal/middleware/timeout.go create mode 100644 internal/model/attachment.go create mode 100644 internal/model/chat.go create mode 100644 internal/model/message.go create mode 100644 internal/model/session.go create mode 100644 internal/model/user.go create mode 100644 internal/postgres/errors.go create mode 100644 internal/postgres/pool.go create mode 100644 internal/reconcile/reconcile.go create mode 100644 internal/redis/client.go create mode 100644 internal/s3/client.go create mode 100644 internal/s3/config.go create mode 100644 internal/service/attachment.go create mode 100644 internal/service/auth.go create mode 100644 internal/service/chat.go create mode 100644 internal/service/cursor.go create mode 100644 internal/service/message.go create mode 100644 internal/service/tx.go create mode 100644 internal/service/user.go create mode 100644 scripts/restart.sh create mode 100644 scripts/stop-one.sh create mode 100644 sqlc.yaml create mode 100644 student-tests/attachment_failover_test.go create mode 100644 student-tests/attachment_helpers_test.go create mode 100644 student-tests/attachment_load_test.go create mode 100644 student-tests/attachment_test.go create mode 100644 student-tests/chat_rollback_test.go create mode 100644 student-tests/contract_test.go create mode 100644 student-tests/dependency_failure_test.go create mode 100644 student-tests/helpers_test.go create mode 100644 student-tests/idempotency_test.go create mode 100644 student-tests/load_action_test.go create mode 100644 student-tests/load_test.go create mode 100644 student-tests/race_test.go create mode 100644 student-tests/reconcile_test.go create mode 100644 student-tests/registration_race_test.go create mode 100644 student-tests/session_expiry_test.go create mode 100644 student-tests/session_test.go create mode 100644 student.mk create mode 100644 web/swagger/index.html diff --git a/.dockerignore b/.dockerignore index bc16e556..d89d8b24 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,4 @@ __pycache__ node_modules evidence .DS_Store +.agent diff --git a/.env.example b/.env.example index 119384b5..85589ca5 100644 --- a/.env.example +++ b/.env.example @@ -1,23 +1,29 @@ -# 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 +MAX_INFLIGHT_REQUESTS=0 SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. + +LOG_LEVEL=INFO + DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres + +# Session store: postgres | redis (redis requires CACHE_URL_FILE) +SESSION_STORE=redis 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 +S3_BOOTSTRAP_ACCESS_KEY_ID_FILE=/run/secrets/s3_bootstrap_access_key_id +S3_BOOTSTRAP_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_bootstrap_secret_access_key MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 + BROKER_URL_FILE=/run/secrets/broker_url WORKER_CONCURRENCY=2 JOB_MAX_ATTEMPTS=5 diff --git a/.gitignore b/.gitignore index b5a71896..1a3c10b5 100644 --- a/.gitignore +++ b/.gitignore @@ -28,5 +28,6 @@ coverage/ .DS_Store .idea/ .vscode/ +.agent/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..ed559f5f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,21 @@ +FROM golang:1.27.1 AS build +WORKDIR /src + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -o /out/server ./cmd/server + +FROM gcr.io/distroless/static-debian12:nonroot +WORKDIR /app +COPY --from=build /out/server . +COPY contracts ./contracts +COPY web/swagger ./web/swagger + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["/app/server", "healthcheck"] + +ENTRYPOINT ["/app/server"] diff --git a/Dockerfile.migrate b/Dockerfile.migrate new file mode 100644 index 00000000..4b82ab32 --- /dev/null +++ b/Dockerfile.migrate @@ -0,0 +1,8 @@ +FROM golang:1.27.1 AS build +ENV CGO_ENABLED=0 +RUN go install github.com/pressly/goose/v3/cmd/goose@v3.28.0 + +FROM alpine:3.24 +COPY --from=build /go/bin/goose /usr/local/bin/goose +COPY db/migrations /migrations +ENTRYPOINT ["sh", "-c", "goose -dir /migrations postgres \"$(cat /run/secrets/database_url)\" up"] diff --git a/Dockerfile.reconcile b/Dockerfile.reconcile new file mode 100644 index 00000000..a8042a53 --- /dev/null +++ b/Dockerfile.reconcile @@ -0,0 +1,14 @@ +FROM golang:1.27.1 AS build +WORKDIR /src + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -o /out/reconcile ./cmd/reconcile + +FROM gcr.io/distroless/static-debian12:nonroot +WORKDIR /app +COPY --from=build /out/reconcile . + +ENTRYPOINT ["/app/reconcile"] diff --git a/Dockerfile.s3config b/Dockerfile.s3config new file mode 100644 index 00000000..87053443 --- /dev/null +++ b/Dockerfile.s3config @@ -0,0 +1,13 @@ +FROM golang:1.27.1 AS build +ENV CGO_ENABLED=0 +WORKDIR /src + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . +RUN go build -o /out/s3config ./cmd/s3config + +FROM gcr.io/distroless/static-debian12:nonroot +COPY --from=build /out/s3config /usr/local/bin/s3config +ENTRYPOINT ["/usr/local/bin/s3config"] diff --git a/Makefile b/Makefile index 5d86d171..75912960 100644 --- a/Makefile +++ b/Makefile @@ -28,3 +28,5 @@ 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) + +include student.mk diff --git a/cmd/reconcile/main.go b/cmd/reconcile/main.go new file mode 100644 index 00000000..a71f7e76 --- /dev/null +++ b/cmd/reconcile/main.go @@ -0,0 +1,133 @@ +package main + +import ( + "context" + "encoding/json" + "flag" + "fmt" + "log/slog" + "os" + "os/signal" + "syscall" + + "github.com/joho/godotenv" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/postgres" + "mtusi2026-messenger/internal/reconcile" + s3store "mtusi2026-messenger/internal/s3" +) + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, "reconcile:", err) + os.Exit(1) + } +} + +func run() error { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + return err + } + + dryRun := flag.Bool("dry-run", true, "report findings without changing PostgreSQL or S3") + grace := flag.Duration("grace", reconcile.DefaultGrace, "minimum age before an object or row may be repaired") + maxDeletes := flag.Int("max-deletes", reconcile.DefaultMaxDeletes, "maximum destructive repairs per run") + asJSON := flag.Bool("json", false, "print the report as JSON") + flag.Parse() + + cfg := config.Load() + log := slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: cfg.Logging.Level})) + + databaseURL, err := cfg.Database.URL() + if err != nil { + return err + } + + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + + pool, err := postgres.New(ctx, databaseURL) + if err != nil { + return err + } + defer pool.Close() + + s3Client, err := s3store.New(ctx, cfg.S3, log) + if err != nil { + return err + } + + reconciler := reconcile.New(s3Client, db.New(pool), log) + + report, err := reconciler.Run(ctx, reconcile.Options{ + DryRun: *dryRun, + Grace: *grace, + MaxDeletes: *maxDeletes, + }) + if err != nil { + return err + } + + if *asJSON { + encoder := json.NewEncoder(os.Stdout) + encoder.SetIndent("", " ") + if err := encoder.Encode(report); err != nil { + return err + } + } else { + printReport(report) + } + + if len(report.Errors) > 0 { + return fmt.Errorf("completed with %d errors", len(report.Errors)) + } + + return nil +} + +func printReport(report reconcile.Report) { + fmt.Printf("dry_run=%t duration_ms=%d\n", report.DryRun, report.DurationMS) + fmt.Printf( + "scanned objects=%d rows=%d list_pages=%d\n", + report.ScannedObjects, + report.ScannedRows, + report.ListPages, + ) + fmt.Printf( + "found orphan_objects=%d missing_attachments=%d stale_uploads=%d corrupt_objects=%d\n", + len(report.OrphanObjects), + len(report.MissingAttachments), + len(report.StaleUploads), + len(report.CorruptObjects), + ) + fmt.Printf( + "skipped fresh=%d referenced=%d inactive=%d\n", + report.SkippedFresh, + report.SkippedReferenced, + report.SkippedInactive, + ) + fmt.Printf( + "changes deleted_objects=%d deleted_rows=%d marked_failed=%d\n", + report.DeletedObjects, + report.DeletedRows, + report.MarkedFailed, + ) + + for _, key := range report.OrphanObjects { + fmt.Printf("orphan_object %s\n", key) + } + for _, key := range report.CorruptObjects { + fmt.Printf("corrupt_object %s\n", key) + } + for _, id := range report.MissingAttachments { + fmt.Printf("missing_attachment %s\n", id) + } + for _, id := range report.StaleUploads { + fmt.Printf("stale_upload %s\n", id) + } + for _, message := range report.Errors { + fmt.Printf("error %s\n", message) + } +} diff --git a/cmd/s3config/main.go b/cmd/s3config/main.go new file mode 100644 index 00000000..c619e27a --- /dev/null +++ b/cmd/s3config/main.go @@ -0,0 +1,19 @@ +package main + +import ( + "fmt" + "os" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/s3" +) + +func main() { + cfg := config.LoadS3() + + err := s3.WriteConfig("/config/s3.json", cfg) + if err != nil { + fmt.Fprintln(os.Stderr, "s3config:", err) + os.Exit(1) + } +} diff --git a/cmd/server/main.go b/cmd/server/main.go new file mode 100644 index 00000000..e4032d40 --- /dev/null +++ b/cmd/server/main.go @@ -0,0 +1,18 @@ +package main + +import ( + "log" + "os" + + "mtusi2026-messenger/internal/app" +) + +func main() { + if len(os.Args) > 1 && os.Args[1] == "healthcheck" { + os.Exit(app.Healthcheck()) + } + + if err := app.Run(); err != nil { + log.Fatal(err) + } +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..1c52a328 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,196 @@ +services: + api: + build: + context: . + dockerfile: Dockerfile + image: mtusi-messenger:lab4 + env_file: + - .env + secrets: + - database_url + - cache_url + - s3_access_key_id + - s3_secret_access_key + - s3_bootstrap_access_key_id + - s3_bootstrap_secret_access_key + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: + cpus: "${API_CPUS:-0.5}" + memory: ${API_MEM:-512M} + depends_on: + migrate: + condition: service_completed_successfully + s3: + condition: service_healthy + restart: unless-stopped + + postgres: + image: postgres:18.6 + ports: + - "127.0.0.1:5432:5432" + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql + healthcheck: + test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 10 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + restart: unless-stopped + + migrate: + build: + context: . + dockerfile: Dockerfile.migrate + secrets: + - database_url + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + depends_on: + postgres: + condition: service_healthy + restart: "no" + + redis: + image: redis:8.8.3-alpine3.23 + command: ["redis-server", "--save", "", "--appendonly", "no"] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + deploy: + resources: + limits: + cpus: "0.25" + memory: 128M + restart: unless-stopped + + s3-config-init: + build: + context: . + dockerfile: Dockerfile.s3config + image: mtusi-messenger-s3config:lab4 + entrypoint: ["/usr/local/bin/s3config"] + user: "0:0" + env_file: + - .env + secrets: + - s3_access_key_id + - s3_secret_access_key + - s3_bootstrap_access_key_id + - s3_bootstrap_secret_access_key + volumes: + - s3config:/config + deploy: + resources: + limits: + cpus: "0.25" + memory: 64M + restart: "no" + + s3: + image: chrislusf/seaweedfs:4.51 + command: + - "server" + - "-dir=/data" + - "-s3" + - "-s3.port=9000" + - "-s3.iam=false" + - "-filer.disableHttp" + - "-s3.port.iceberg=0" + - "-s3.port.lance=0" + - "-s3.config=/config/s3.json" + depends_on: + s3-config-init: + condition: service_completed_successfully + volumes: + - s3config:/config:ro + - seaweedfs:/data + healthcheck: + test: + - CMD-SHELL + - wget -qO- http://127.0.0.1:9000/healthz >/dev/null && wget -qO- http://127.0.0.1:9333/dir/status | grep -q '"Url":' + interval: 10s + timeout: 5s + retries: 5 + start_period: 20s + deploy: + resources: + limits: + cpus: "0.5" + memory: 512M + restart: unless-stopped + + load_balancer: + image: nginx:1.31.7-alpine3.24 + ports: + - "127.0.0.1:8080:8080" + volumes: + - ./deploy/nginx.conf:/etc/nginx/nginx.conf:ro + deploy: + resources: + limits: + cpus: ${LB_CPUS:-0.5} + memory: 128M + depends_on: + api: + condition: service_healthy + restart: unless-stopped + + reconcile: + build: + context: . + dockerfile: Dockerfile.reconcile + image: mtusi-messenger-reconcile:lab4 + profiles: ["tools"] + env_file: + - .env + secrets: + - database_url + - s3_access_key_id + - s3_secret_access_key + - s3_bootstrap_access_key_id + - s3_bootstrap_secret_access_key + deploy: + resources: + limits: + cpus: "0.25" + memory: 64M + restart: "no" + +secrets: + postgres_password: + file: ./secrets/postgres_password.txt + database_url: + file: ./secrets/database_url.txt + cache_url: + file: ./secrets/cache_url.txt + s3_access_key_id: + file: ./secrets/s3_access_key_id.txt + s3_secret_access_key: + file: ./secrets/s3_secret_access_key.txt + s3_bootstrap_access_key_id: + file: ./secrets/s3_bootstrap_access_key_id.txt + s3_bootstrap_secret_access_key: + file: ./secrets/s3_bootstrap_secret_access_key.txt + +volumes: + pgdata: + seaweedfs: + s3config: diff --git a/db/migrations/00001_init.sql b/db/migrations/00001_init.sql new file mode 100644 index 00000000..ae4b6415 --- /dev/null +++ b/db/migrations/00001_init.sql @@ -0,0 +1,51 @@ +-- +goose Up +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL + CONSTRAINT users_display_name_not_blank CHECK (display_name ~ '\S'), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE sessions ( + token_hash text PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL +); + +CREATE INDEX idx_sessions_expires_at ON sessions (expires_at); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL + CONSTRAINT chats_title_not_blank CHECK (title ~ '\S'), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX idx_chat_members_user_id ON chat_members (user_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id); + +-- +goose Down +DROP TABLE messages; +DROP TABLE chat_members; +DROP TABLE chats; +DROP TABLE sessions; +DROP TABLE users; diff --git a/db/migrations/00002_add_idempotency_keys.sql b/db/migrations/00002_add_idempotency_keys.sql new file mode 100644 index 00000000..3820d3ca --- /dev/null +++ b/db/migrations/00002_add_idempotency_keys.sql @@ -0,0 +1,17 @@ +-- +goose Up +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + method text NOT NULL, + path text NOT NULL, + key text NOT NULL, + request_hash text NOT NULL, + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE + DEFERRABLE INITIALLY DEFERRED, + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, key) +); + +CREATE INDEX idx_idempotency_keys_created_at ON idempotency_keys (created_at); + +-- +goose Down +DROP TABLE idempotency_keys; diff --git a/db/migrations/00003_attachments.sql b/db/migrations/00003_attachments.sql new file mode 100644 index 00000000..febdea50 --- /dev/null +++ b/db/migrations/00003_attachments.sql @@ -0,0 +1,38 @@ +-- +goose Up +CREATE TYPE attachment_content_type AS ENUM ('image/png', 'image/jpeg'); +CREATE TYPE attachment_status AS ENUM ('queued', 'processing', 'ready', 'failed'); + +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + owner_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + s3_key text NOT NULL UNIQUE, + filename text NOT NULL, + content_type attachment_content_type NOT NULL, + size_bytes int NOT NULL CHECK (size_bytes > 0 AND size_bytes <= 10485760), + sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + status attachment_status NOT NULL DEFAULT 'queued', + error_code text, + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now() +); + +CREATE INDEX idx_attachments_chat_id ON attachments (chat_id, created_at); +CREATE INDEX idx_attachments_owner_id ON attachments (owner_id); +CREATE INDEX idx_attachments_queued_created_at ON attachments (created_at) WHERE status = 'queued'; + +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE RESTRICT, + position int NOT NULL CHECK (position >= 0 AND position < 10), + PRIMARY KEY (message_id, attachment_id), + UNIQUE (message_id, position) +); + +CREATE INDEX idx_message_attachments_attachment_id ON message_attachments (attachment_id); + +-- +goose Down +DROP TABLE message_attachments; +DROP TABLE attachments; +DROP TYPE attachment_status; +DROP TYPE attachment_content_type; diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql new file mode 100644 index 00000000..9f6ce774 --- /dev/null +++ b/db/queries/attachments.sql @@ -0,0 +1,95 @@ +-- name: CreateAttachment :one +INSERT INTO attachments ( + id, + chat_id, + owner_id, + s3_key, + filename, + content_type, + size_bytes, + sha256, + error_code +) +SELECT + sqlc.arg(id)::uuid, + sqlc.arg(chat_id)::uuid, + sqlc.arg(owner_id)::uuid, + sqlc.arg(s3_key)::text, + sqlc.arg(filename)::text, + sqlc.arg(content_type)::attachment_content_type, + sqlc.arg(size_bytes)::int, + sqlc.arg(sha256)::text, + NULLIF(sqlc.arg(error_code)::text, '') +WHERE EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = sqlc.arg(chat_id) + AND user_id = sqlc.arg(owner_id) +) +RETURNING *; + +-- name: CreateMessageAttachment :exec +INSERT INTO message_attachments ( + message_id, + attachment_id, + position +) VALUES ( + sqlc.arg(message_id), + sqlc.arg(attachment_id), + sqlc.arg(position) +); + +-- name: GetAttachmentByID :one +SELECT * FROM attachments +WHERE id = $1::uuid; + +-- name: ListAttachmentsByIDs :many +SELECT status +FROM attachments +WHERE chat_id = sqlc.arg(chat_id)::uuid + AND id = ANY(sqlc.arg(ids)::uuid[]); + +-- name: ListMessageAttachmentIDs :many +SELECT attachment_id +FROM message_attachments +WHERE message_id = sqlc.arg(message_id)::uuid +ORDER BY position; + +-- name: ListMessageAttachmentsByMessageIDs :many +SELECT message_id, attachment_id +FROM message_attachments +WHERE message_id = ANY(sqlc.arg(message_ids)::uuid[]) +ORDER BY message_id, position; + +-- name: ListStaleAttachmentUploads :many +SELECT id, s3_key FROM attachments +WHERE status = 'queued' AND created_at < sqlc.arg(cutoff)::timestamptz; + +-- name: ListAttachmentsForReconcile :many +SELECT + a.id, + a.s3_key, + a.status, + a.size_bytes, + a.created_at, + EXISTS ( + SELECT 1 FROM message_attachments ma + WHERE ma.attachment_id = a.id + ) AS referenced +FROM attachments a; + +-- name: MarkAttachmentFailedIfReady :execrows +UPDATE attachments +SET status = 'failed', + error_code = sqlc.arg(error_code)::text, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid AND status = 'ready'; + +-- name: MarkAttachmentReady :one +UPDATE attachments +SET status = 'ready', updated_at = now() +WHERE id = $1::uuid +RETURNING *; + +-- name: DeleteQueuedAttachment :execrows +DELETE FROM attachments +WHERE id = sqlc.arg(id)::uuid AND status = 'queued'; diff --git a/db/queries/chats.sql b/db/queries/chats.sql new file mode 100644 index 00000000..80d2ba3e --- /dev/null +++ b/db/queries/chats.sql @@ -0,0 +1,73 @@ +-- name: CreateChat :one +INSERT INTO chats ( + id, + title +) VALUES ( + sqlc.arg(id), + sqlc.arg(title) +) +RETURNING *; + +-- name: AddChatMembers :exec +INSERT INTO chat_members ( + chat_id, + user_id +) +SELECT + sqlc.arg(chat_id)::uuid, + unnest(sqlc.arg(user_ids)::uuid[]); + +-- name: IsChatMember :one +SELECT EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = sqlc.arg(chat_id) + AND user_id = sqlc.arg(user_id) +); + +-- name: GetChat :one +SELECT + c.*, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +FROM chats c +WHERE c.id = sqlc.arg(id) + AND EXISTS ( + SELECT 1 FROM chat_members m + WHERE m.chat_id = c.id + AND m.user_id = sqlc.arg(user_id) + ); + +-- name: ListChatsFirstPage :many +SELECT + c.*, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +FROM chats c +JOIN chat_members m ON m.chat_id = c.id +WHERE m.user_id = sqlc.arg(user_id) +ORDER BY c.created_at, c.id +LIMIT sqlc.arg(lim); + +-- name: ListChatsAfter :many +SELECT + c.*, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +FROM chats c +JOIN chat_members m ON m.chat_id = c.id +WHERE m.user_id = sqlc.arg(user_id) + AND (c.created_at, c.id) > ( + sqlc.arg(after_created_at)::timestamptz, + sqlc.arg(after_id)::uuid + ) +ORDER BY c.created_at, c.id +LIMIT sqlc.arg(lim); diff --git a/db/queries/idempotency_keys.sql b/db/queries/idempotency_keys.sql new file mode 100644 index 00000000..95239270 --- /dev/null +++ b/db/queries/idempotency_keys.sql @@ -0,0 +1,36 @@ +-- name: CreateIdempotencyKey :execrows +INSERT INTO idempotency_keys ( + user_id, + method, + path, + key, + request_hash, + message_id +) VALUES ( + sqlc.arg(user_id), + sqlc.arg(method), + sqlc.arg(path), + sqlc.arg(key), + sqlc.arg(request_hash), + sqlc.arg(message_id) +) +ON CONFLICT DO NOTHING; + +-- name: GetIdempotentMessage :one +SELECT + k.request_hash, + m.id, + m.chat_id, + m.sender_id, + m.text, + m.created_at +FROM idempotency_keys AS k +JOIN messages AS m ON m.id = k.message_id +WHERE k.user_id = sqlc.arg(user_id) + AND k.method = sqlc.arg(method) + AND k.path = sqlc.arg(path) + AND k.key = sqlc.arg(key); + +-- name: DeleteExpiredIdempotencyKeys :execrows +DELETE FROM idempotency_keys +WHERE created_at < sqlc.arg(cutoff); diff --git a/db/queries/messages.sql b/db/queries/messages.sql new file mode 100644 index 00000000..69635c4f --- /dev/null +++ b/db/queries/messages.sql @@ -0,0 +1,34 @@ +-- name: CreateMessage :one +INSERT INTO messages ( + id, + chat_id, + sender_id, + text +) +SELECT + sqlc.arg(id)::uuid, + sqlc.arg(chat_id)::uuid, + sqlc.arg(sender_id)::uuid, + sqlc.arg(text)::text +WHERE EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = sqlc.arg(chat_id) + AND user_id = sqlc.arg(sender_id) +) +RETURNING *; + +-- name: ListMessagesFirstPage :many +SELECT * FROM messages +WHERE chat_id = sqlc.arg(chat_id) +ORDER BY created_at, id +LIMIT sqlc.arg(lim); + +-- name: ListMessagesAfter :many +SELECT * FROM messages +WHERE chat_id = sqlc.arg(chat_id) + AND (created_at, id) > ( + sqlc.arg(after_created_at)::timestamptz, + sqlc.arg(after_id)::uuid + ) +ORDER BY created_at, id +LIMIT sqlc.arg(lim); diff --git a/db/queries/sessions.sql b/db/queries/sessions.sql new file mode 100644 index 00000000..065907f2 --- /dev/null +++ b/db/queries/sessions.sql @@ -0,0 +1,24 @@ +-- name: CreateSession :exec +INSERT INTO sessions ( + token_hash, + user_id, + expires_at +) VALUES ( + sqlc.arg(token_hash), + sqlc.arg(user_id), + sqlc.arg(expires_at) +); + +-- name: GetActiveSession :one +SELECT user_id, expires_at FROM sessions +WHERE token_hash = sqlc.arg(token_hash) + AND expires_at > now(); + +-- name: DeleteSession :execrows +DELETE FROM sessions +WHERE token_hash = sqlc.arg(token_hash) + AND expires_at > now(); + +-- name: DeleteExpiredSessions :execrows +DELETE FROM sessions +WHERE expires_at <= now(); diff --git a/db/queries/users.sql b/db/queries/users.sql new file mode 100644 index 00000000..d6e9c030 --- /dev/null +++ b/db/queries/users.sql @@ -0,0 +1,21 @@ +-- name: CreateUser :one +INSERT INTO users ( + id, + username, + display_name, + password_hash +) VALUES ( + sqlc.arg(id), + sqlc.arg(username), + sqlc.arg(display_name), + sqlc.arg(password_hash) +) +RETURNING id, username, display_name, created_at; + +-- name: GetUser :one +SELECT id, username, display_name, created_at FROM users +WHERE id = sqlc.arg(id); + +-- name: GetUserByUsername :one +SELECT * FROM users +WHERE username = sqlc.arg(username); diff --git a/deploy/nginx.conf b/deploy/nginx.conf new file mode 100644 index 00000000..8c2a5941 --- /dev/null +++ b/deploy/nginx.conf @@ -0,0 +1,33 @@ +events { + worker_connections 4096; +} + +http { + resolver 127.0.0.11 valid=2s ipv6=off; + + server { + listen 8080; + + client_max_body_size 11m; + + location ~ ^/api/v1/chats/[^/]+/messages$ { + set $backend http://api:8080; + proxy_pass $backend; + + proxy_connect_timeout 1s; + proxy_read_timeout 6s; + proxy_next_upstream error timeout http_500 http_502 non_idempotent; + proxy_next_upstream_tries 2; + } + + location / { + set $backend http://api:8080; + proxy_pass $backend; + + proxy_connect_timeout 1s; + proxy_read_timeout 6s; + proxy_next_upstream error timeout http_500 http_502; + proxy_next_upstream_tries 2; + } + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..dbbd6734 --- /dev/null +++ b/go.mod @@ -0,0 +1,41 @@ +module mtusi2026-messenger + +go 1.26.0 + +require ( + github.com/aws/aws-sdk-go-v2 v1.47.5 + github.com/aws/aws-sdk-go-v2/config v1.33.13 + github.com/aws/aws-sdk-go-v2/credentials v1.20.13 + github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6 + github.com/aws/smithy-go v1.28.7 + github.com/go-chi/chi/v5 v5.5.0 + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.11.0 + github.com/joho/godotenv v1.5.1 + github.com/redis/go-redis/v9 v9.23.0 + golang.org/x/crypto v0.58.0 +) + +require ( + github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.12.1 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.39.1 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.51.6 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + go.uber.org/atomic v1.12.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/text v0.43.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..4a47d012 --- /dev/null +++ b/go.sum @@ -0,0 +1,83 @@ +github.com/aws/aws-sdk-go-v2 v1.47.5 h1:5yA+A+BiXbDq1ZLbYwPViwhEGDMdR0MEhL8Jh2LnLS4= +github.com/aws/aws-sdk-go-v2 v1.47.5/go.mod h1:iNIkogrRvFwm+1OQIUOP2lPBtlXZboOIUWiCa+pHEMw= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 h1:MW0Iql1SOTgQPj8mCxrU/eH/K/AIDWi08ItOsXaWRLU= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25/go.mod h1:+ucVYmHYB3JqVueY0E1RHahdXAnKQbIHqybSbvOUbOM= +github.com/aws/aws-sdk-go-v2/config v1.33.13 h1:u52x6ISQOx172tpwM0VRxhJzEsTJYpMcEYUGM2A1wrw= +github.com/aws/aws-sdk-go-v2/config v1.33.13/go.mod h1:/ixtz6XPHb42zekjQ0LqD9XjTpTysNWhIGwufY1OzI4= +github.com/aws/aws-sdk-go-v2/credentials v1.20.13 h1:j4z41OtspmQ3ftQycaDunJ26b69a9SHfaSVUPqgRv8k= +github.com/aws/aws-sdk-go-v2/credentials v1.20.13/go.mod h1:SgPA1oS3b+dlMxZb618jDmGNscpXSCaxz15igS52OlE= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 h1:iXjy2SFhGYNB1jWZBhQqq8HbhsbPF23w+/zbMvPXsTg= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5/go.mod h1:k0RUiBnyXU0AXRJ9tJmY2jQke6XUIX2PNVnWtvgaPtc= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8 h1:gzIWc3DTPfPbWKrQnmL6BV6WD7NPD1htxzgdk/bQ/Z4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8/go.mod h1:vvUA5cDAZWGo4R14FZPZfXfJCmgsafOWEq78Kg0D+ug= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8 h1:PWv+vG8aCLS8qd+HPdYhK7Vees90aKHWFFQ1AGYD/8E= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8/go.mod h1:xxPZEpflYHJA12366ZGyq66z9dHPCoeCIu99Jck+MPw= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8 h1:WOp5De9iWdEHDPh2Kb0tBP3vGBm/dVAuRGh4a4tqduo= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8/go.mod h1:z8W8YgfhbWl62XqcTtK+CxPrE+iHGRVUOtrrbIOp7ZY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23 h1:MCIR6iZaCKO4UE0hUvoWWLI6JVjppopV64JfAJaMjng= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23/go.mod h1:pphWFS+z0MmIPivj8c/6bATd1Z+Av7Ust75DPdEFsPA= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9 h1:GACgECI422Xt5n4Pojr3O0aocPv8lfH4PJe2Aon5Wv8= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9/go.mod h1:lPfnRkHpn1qWZJLbVEw10rIqSuCee1pNQTyGkUjAYh8= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8 h1:+PMpWlJYOn2tm7sm6OZ/ZLd4jStl17T7wjNapd1Rczs= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8/go.mod h1:cnG3xZLGQL4c/bt8pjdzlFtZsW7epBBuNS04a5xMjdo= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8 h1:RS1Wt+K0r4X0ci9Vf4JYTUfHzsQihYA2LgGJeEneKpk= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8/go.mod h1:adMnTy5kyoUW86jhXnGSVc/mvMQI4GZd1qYWMeaS8M8= +github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6 h1:to7+Vr3rLkpYRwVKJ5QRriI0eE306vrVN/6TnVHgxvY= +github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6/go.mod h1:Jc89ASa2k7HMAskj3bSnt8bf+k+p2IApzkoXnEjkgUw= +github.com/aws/aws-sdk-go-v2/service/signin v1.12.1 h1:WZLC+k/CZx11kZGQDqu9mpA8yhiXGX2I//jhuJE1FDo= +github.com/aws/aws-sdk-go-v2/service/signin v1.12.1/go.mod h1:wxAk0D2oVBSjuXEIzvcKxTZfM90zticdAbh/VD42L0Y= +github.com/aws/aws-sdk-go-v2/service/sso v1.39.1 h1:4VB/dnDo7pmXSLQMszSoBzWndENuc7mzwTpD6lQn77A= +github.com/aws/aws-sdk-go-v2/service/sso v1.39.1/go.mod h1:UGsEYgWz4Gi+46vDQ5zkFLqUgJziyOE2SXjZjgmfmHc= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1 h1:w8yui2ZqdHmGwVBDGvazoIvKw/DnLENBLkYnN8q8iqo= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1/go.mod h1:gJSdIY6YUzDvqQLcMtPVZgBRHrFwzHryvpE8Igzbxps= +github.com/aws/aws-sdk-go-v2/service/sts v1.51.6 h1:BVjKrtRUtSYKztBCCfE1oAB+d3ViKcW2cKZfserOqMQ= +github.com/aws/aws-sdk-go-v2/service/sts v1.51.6/go.mod h1:eSukFLeLkPMm+1OxDR+F0joauZdyBkF47Ow7MqjZiJw= +github.com/aws/smithy-go v1.28.7 h1:h/n1SHrwVtaDYLz8mR1/Kq4Xh4RaFbFW7bOYckg9mfE= +github.com/aws/smithy-go v1.28.7/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +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/go-chi/chi/v5 v5.5.0 h1:xdKQ1dJmVJsmgahrXSKhUx8NyVPzpwdlyrrQFpMPJgg= +github.com/go-chi/chi/v5 v5.5.0/go.mod h1:d1IG7GtKPSjPyBP365PH8sAGVHk3qfB/IhjFNRH1wWM= +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.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +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/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +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.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= +github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +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= diff --git a/internal/app/app.go b/internal/app/app.go new file mode 100644 index 00000000..80a3c9f2 --- /dev/null +++ b/internal/app/app.go @@ -0,0 +1,165 @@ +package app + +import ( + "context" + "net/http" + "os" + "os/signal" + "sync" + "syscall" + "time" + + "github.com/joho/godotenv" + + goredis "github.com/redis/go-redis/v9" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/logger" + "mtusi2026-messenger/internal/postgres" + "mtusi2026-messenger/internal/redis" + s3store "mtusi2026-messenger/internal/s3" + "mtusi2026-messenger/internal/service" +) + +func Run() error { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + return err + } + + cfg := config.Load() + + log := logger.New(cfg.Logging.Level).With("instance_id", cfg.Server.InstanceID) + + dbURL, err := cfg.Database.URL() + if err != nil { + log.Error("read database url", "error", err) + return err + } + + pool, err := postgres.New(context.Background(), dbURL) + if err != nil { + log.Error("connect to database", "error", err) + return err + } + defer pool.Close() + + queries := db.New(pool) + + var rdb *goredis.Client + if cfg.UseCache() { + cacheURL, err := cfg.Redis.URL() + if err != nil { + log.Error("read redis url", "error", err) + return err + } + + rdb, err = redis.New(context.Background(), log, cacheURL) + if err != nil { + log.Error("create redis client", "error", err) + return err + } + defer rdb.Close() + } + + log.Info("session store configured", "store", cfg.SessionStore) + + s3Client, err := s3store.New(context.Background(), cfg.S3, log) + if err != nil { + log.Error("create s3 client", "error", err) + return err + } + + ensureCtx, cancelEnsure := context.WithTimeout(context.Background(), 10*time.Second) + err = s3Client.EnsureBucket(ensureCtx) + cancelEnsure() + if err != nil { + log.Error("ensure s3 bucket", "error", err) + return err + } + + log.Info("s3 storage ready", "endpoint", cfg.S3.Endpoint, "bucket", s3Client.Bucket()) + + cleanupCtx, stopCleanup := context.WithCancel(context.Background()) + var cleanupWG sync.WaitGroup + cleanupWG.Go(func() { + runSessionCleanup(cleanupCtx, log, queries, sessionCleanupInterval) + }) + cleanupWG.Go(func() { + runIdempotencyCleanup(cleanupCtx, log, queries, cfg.Server.IdempotencyTTL, idempotencyCleanupInterval) + }) + cleanupWG.Go(func() { + runAttachmentCleanup( + cleanupCtx, + log, + queries, + s3Client, + attachmentOrphanGracePeriod, + attachmentCleanupInterval, + ) + }) + defer func() { + stopCleanup() + cleanupWG.Wait() + }() + + authService := service.NewAuthService(queries, rdb, cfg.Server.SessionTTL, log) + userService := service.NewUserService(queries) + chatService := service.NewChatService(pool, queries) + messageService := service.NewMessageService(pool, queries) + attachmentService := service.NewAttachmentService(queries, s3Client, cfg.S3.MaxUploadBytes, cfg.S3.MaxImagePixels) + + router := NewRouter( + log, + cfg.Server.InstanceID, + cfg.Server.MaxInflightRequests, + cfg.S3.MaxUploadBytes, + pool, + s3Client, + authService, + userService, + chatService, + messageService, + attachmentService, + ) + + server := &http.Server{ + Addr: cfg.Server.Host + ":" + cfg.Server.Port, + Handler: router, + } + + serverErrors := make(chan error, 1) + + go func() { + log.Info("server starting", "addr", server.Addr) + serverErrors <- server.ListenAndServe() + }() + + signalCh := make(chan os.Signal, 1) + signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM) + defer signal.Stop(signalCh) + + select { + case err := <-serverErrors: + if err == http.ErrServerClosed { + return nil + } + + log.Error("server failed", "error", err) + return err + + case sig := <-signalCh: + log.Info("shutdown signal received", "signal", sig.String()) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + if err := server.Shutdown(ctx); err != nil { + log.Error("server shutdown failed", "error", err) + return err + } + + log.Info("server stopped") + return nil + } +} diff --git a/internal/app/cleanup.go b/internal/app/cleanup.go new file mode 100644 index 00000000..c27528de --- /dev/null +++ b/internal/app/cleanup.go @@ -0,0 +1,149 @@ +package app + +import ( + "context" + "log/slog" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/db" +) + +const ( + sessionCleanupInterval = time.Hour + idempotencyCleanupInterval = time.Hour + + attachmentCleanupInterval = 10 * time.Minute + attachmentOrphanGracePeriod = time.Hour +) + +type sessionCleaner interface { + DeleteExpiredSessions(ctx context.Context) (int64, error) +} + +type idempotencyCleaner interface { + DeleteExpiredIdempotencyKeys(ctx context.Context, cutoff time.Time) (int64, error) +} + +type staleUploadLister interface { + ListStaleAttachmentUploads(ctx context.Context, cutoff time.Time) ([]db.ListStaleAttachmentUploadsRow, error) + DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) +} + +type objectDeleter interface { + DeleteAdmin(ctx context.Context, key string) error +} + +func runSessionCleanup(ctx context.Context, log *slog.Logger, q sessionCleaner, interval time.Duration) { + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + n, err := q.DeleteExpiredSessions(ctx) + if err != nil { + if ctx.Err() == nil { + log.Error("delete expired sessions", "error", err) + } + continue + } + if n > 0 { + log.Info("expired sessions deleted", "count", n) + } + } + } +} + +func runIdempotencyCleanup( + ctx context.Context, + log *slog.Logger, + q idempotencyCleaner, + ttl time.Duration, + interval time.Duration, +) { + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + n, err := q.DeleteExpiredIdempotencyKeys(ctx, time.Now().Add(-ttl)) + if err != nil { + if ctx.Err() == nil { + log.Error("delete expired idempotency keys", "error", err) + } + continue + } + if n > 0 { + log.Info("expired idempotency keys deleted", "count", n) + } + } + } +} + +func runAttachmentCleanup( + ctx context.Context, + log *slog.Logger, + q staleUploadLister, + store objectDeleter, + grace time.Duration, + interval time.Duration, +) { + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + cleanupStaleUploads(ctx, log, q, store, grace) + } + } +} + +func cleanupStaleUploads( + ctx context.Context, + log *slog.Logger, + q staleUploadLister, + store objectDeleter, + grace time.Duration, +) { + cutoff := time.Now().Add(-grace) + + rows, err := q.ListStaleAttachmentUploads(ctx, cutoff) + if err != nil { + if ctx.Err() == nil { + log.Error("list stale attachment uploads", "error", err) + } + return + } + + deleted := 0 + + for _, row := range rows { + removed, err := q.DeleteQueuedAttachment(ctx, row.ID) + if err != nil { + log.Error("delete stale upload row", "id", row.ID, "error", err) + continue + } + if removed == 0 { + continue + } + if err := store.DeleteAdmin(ctx, row.S3Key); err != nil { + log.Error("delete stale upload object", "key", row.S3Key, "error", err) + continue + } + deleted++ + } + + if deleted > 0 { + log.Info("stale attachment uploads deleted", "count", deleted) + } +} diff --git a/internal/app/healthcheck.go b/internal/app/healthcheck.go new file mode 100644 index 00000000..6cab9274 --- /dev/null +++ b/internal/app/healthcheck.go @@ -0,0 +1,46 @@ +package app + +import ( + "context" + "fmt" + "net/http" + "os" + "time" + + "mtusi2026-messenger/internal/config" + + "github.com/joho/godotenv" +) + +func Healthcheck() int { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + fmt.Fprintln(os.Stderr, "healthcheck: load env:", err) + return 1 + } + + cfg := config.Load() + url := fmt.Sprintf("http://localhost:%s/health/ready", cfg.Server.Port) + + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + fmt.Fprintln(os.Stderr, "healthcheck: build request:", err) + return 1 + } + + resp, err := http.DefaultClient.Do(req) + if err != nil { + fmt.Fprintln(os.Stderr, "healthcheck: request failed:", err) + return 1 + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + fmt.Fprintln(os.Stderr, "healthcheck: unexpected status", resp.StatusCode) + return 1 + } + + return 0 +} diff --git a/internal/app/router.go b/internal/app/router.go new file mode 100644 index 00000000..86bed0e6 --- /dev/null +++ b/internal/app/router.go @@ -0,0 +1,72 @@ +package app + +import ( + "log/slog" + "net/http" + "time" + + "github.com/go-chi/chi/v5" + + "mtusi2026-messenger/internal/handler" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +func NewRouter( + log *slog.Logger, + instanceID string, + maxInflightRequests int, + maxUploadBytes int, + db handler.Pinger, + storage handler.Pinger, + authService *service.AuthService, + userService *service.UserService, + chatService *service.ChatService, + messageService *service.MessageService, + attachmentService *service.AttachmentService, +) http.Handler { + router := chi.NewRouter() + + healthHandler := handler.NewHealthHandler(log, db, storage) + authHandler := handler.NewAuthHandler(authService) + userHandler := handler.NewUserHandler(userService) + chatHandler := handler.NewChatHandler(chatService) + messageHandler := handler.NewMessageHandler(messageService) + attachmentHandler := handler.NewAttachmentHandler(attachmentService, maxUploadBytes) + + router.Use(middleware.InstanceID(instanceID)) + router.Use(middleware.RequestTimeout(5 * time.Second)) + router.Use(middleware.RequestID) + router.Use(middleware.Logging(log)) + router.Use(middleware.ConcurrencyLimit(maxInflightRequests)) + + router.Get("/health/live", healthHandler.Live) + router.Get("/health/ready", healthHandler.Ready) + + router.Post("/api/v1/users", userHandler.Create) + + router.Post("/api/v1/auth/sessions", authHandler.CreateSession) + router.Delete("/api/v1/auth/sessions/current", authHandler.RevokeSession) + + router.Group(func(r chi.Router) { + r.Use(middleware.Auth(authService)) + + r.Get("/api/v1/users/me", userHandler.Me) + + r.Post("/api/v1/chats", chatHandler.Create) + r.Get("/api/v1/chats", chatHandler.List) + r.Get("/api/v1/chats/{chat_id}", chatHandler.Get) + + r.Post("/api/v1/chats/{chat_id}/messages", messageHandler.Create) + r.Get("/api/v1/chats/{chat_id}/messages", messageHandler.List) + + r.Post("/api/v1/chats/{chat_id}/attachments", attachmentHandler.Upload) + r.Get("/api/v1/attachments/{attachment_id}", attachmentHandler.Get) + r.Get("/api/v1/attachments/{attachment_id}/content", attachmentHandler.GetContent) + }) + + router.Handle("/swagger/*", http.StripPrefix("/swagger/", http.FileServer(http.Dir("web/swagger")))) + router.Handle("/contracts/*", http.StripPrefix("/contracts/", http.FileServer(http.Dir("contracts")))) + + return router +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..9271fe13 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,230 @@ +package config + +import ( + "fmt" + "log" + "log/slog" + "os" + "strconv" + "strings" + "time" +) + +const ( + SessionStorePostgres = "postgres" + SessionStoreRedis = "redis" +) + +type Config struct { + Server ServerConfig + Logging LoggingConfig + Database DatabaseConfig + Redis RedisConfig + S3 S3Config + SessionStore string +} + +func (c Config) UseCache() bool { + return c.SessionStore == SessionStoreRedis +} + +type ServerConfig struct { + Host string + Port string + MaxInflightRequests int + SessionTTL time.Duration + IdempotencyTTL time.Duration + InstanceID string +} + +type LoggingConfig struct { + Level slog.Level +} + +type DatabaseConfig struct { + URLFile string +} + +func (c DatabaseConfig) URL() (string, error) { + return readSecretFile(c.URLFile) +} + +type RedisConfig struct { + URLFile string +} + +func (c RedisConfig) URL() (string, error) { + return readSecretFile(c.URLFile) +} + +type S3Config struct { + Endpoint string + Region string + Bucket string + APIAccessKeyFile string + APISecretKeyFile string + BootstrapAccessKeyFile string + BootstrapSecretKeyFile string + MaxUploadBytes int + MaxImagePixels int +} + +func (c S3Config) APIAccessKey() (string, error) { + return readSecretFile(c.APIAccessKeyFile) +} + +func (c S3Config) APISecretKey() (string, error) { + return readSecretFile(c.APISecretKeyFile) +} + +func (c S3Config) BootstrapAccessKey() (string, error) { + return readSecretFile(c.BootstrapAccessKeyFile) +} + +func (c S3Config) BootstrapSecretKey() (string, error) { + return readSecretFile(c.BootstrapSecretKeyFile) +} + +func Load() Config { + return Config{ + Server: ServerConfig{ + Host: getEnv("APP_HOST", "0.0.0.0"), + Port: getEnv("APP_PORT", "8080"), + MaxInflightRequests: getEnvNonNegativeInt("MAX_INFLIGHT_REQUESTS", 0), + SessionTTL: time.Duration(getEnvPositiveInt("SESSION_TTL_SECONDS", 3600)) * time.Second, + IdempotencyTTL: time.Duration(getEnvPositiveInt("IDEMPOTENCY_TTL_SECONDS", 86400)) * time.Second, + InstanceID: getInstanceID("INSTANCE_ID"), + }, + + Logging: LoggingConfig{ + Level: getEnvLogLevel("LOG_LEVEL", slog.LevelInfo), + }, + + Database: DatabaseConfig{ + URLFile: getEnv("DATABASE_URL_FILE", "/run/secrets/database_url"), + }, + + Redis: RedisConfig{ + URLFile: getEnv("CACHE_URL_FILE", "/run/secrets/cache_url"), + }, + + S3: LoadS3(), + + SessionStore: getEnvSessionStore("SESSION_STORE", SessionStorePostgres), + } +} + +func LoadS3() S3Config { + return S3Config{ + Endpoint: getEnv("S3_ENDPOINT", "http://s3:9000"), + Region: getEnv("S3_REGION", "us-east-1"), + Bucket: getEnv("S3_BUCKET", "messenger-attachments"), + APIAccessKeyFile: getEnv("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id"), + APISecretKeyFile: getEnv("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key"), + BootstrapAccessKeyFile: getEnv("S3_BOOTSTRAP_ACCESS_KEY_ID_FILE", "/run/secrets/s3_bootstrap_access_key_id"), + BootstrapSecretKeyFile: getEnv("S3_BOOTSTRAP_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_bootstrap_secret_access_key"), + MaxUploadBytes: getEnvPositiveInt("MAX_UPLOAD_BYTES", 10485760), + MaxImagePixels: getEnvPositiveInt("MAX_IMAGE_PIXELS", 40000000), + } +} + +func getEnv(key, def string) string { + value := os.Getenv(key) + if value == "" { + return def + } + + return value +} + +func getEnvNonNegativeInt(key string, def int) int { + v := os.Getenv(key) + if v == "" { + return def + } + + value, err := strconv.Atoi(v) + if err != nil || value < 0 { + log.Printf("invalid non-negative int for %s=%q, using default %d", key, v, def) + return def + } + + return value +} + +func getEnvPositiveInt(key string, def int) int { + v := os.Getenv(key) + if v == "" { + return def + } + + value, err := strconv.Atoi(v) + if err != nil || value <= 0 { + log.Printf("invalid positive int for %s=%q, using default %d", key, v, def) + return def + } + + return value +} + +func getEnvLogLevel(key string, def slog.Level) slog.Level { + v := os.Getenv(key) + + switch v { + case "DEBUG": + return slog.LevelDebug + case "INFO": + return slog.LevelInfo + case "WARN": + return slog.LevelWarn + case "ERROR": + return slog.LevelError + case "": + return def + default: + log.Printf("invalid log level for %s=%q, using default %s", key, v, def) + return def + } +} + +func readSecretFile(path string) (string, error) { + b, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("read secret file %s: %w", path, err) + } + + value := strings.TrimSpace(string(b)) + if value == "" { + return "", fmt.Errorf("secret file %s is empty", path) + } + + return value, nil +} + +func getEnvSessionStore(key, def string) string { + v := strings.ToLower(os.Getenv(key)) + + switch v { + case "": + return def + case SessionStorePostgres, SessionStoreRedis: + return v + default: + log.Printf("invalid session store for %s=%q, using default %s", key, v, def) + return def + } +} + +func getInstanceID(key string) string { + if v := os.Getenv(key); v != "" { + return v + } + + host, err := os.Hostname() + if err != nil || host == "" { + log.Printf("cannot determine hostname, using \"unknown\" for %s: %v", key, err) + return "unknown" + } + + return host +} diff --git a/internal/credentials/credentials.go b/internal/credentials/credentials.go new file mode 100644 index 00000000..7120a961 --- /dev/null +++ b/internal/credentials/credentials.go @@ -0,0 +1,51 @@ +package credentials + +import ( + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "errors" + + "golang.org/x/crypto/bcrypt" +) + +const tokenSize = 32 + +var ErrPasswordMismatch = errors.New("password mismatch") + +func prehash(plain string) []byte { + sum := sha256.Sum256([]byte(plain)) + return []byte(base64.StdEncoding.EncodeToString(sum[:])) +} + +func HashPassword(plain string) (string, error) { + hash, err := bcrypt.GenerateFromPassword(prehash(plain), bcrypt.DefaultCost) + if err != nil { + return "", err + } + + return string(hash), nil +} + +func VerifyPassword(hash, plain string) error { + err := bcrypt.CompareHashAndPassword([]byte(hash), prehash(plain)) + if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) { + return ErrPasswordMismatch + } + + return err +} + +func NewToken() string { + raw := make([]byte, tokenSize) + _, _ = rand.Read(raw) // never returns an error since Go 1.24 + + return base64.RawURLEncoding.EncodeToString(raw) +} + +func HashToken(token string) string { + sum := sha256.Sum256([]byte(token)) + + return hex.EncodeToString(sum[:]) +} diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go new file mode 100644 index 00000000..8103dd3a --- /dev/null +++ b/internal/db/attachments.sql.go @@ -0,0 +1,365 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: attachments.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createAttachment = `-- name: CreateAttachment :one +INSERT INTO attachments ( + id, + chat_id, + owner_id, + s3_key, + filename, + content_type, + size_bytes, + sha256, + error_code +) +SELECT + $1::uuid, + $2::uuid, + $3::uuid, + $4::text, + $5::text, + $6::attachment_content_type, + $7::int, + $8::text, + NULLIF($9::text, '') +WHERE EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = $2 + AND user_id = $3 +) +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at +` + +type CreateAttachmentParams struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + S3Key string + Filename string + ContentType AttachmentContentType + SizeBytes int + Sha256 string + ErrorCode string +} + +func (q *Queries) CreateAttachment(ctx context.Context, arg CreateAttachmentParams) (Attachment, error) { + row := q.db.QueryRow(ctx, createAttachment, + arg.ID, + arg.ChatID, + arg.OwnerID, + arg.S3Key, + arg.Filename, + arg.ContentType, + arg.SizeBytes, + arg.Sha256, + arg.ErrorCode, + ) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const createMessageAttachment = `-- name: CreateMessageAttachment :exec +INSERT INTO message_attachments ( + message_id, + attachment_id, + position +) VALUES ( + $1, + $2, + $3 +) +` + +type CreateMessageAttachmentParams struct { + MessageID uuid.UUID + AttachmentID uuid.UUID + Position int +} + +func (q *Queries) CreateMessageAttachment(ctx context.Context, arg CreateMessageAttachmentParams) error { + _, err := q.db.Exec(ctx, createMessageAttachment, arg.MessageID, arg.AttachmentID, arg.Position) + return err +} + +const deleteQueuedAttachment = `-- name: DeleteQueuedAttachment :execrows +DELETE FROM attachments +WHERE id = $1::uuid AND status = 'queued' +` + +func (q *Queries) DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) { + result, err := q.db.Exec(ctx, deleteQueuedAttachment, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const getAttachmentByID = `-- name: GetAttachmentByID :one +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at FROM attachments +WHERE id = $1::uuid +` + +func (q *Queries) GetAttachmentByID(ctx context.Context, dollar_1 uuid.UUID) (Attachment, error) { + row := q.db.QueryRow(ctx, getAttachmentByID, dollar_1) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const listAttachmentsByIDs = `-- name: ListAttachmentsByIDs :many +SELECT status +FROM attachments +WHERE chat_id = $1::uuid + AND id = ANY($2::uuid[]) +` + +type ListAttachmentsByIDsParams struct { + ChatID uuid.UUID + Ids []uuid.UUID +} + +func (q *Queries) ListAttachmentsByIDs(ctx context.Context, arg ListAttachmentsByIDsParams) ([]AttachmentStatus, error) { + rows, err := q.db.Query(ctx, listAttachmentsByIDs, arg.ChatID, arg.Ids) + if err != nil { + return nil, err + } + defer rows.Close() + items := []AttachmentStatus{} + for rows.Next() { + var status AttachmentStatus + if err := rows.Scan(&status); err != nil { + return nil, err + } + items = append(items, status) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listAttachmentsForReconcile = `-- name: ListAttachmentsForReconcile :many +SELECT + a.id, + a.s3_key, + a.status, + a.size_bytes, + a.created_at, + EXISTS ( + SELECT 1 FROM message_attachments ma + WHERE ma.attachment_id = a.id + ) AS referenced +FROM attachments a +` + +type ListAttachmentsForReconcileRow struct { + ID uuid.UUID + S3Key string + Status AttachmentStatus + SizeBytes int + CreatedAt time.Time + Referenced bool +} + +func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttachmentsForReconcileRow, error) { + rows, err := q.db.Query(ctx, listAttachmentsForReconcile) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListAttachmentsForReconcileRow{} + for rows.Next() { + var i ListAttachmentsForReconcileRow + if err := rows.Scan( + &i.ID, + &i.S3Key, + &i.Status, + &i.SizeBytes, + &i.CreatedAt, + &i.Referenced, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listMessageAttachmentIDs = `-- name: ListMessageAttachmentIDs :many +SELECT attachment_id +FROM message_attachments +WHERE message_id = $1::uuid +ORDER BY position +` + +func (q *Queries) ListMessageAttachmentIDs(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) { + rows, err := q.db.Query(ctx, listMessageAttachmentIDs, messageID) + if err != nil { + return nil, err + } + defer rows.Close() + items := []uuid.UUID{} + for rows.Next() { + var attachment_id uuid.UUID + if err := rows.Scan(&attachment_id); err != nil { + return nil, err + } + items = append(items, attachment_id) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listMessageAttachmentsByMessageIDs = `-- name: ListMessageAttachmentsByMessageIDs :many +SELECT message_id, attachment_id +FROM message_attachments +WHERE message_id = ANY($1::uuid[]) +ORDER BY message_id, position +` + +type ListMessageAttachmentsByMessageIDsRow struct { + MessageID uuid.UUID + AttachmentID uuid.UUID +} + +func (q *Queries) ListMessageAttachmentsByMessageIDs(ctx context.Context, messageIds []uuid.UUID) ([]ListMessageAttachmentsByMessageIDsRow, error) { + rows, err := q.db.Query(ctx, listMessageAttachmentsByMessageIDs, messageIds) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListMessageAttachmentsByMessageIDsRow{} + for rows.Next() { + var i ListMessageAttachmentsByMessageIDsRow + if err := rows.Scan(&i.MessageID, &i.AttachmentID); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listStaleAttachmentUploads = `-- name: ListStaleAttachmentUploads :many +SELECT id, s3_key FROM attachments +WHERE status = 'queued' AND created_at < $1::timestamptz +` + +type ListStaleAttachmentUploadsRow struct { + ID uuid.UUID + S3Key string +} + +func (q *Queries) ListStaleAttachmentUploads(ctx context.Context, cutoff time.Time) ([]ListStaleAttachmentUploadsRow, error) { + rows, err := q.db.Query(ctx, listStaleAttachmentUploads, cutoff) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListStaleAttachmentUploadsRow{} + for rows.Next() { + var i ListStaleAttachmentUploadsRow + if err := rows.Scan(&i.ID, &i.S3Key); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const markAttachmentFailedIfReady = `-- name: MarkAttachmentFailedIfReady :execrows +UPDATE attachments +SET status = 'failed', + error_code = $1::text, + updated_at = now() +WHERE id = $2::uuid AND status = 'ready' +` + +type MarkAttachmentFailedIfReadyParams struct { + ErrorCode string + ID uuid.UUID +} + +func (q *Queries) MarkAttachmentFailedIfReady(ctx context.Context, arg MarkAttachmentFailedIfReadyParams) (int64, error) { + result, err := q.db.Exec(ctx, markAttachmentFailedIfReady, arg.ErrorCode, arg.ID) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const markAttachmentReady = `-- name: MarkAttachmentReady :one +UPDATE attachments +SET status = 'ready', updated_at = now() +WHERE id = $1::uuid +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at +` + +func (q *Queries) MarkAttachmentReady(ctx context.Context, dollar_1 uuid.UUID) (Attachment, error) { + row := q.db.QueryRow(ctx, markAttachmentReady, dollar_1) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} diff --git a/internal/db/chats.sql.go b/internal/db/chats.sql.go new file mode 100644 index 00000000..c2794cc7 --- /dev/null +++ b/internal/db/chats.sql.go @@ -0,0 +1,232 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: chats.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const addChatMembers = `-- name: AddChatMembers :exec +INSERT INTO chat_members ( + chat_id, + user_id +) +SELECT + $1::uuid, + unnest($2::uuid[]) +` + +type AddChatMembersParams struct { + ChatID uuid.UUID + UserIds []uuid.UUID +} + +func (q *Queries) AddChatMembers(ctx context.Context, arg AddChatMembersParams) error { + _, err := q.db.Exec(ctx, addChatMembers, arg.ChatID, arg.UserIds) + return err +} + +const createChat = `-- name: CreateChat :one +INSERT INTO chats ( + id, + title +) VALUES ( + $1, + $2 +) +RETURNING id, title, created_at +` + +type CreateChatParams struct { + ID uuid.UUID + Title string +} + +func (q *Queries) CreateChat(ctx context.Context, arg CreateChatParams) (Chat, error) { + row := q.db.QueryRow(ctx, createChat, arg.ID, arg.Title) + var i Chat + err := row.Scan(&i.ID, &i.Title, &i.CreatedAt) + return i, err +} + +const getChat = `-- name: GetChat :one +SELECT + c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +FROM chats c +WHERE c.id = $1 + AND EXISTS ( + SELECT 1 FROM chat_members m + WHERE m.chat_id = c.id + AND m.user_id = $2 + ) +` + +type GetChatParams struct { + ID uuid.UUID + UserID uuid.UUID +} + +type GetChatRow struct { + ID uuid.UUID + Title string + CreatedAt time.Time + MemberIds []uuid.UUID +} + +func (q *Queries) GetChat(ctx context.Context, arg GetChatParams) (GetChatRow, error) { + row := q.db.QueryRow(ctx, getChat, arg.ID, arg.UserID) + var i GetChatRow + err := row.Scan( + &i.ID, + &i.Title, + &i.CreatedAt, + &i.MemberIds, + ) + return i, err +} + +const isChatMember = `-- name: IsChatMember :one +SELECT EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = $1 + AND user_id = $2 +) +` + +type IsChatMemberParams struct { + ChatID uuid.UUID + UserID uuid.UUID +} + +func (q *Queries) IsChatMember(ctx context.Context, arg IsChatMemberParams) (bool, error) { + row := q.db.QueryRow(ctx, isChatMember, arg.ChatID, arg.UserID) + var exists bool + err := row.Scan(&exists) + return exists, err +} + +const listChatsAfter = `-- name: ListChatsAfter :many +SELECT + c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +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::timestamptz, + $3::uuid + ) +ORDER BY c.created_at, c.id +LIMIT $4 +` + +type ListChatsAfterParams struct { + UserID uuid.UUID + AfterCreatedAt time.Time + AfterID uuid.UUID + Lim int +} + +type ListChatsAfterRow struct { + ID uuid.UUID + Title string + CreatedAt time.Time + MemberIds []uuid.UUID +} + +func (q *Queries) ListChatsAfter(ctx context.Context, arg ListChatsAfterParams) ([]ListChatsAfterRow, error) { + rows, err := q.db.Query(ctx, listChatsAfter, + arg.UserID, + arg.AfterCreatedAt, + arg.AfterID, + arg.Lim, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChatsAfterRow{} + for rows.Next() { + var i ListChatsAfterRow + if err := rows.Scan( + &i.ID, + &i.Title, + &i.CreatedAt, + &i.MemberIds, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listChatsFirstPage = `-- name: ListChatsFirstPage :many +SELECT + c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + )::uuid[] AS member_ids +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 +` + +type ListChatsFirstPageParams struct { + UserID uuid.UUID + Lim int +} + +type ListChatsFirstPageRow struct { + ID uuid.UUID + Title string + CreatedAt time.Time + MemberIds []uuid.UUID +} + +func (q *Queries) ListChatsFirstPage(ctx context.Context, arg ListChatsFirstPageParams) ([]ListChatsFirstPageRow, error) { + rows, err := q.db.Query(ctx, listChatsFirstPage, arg.UserID, arg.Lim) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListChatsFirstPageRow{} + for rows.Next() { + var i ListChatsFirstPageRow + if err := rows.Scan( + &i.ID, + &i.Title, + &i.CreatedAt, + &i.MemberIds, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/db/db.go b/internal/db/db.go new file mode 100644 index 00000000..468d1fa3 --- /dev/null +++ b/internal/db/db.go @@ -0,0 +1,32 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package db + +import ( + "context" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" +) + +type DBTX interface { + Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error) + Query(context.Context, string, ...interface{}) (pgx.Rows, error) + QueryRow(context.Context, string, ...interface{}) pgx.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx pgx.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/db/idempotency_keys.sql.go b/internal/db/idempotency_keys.sql.go new file mode 100644 index 00000000..5dc4235d --- /dev/null +++ b/internal/db/idempotency_keys.sql.go @@ -0,0 +1,120 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: idempotency_keys.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createIdempotencyKey = `-- name: CreateIdempotencyKey :execrows +INSERT INTO idempotency_keys ( + user_id, + method, + path, + key, + request_hash, + message_id +) VALUES ( + $1, + $2, + $3, + $4, + $5, + $6 +) +ON CONFLICT DO NOTHING +` + +type CreateIdempotencyKeyParams struct { + UserID uuid.UUID + Method string + Path string + Key string + RequestHash string + MessageID uuid.UUID +} + +func (q *Queries) CreateIdempotencyKey(ctx context.Context, arg CreateIdempotencyKeyParams) (int64, error) { + result, err := q.db.Exec(ctx, createIdempotencyKey, + arg.UserID, + arg.Method, + arg.Path, + arg.Key, + arg.RequestHash, + arg.MessageID, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const deleteExpiredIdempotencyKeys = `-- name: DeleteExpiredIdempotencyKeys :execrows +DELETE FROM idempotency_keys +WHERE created_at < $1 +` + +func (q *Queries) DeleteExpiredIdempotencyKeys(ctx context.Context, cutoff time.Time) (int64, error) { + result, err := q.db.Exec(ctx, deleteExpiredIdempotencyKeys, cutoff) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const getIdempotentMessage = `-- name: GetIdempotentMessage :one +SELECT + k.request_hash, + m.id, + m.chat_id, + m.sender_id, + m.text, + m.created_at +FROM idempotency_keys AS k +JOIN messages AS m ON m.id = k.message_id +WHERE k.user_id = $1 + AND k.method = $2 + AND k.path = $3 + AND k.key = $4 +` + +type GetIdempotentMessageParams struct { + UserID uuid.UUID + Method string + Path string + Key string +} + +type GetIdempotentMessageRow struct { + RequestHash string + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + CreatedAt time.Time +} + +func (q *Queries) GetIdempotentMessage(ctx context.Context, arg GetIdempotentMessageParams) (GetIdempotentMessageRow, error) { + row := q.db.QueryRow(ctx, getIdempotentMessage, + arg.UserID, + arg.Method, + arg.Path, + arg.Key, + ) + var i GetIdempotentMessageRow + err := row.Scan( + &i.RequestHash, + &i.ID, + &i.ChatID, + &i.SenderID, + &i.Text, + &i.CreatedAt, + ) + return i, err +} diff --git a/internal/db/messages.sql.go b/internal/db/messages.sql.go new file mode 100644 index 00000000..cb579fde --- /dev/null +++ b/internal/db/messages.sql.go @@ -0,0 +1,145 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: messages.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createMessage = `-- name: CreateMessage :one +INSERT INTO messages ( + id, + chat_id, + sender_id, + text +) +SELECT + $1::uuid, + $2::uuid, + $3::uuid, + $4::text +WHERE EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = $2 + AND user_id = $3 +) +RETURNING id, chat_id, sender_id, text, created_at +` + +type CreateMessageParams struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string +} + +func (q *Queries) CreateMessage(ctx context.Context, arg CreateMessageParams) (Message, error) { + row := q.db.QueryRow(ctx, createMessage, + arg.ID, + arg.ChatID, + arg.SenderID, + arg.Text, + ) + var i Message + err := row.Scan( + &i.ID, + &i.ChatID, + &i.SenderID, + &i.Text, + &i.CreatedAt, + ) + return i, err +} + +const listMessagesAfter = `-- name: ListMessagesAfter :many +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = $1 + AND (created_at, id) > ( + $2::timestamptz, + $3::uuid + ) +ORDER BY created_at, id +LIMIT $4 +` + +type ListMessagesAfterParams struct { + ChatID uuid.UUID + AfterCreatedAt time.Time + AfterID uuid.UUID + Lim int +} + +func (q *Queries) ListMessagesAfter(ctx context.Context, arg ListMessagesAfterParams) ([]Message, error) { + rows, err := q.db.Query(ctx, listMessagesAfter, + arg.ChatID, + arg.AfterCreatedAt, + arg.AfterID, + arg.Lim, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []Message{} + for rows.Next() { + var i Message + if err := rows.Scan( + &i.ID, + &i.ChatID, + &i.SenderID, + &i.Text, + &i.CreatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listMessagesFirstPage = `-- name: ListMessagesFirstPage :many +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = $1 +ORDER BY created_at, id +LIMIT $2 +` + +type ListMessagesFirstPageParams struct { + ChatID uuid.UUID + Lim int +} + +func (q *Queries) ListMessagesFirstPage(ctx context.Context, arg ListMessagesFirstPageParams) ([]Message, error) { + rows, err := q.db.Query(ctx, listMessagesFirstPage, arg.ChatID, arg.Lim) + if err != nil { + return nil, err + } + defer rows.Close() + items := []Message{} + for rows.Next() { + var i Message + if err := rows.Scan( + &i.ID, + &i.ChatID, + &i.SenderID, + &i.Text, + &i.CreatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/db/models.go b/internal/db/models.go new file mode 100644 index 00000000..5d69de15 --- /dev/null +++ b/internal/db/models.go @@ -0,0 +1,164 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package db + +import ( + "database/sql/driver" + "fmt" + "time" + + "github.com/google/uuid" +) + +type AttachmentContentType string + +const ( + AttachmentContentTypeImagePng AttachmentContentType = "image/png" + AttachmentContentTypeImageJpeg AttachmentContentType = "image/jpeg" +) + +func (e *AttachmentContentType) Scan(src interface{}) error { + switch s := src.(type) { + case []byte: + *e = AttachmentContentType(s) + case string: + *e = AttachmentContentType(s) + default: + return fmt.Errorf("unsupported scan type for AttachmentContentType: %T", src) + } + return nil +} + +type NullAttachmentContentType struct { + AttachmentContentType AttachmentContentType + Valid bool // Valid is true if AttachmentContentType is not NULL +} + +// Scan implements the Scanner interface. +func (ns *NullAttachmentContentType) Scan(value interface{}) error { + if value == nil { + ns.AttachmentContentType, ns.Valid = "", false + return nil + } + ns.Valid = true + return ns.AttachmentContentType.Scan(value) +} + +// Value implements the driver Valuer interface. +func (ns NullAttachmentContentType) Value() (driver.Value, error) { + if !ns.Valid { + return nil, nil + } + return string(ns.AttachmentContentType), nil +} + +type AttachmentStatus string + +const ( + AttachmentStatusQueued AttachmentStatus = "queued" + AttachmentStatusProcessing AttachmentStatus = "processing" + AttachmentStatusReady AttachmentStatus = "ready" + AttachmentStatusFailed AttachmentStatus = "failed" +) + +func (e *AttachmentStatus) Scan(src interface{}) error { + switch s := src.(type) { + case []byte: + *e = AttachmentStatus(s) + case string: + *e = AttachmentStatus(s) + default: + return fmt.Errorf("unsupported scan type for AttachmentStatus: %T", src) + } + return nil +} + +type NullAttachmentStatus struct { + AttachmentStatus AttachmentStatus + Valid bool // Valid is true if AttachmentStatus is not NULL +} + +// Scan implements the Scanner interface. +func (ns *NullAttachmentStatus) Scan(value interface{}) error { + if value == nil { + ns.AttachmentStatus, ns.Valid = "", false + return nil + } + ns.Valid = true + return ns.AttachmentStatus.Scan(value) +} + +// Value implements the driver Valuer interface. +func (ns NullAttachmentStatus) Value() (driver.Value, error) { + if !ns.Valid { + return nil, nil + } + return string(ns.AttachmentStatus), nil +} + +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + S3Key string + Filename string + ContentType AttachmentContentType + SizeBytes int + Sha256 string + Status AttachmentStatus + ErrorCode *string + CreatedAt time.Time + UpdatedAt time.Time +} + +type Chat struct { + ID uuid.UUID + Title string + CreatedAt time.Time +} + +type ChatMember struct { + ChatID uuid.UUID + UserID uuid.UUID +} + +type IdempotencyKey struct { + UserID uuid.UUID + Method string + Path string + Key string + RequestHash string + MessageID uuid.UUID + CreatedAt time.Time +} + +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + CreatedAt time.Time +} + +type MessageAttachment struct { + MessageID uuid.UUID + AttachmentID uuid.UUID + Position int +} + +type Session struct { + TokenHash string + UserID uuid.UUID + CreatedAt time.Time + ExpiresAt time.Time +} + +type User struct { + ID uuid.UUID + Username string + DisplayName string + PasswordHash string + CreatedAt time.Time +} diff --git a/internal/db/sessions.sql.go b/internal/db/sessions.sql.go new file mode 100644 index 00000000..fa6abddb --- /dev/null +++ b/internal/db/sessions.sql.go @@ -0,0 +1,81 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: sessions.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createSession = `-- name: CreateSession :exec +INSERT INTO sessions ( + token_hash, + user_id, + expires_at +) VALUES ( + $1, + $2, + $3 +) +` + +type CreateSessionParams struct { + TokenHash string + UserID uuid.UUID + ExpiresAt time.Time +} + +func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) error { + _, err := q.db.Exec(ctx, createSession, arg.TokenHash, arg.UserID, arg.ExpiresAt) + return err +} + +const deleteExpiredSessions = `-- name: DeleteExpiredSessions :execrows +DELETE FROM sessions +WHERE expires_at <= now() +` + +func (q *Queries) DeleteExpiredSessions(ctx context.Context) (int64, error) { + result, err := q.db.Exec(ctx, deleteExpiredSessions) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const deleteSession = `-- name: DeleteSession :execrows +DELETE FROM sessions +WHERE token_hash = $1 + AND expires_at > now() +` + +func (q *Queries) DeleteSession(ctx context.Context, tokenHash string) (int64, error) { + result, err := q.db.Exec(ctx, deleteSession, tokenHash) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const getActiveSession = `-- name: GetActiveSession :one +SELECT user_id, expires_at FROM sessions +WHERE token_hash = $1 + AND expires_at > now() +` + +type GetActiveSessionRow struct { + UserID uuid.UUID + ExpiresAt time.Time +} + +func (q *Queries) GetActiveSession(ctx context.Context, tokenHash string) (GetActiveSessionRow, error) { + row := q.db.QueryRow(ctx, getActiveSession, tokenHash) + var i GetActiveSessionRow + err := row.Scan(&i.UserID, &i.ExpiresAt) + return i, err +} diff --git a/internal/db/users.sql.go b/internal/db/users.sql.go new file mode 100644 index 00000000..ec8a97f9 --- /dev/null +++ b/internal/db/users.sql.go @@ -0,0 +1,101 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: users.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createUser = `-- name: CreateUser :one +INSERT INTO users ( + id, + username, + display_name, + password_hash +) VALUES ( + $1, + $2, + $3, + $4 +) +RETURNING id, username, display_name, created_at +` + +type CreateUserParams struct { + ID uuid.UUID + Username string + DisplayName string + PasswordHash string +} + +type CreateUserRow struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} + +func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) { + row := q.db.QueryRow(ctx, createUser, + arg.ID, + arg.Username, + arg.DisplayName, + arg.PasswordHash, + ) + var i CreateUserRow + err := row.Scan( + &i.ID, + &i.Username, + &i.DisplayName, + &i.CreatedAt, + ) + return i, err +} + +const getUser = `-- name: GetUser :one +SELECT id, username, display_name, created_at FROM users +WHERE id = $1 +` + +type GetUserRow struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} + +func (q *Queries) GetUser(ctx context.Context, id uuid.UUID) (GetUserRow, error) { + row := q.db.QueryRow(ctx, getUser, id) + var i GetUserRow + err := row.Scan( + &i.ID, + &i.Username, + &i.DisplayName, + &i.CreatedAt, + ) + return i, err +} + +const getUserByUsername = `-- name: GetUserByUsername :one +SELECT id, username, display_name, password_hash, created_at FROM users +WHERE username = $1 +` + +func (q *Queries) GetUserByUsername(ctx context.Context, username string) (User, error) { + row := q.db.QueryRow(ctx, getUserByUsername, username) + var i User + err := row.Scan( + &i.ID, + &i.Username, + &i.DisplayName, + &i.PasswordHash, + &i.CreatedAt, + ) + return i, err +} diff --git a/internal/dto/attachment.go b/internal/dto/attachment.go new file mode 100644 index 00000000..996835f8 --- /dev/null +++ b/internal/dto/attachment.go @@ -0,0 +1,79 @@ +package dto + +import ( + "time" + "unicode" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/model" +) + +type CreateAttachmentRequest struct { + Filename string +} + +type GetAttachmentContentRequest struct { + Variant string +} + +type VariantResponse struct { + Name string `json:"name"` + ContentType string `json:"content_type"` + SizeBytes int `json:"size_bytes"` + Width int `json:"width"` + Height int `json:"height"` + Sha256 string `json:"sha256"` +} + +type AttachmentResponse struct { + ID uuid.UUID `json:"id"` + ChatID uuid.UUID `json:"chat_id"` + OwnerID uuid.UUID `json:"owner_id"` + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int `json:"size_bytes"` + Sha256 string `json:"sha256"` + Status string `json:"status"` + Variants []VariantResponse `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` +} + +func (r CreateAttachmentRequest) Validate() bool { + if n := utf8.RuneCountInString(r.Filename); n < 1 || n > 255 { + return false + } + + for _, ch := range r.Filename { + if ch == '/' || ch == '\\' || ch == 0 || unicode.IsControl(ch) { + return false + } + } + + return true +} + +func (r GetAttachmentContentRequest) Validate() bool { + return r.Variant == "" || r.Variant == "original" +} + +func ToAttachmentResponse(a model.Attachment) AttachmentResponse { + variants := make([]VariantResponse, 0) + return AttachmentResponse{ + ID: a.ID, + ChatID: a.ChatID, + OwnerID: a.OwnerID, + Filename: a.Filename, + ContentType: string(a.ContentType), + SizeBytes: a.SizeBytes, + Sha256: a.Sha256, + Status: string(a.Status), + Variants: variants, + ErrorCode: a.ErrorCode, + CreatedAt: a.CreatedAt, + UpdatedAt: a.UpdatedAt, + } +} diff --git a/internal/dto/chat.go b/internal/dto/chat.go new file mode 100644 index 00000000..f8c2cca0 --- /dev/null +++ b/internal/dto/chat.go @@ -0,0 +1,50 @@ +package dto + +import ( + "mtusi2026-messenger/internal/model" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +type CreateChatRequest struct { + Title string `json:"title"` + MemberIDs []uuid.UUID `json:"member_ids"` +} + +type ChatResponse struct { + ID uuid.UUID `json:"id"` + Title string `json:"title"` + MemberIDs []uuid.UUID `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type ChatPageResponse struct { + Items []ChatResponse `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +func (r CreateChatRequest) Validate() bool { + if strings.TrimSpace(r.Title) == "" || + strings.ContainsRune(r.Title, 0) || + utf8.RuneCountInString(r.Title) > 100 { + return false + } + + if len(r.MemberIDs) < 1 || len(r.MemberIDs) > 100 { + return false + } + + return true +} + +func ToChatResponse(c model.Chat) ChatResponse { + return ChatResponse{ + ID: c.ID, + Title: c.Title, + MemberIDs: c.MemberIDs, + CreatedAt: c.CreatedAt, + } +} diff --git a/internal/dto/error.go b/internal/dto/error.go new file mode 100644 index 00000000..3a46305e --- /dev/null +++ b/internal/dto/error.go @@ -0,0 +1,25 @@ +package dto + +type ErrorCode string + +const ( + ErrorCodeInvalidRequest ErrorCode = "invalid_request" + ErrorCodeUnauthorized ErrorCode = "unauthorized" + ErrorCodeNotFound ErrorCode = "not_found" + ErrorCodeConflict ErrorCode = "conflict" + ErrorCodePayloadTooLarge ErrorCode = "payload_too_large" + ErrorCodeUnsupportedMediaType ErrorCode = "unsupported_media_type" + ErrorCodeRateLimited ErrorCode = "rate_limited" + ErrorCodeUnavailable ErrorCode = "unavailable" + ErrorCodeInternalError ErrorCode = "internal_error" +) + +type ErrorResponse struct { + Error Error `json:"error"` +} + +type Error struct { + Code ErrorCode `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} diff --git a/internal/dto/health.go b/internal/dto/health.go new file mode 100644 index 00000000..8bb35034 --- /dev/null +++ b/internal/dto/health.go @@ -0,0 +1,5 @@ +package dto + +type HealthResponse struct { + Status string `json:"status"` +} diff --git a/internal/dto/message.go b/internal/dto/message.go new file mode 100644 index 00000000..00902c7e --- /dev/null +++ b/internal/dto/message.go @@ -0,0 +1,64 @@ +package dto + +import ( + "mtusi2026-messenger/internal/model" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +type CreateMessageRequest struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` +} + +type MessageResponse struct { + ID uuid.UUID `json:"id"` + ChatID uuid.UUID `json:"chat_id"` + SenderID uuid.UUID `json:"sender_id"` + Text string `json:"text"` + AttachmentIDs []uuid.UUID `json:"attachment_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type MessagePageResponse struct { + Items []MessageResponse `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +func (r CreateMessageRequest) Validate() bool { + if strings.ContainsRune(r.Text, 0) || utf8.RuneCountInString(r.Text) > 4000 { + return false + } + if len(r.AttachmentIDs) > 10 { + return false + } + + seen := make(map[string]struct{}, len(r.AttachmentIDs)) + for _, id := range r.AttachmentIDs { + if _, ok := seen[id]; ok { + return false + } + seen[id] = struct{}{} + } + + hasText := strings.TrimSpace(r.Text) != "" + hasAttachment := len(r.AttachmentIDs) > 0 + + return hasText || hasAttachment +} + +func ToMessageResponse(m model.Message) MessageResponse { + ids := make([]uuid.UUID, len(m.AttachmentIDs)) + copy(ids, m.AttachmentIDs) + return MessageResponse{ + ID: m.ID, + ChatID: m.ChatID, + SenderID: m.SenderID, + Text: m.Text, + AttachmentIDs: ids, + CreatedAt: m.CreatedAt, + } +} diff --git a/internal/dto/session.go b/internal/dto/session.go new file mode 100644 index 00000000..f8d1ccf2 --- /dev/null +++ b/internal/dto/session.go @@ -0,0 +1,10 @@ +package dto + +import "time" + +type SessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt time.Time `json:"expires_at"` + User UserResponse `json:"user"` +} diff --git a/internal/dto/user.go b/internal/dto/user.go new file mode 100644 index 00000000..27973e1d --- /dev/null +++ b/internal/dto/user.go @@ -0,0 +1,44 @@ +package dto + +import ( + "regexp" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +type CreateUserRequest struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` +} + +type UserResponse struct { + ID uuid.UUID `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +func (r CreateUserRequest) Validate() bool { + if !usernamePattern.MatchString(r.Username) { + return false + } + + displayNameLength := utf8.RuneCountInString(r.DisplayName) + if strings.TrimSpace(r.DisplayName) == "" || + displayNameLength > 100 || + strings.ContainsRune(r.DisplayName, 0) { + return false + } + + if n := utf8.RuneCountInString(r.Password); n < 12 || n > 128 { + return false + } + + return true +} diff --git a/internal/handler/attachment.go b/internal/handler/attachment.go new file mode 100644 index 00000000..5470d7bc --- /dev/null +++ b/internal/handler/attachment.go @@ -0,0 +1,140 @@ +package handler + +import ( + "errors" + "net/http" + "time" + + "github.com/go-chi/chi/v5" + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type AttachmentHandler struct { + service *service.AttachmentService + maxBytes int +} + +func NewAttachmentHandler(service *service.AttachmentService, maxBytes int) *AttachmentHandler { + return &AttachmentHandler{ + service: service, + maxBytes: maxBytes, + } +} + +func (h *AttachmentHandler) Upload(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid chat_id", requestID) + return + } + + req := dto.CreateAttachmentRequest{ + Filename: r.URL.Query().Get("filename"), + } + if !req.Validate() { + httpx.WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid filename", requestID) + return + } + + if deadline, ok := r.Context().Deadline(); ok { + controller := http.NewResponseController(w) + if err := controller.SetReadDeadline(deadline); err != nil { + httpx.WriteInternalError(w, requestID, err) + return + } + defer func() { _ = controller.SetReadDeadline(time.Time{}) }() + } + + contentType := r.Header.Get("Content-Type") + r.Body = http.MaxBytesReader(w, r.Body, int64(h.maxBytes)) + + att, err := h.service.Upload(r.Context(), userID, chatID, req.Filename, r.Body, contentType) + switch { + case errors.Is(err, service.ErrUploadReadTimeout): + r.Close = true + w.Header().Set("Connection", "close") + httpx.WriteError(w, http.StatusRequestTimeout, dto.ErrorCodeInvalidRequest, "upload body read timed out", requestID) + return + case errors.Is(err, service.ErrInvalidSize): + httpx.WriteError(w, http.StatusRequestEntityTooLarge, dto.ErrorCodePayloadTooLarge, "file too large", requestID) + return + case errors.Is(err, service.ErrInvalidImage): + httpx.WriteError(w, http.StatusUnsupportedMediaType, dto.ErrorCodeUnsupportedMediaType, "invalid image", requestID) + return + case errors.Is(err, service.ErrAttachmentNotFound): + httpx.WriteError(w, http.StatusNotFound, dto.ErrorCodeNotFound, "not found", requestID) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.ToAttachmentResponse(att)) +} + +func (h *AttachmentHandler) Get(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + attachmentID, err := uuid.Parse(chi.URLParam(r, "attachment_id")) + if err != nil { + httpx.WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid attachment_id", requestID) + return + } + + att, err := h.service.Get(r.Context(), userID, attachmentID) + switch { + case errors.Is(err, service.ErrAttachmentNotFound): + httpx.WriteError(w, http.StatusNotFound, dto.ErrorCodeNotFound, "not found", requestID) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusOK, dto.ToAttachmentResponse(att)) +} + +func (h *AttachmentHandler) GetContent(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + attachmentID, err := uuid.Parse(chi.URLParam(r, "attachment_id")) + if err != nil { + httpx.WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid attachment_id", requestID) + return + } + + req := dto.GetAttachmentContentRequest{ + Variant: r.URL.Query().Get("variant"), + } + if !req.Validate() { + httpx.WriteError(w, http.StatusNotFound, dto.ErrorCodeNotFound, "not found", requestID) + return + } + + data, contentType, err := h.service.GetContent(r.Context(), userID, attachmentID) + switch { + case errors.Is(err, service.ErrAttachmentNotReady): + httpx.WriteError(w, http.StatusConflict, dto.ErrorCodeConflict, "attachment not ready", requestID) + return + case errors.Is(err, service.ErrAttachmentNotFound): + httpx.WriteError(w, http.StatusNotFound, dto.ErrorCodeNotFound, "not found", requestID) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + w.Header().Set("Content-Type", string(contentType)) + w.WriteHeader(http.StatusOK) + _, _ = w.Write(data) +} diff --git a/internal/handler/auth.go b/internal/handler/auth.go new file mode 100644 index 00000000..13424130 --- /dev/null +++ b/internal/handler/auth.go @@ -0,0 +1,80 @@ +package handler + +import ( + "errors" + "net/http" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type AuthHandler struct { + service *service.AuthService +} + +func NewAuthHandler(s *service.AuthService) *AuthHandler { + return &AuthHandler{service: s} +} + +func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + + username, plain, ok := r.BasicAuth() + if !ok { + httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID) + return + } + + if !httpx.RejectBody(w, r, requestID) { + return + } + + session, err := h.service.Login(r.Context(), username, plain) + if errors.Is(err, service.ErrInvalidCredentials) { + httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID) + return + } + if err != nil { + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.SessionResponse{ + Token: session.Token, + TokenType: "Bearer", + ExpiresAt: session.ExpiresAt, + User: dto.UserResponse{ + ID: session.User.ID, + Username: session.User.Username, + DisplayName: session.User.DisplayName, + CreatedAt: session.User.CreatedAt, + }, + }) +} + +func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + + token, ok := httpx.BearerToken(r) + if !ok { + httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID) + return + } + + err := h.service.Logout(r.Context(), token) + switch { + case errors.Is(err, service.ErrSessionCacheUnavailable): + httpx.WriteError(w, http.StatusServiceUnavailable, dto.ErrorCodeUnavailable, "session cache unavailable", requestID) + return + case errors.Is(err, service.ErrUnauthorized): + httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + w.WriteHeader(http.StatusNoContent) +} diff --git a/internal/handler/chat.go b/internal/handler/chat.go new file mode 100644 index 00000000..e5f9c1e6 --- /dev/null +++ b/internal/handler/chat.go @@ -0,0 +1,150 @@ +package handler + +import ( + "errors" + "net/http" + + "github.com/go-chi/chi/v5" + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type ChatHandler struct { + service *service.ChatService +} + +func NewChatHandler(service *service.ChatService) *ChatHandler { + return &ChatHandler{service: service} +} + +func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + var req dto.CreateChatRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + chat, err := h.service.Create(r.Context(), userID, req.Title, req.MemberIDs) + switch { + case errors.Is(err, service.ErrNotChatMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "caller must be a member of member_ids", + requestID, + ) + return + case errors.Is(err, service.ErrDuplicateMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "member_ids contains duplicates", + requestID, + ) + return + case errors.Is(err, service.ErrUnknownMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "member_ids contains unknown user", + requestID, + ) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.ToChatResponse(chat)) +} + +func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + chat, err := h.service.Get(r.Context(), userID, chatID) + switch { + case errors.Is(err, service.ErrChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusOK, dto.ToChatResponse(chat)) +} + +func (h *ChatHandler) List(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + limit, cursor, ok := httpx.ParsePagination(w, r, requestID) + if !ok { + return + } + + chats, nextCursor, err := h.service.List(r.Context(), userID, limit, cursor) + switch { + case errors.Is(err, service.ErrInvalidCursor): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid cursor", + requestID, + ) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + items := make([]dto.ChatResponse, 0, len(chats)) + for _, c := range chats { + items = append(items, dto.ToChatResponse(c)) + } + + httpx.WriteJSON(w, http.StatusOK, dto.ChatPageResponse{ + Items: items, + NextCursor: nextCursor, + }) +} diff --git a/internal/handler/health.go b/internal/handler/health.go new file mode 100644 index 00000000..9ffc69a1 --- /dev/null +++ b/internal/handler/health.go @@ -0,0 +1,62 @@ +package handler + +import ( + "context" + "encoding/json" + "log/slog" + "net/http" + "time" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" +) + +const readyPingTimeout = 2 * time.Second + +type Pinger interface { + Ping(ctx context.Context) error +} + +type HealthHandler struct { + log *slog.Logger + dependencies []Pinger +} + +func NewHealthHandler(log *slog.Logger, dependencies ...Pinger) *HealthHandler { + return &HealthHandler{log: log, dependencies: dependencies} +} + +func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + + _ = json.NewEncoder(w).Encode(dto.HealthResponse{ + Status: "ok", + }) +} + +func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) { + ctx, cancel := context.WithTimeout(r.Context(), readyPingTimeout) + defer cancel() + + for _, dependency := range h.dependencies { + if err := dependency.Ping(ctx); err != nil { + h.log.ErrorContext(r.Context(), "readiness check failed", "error", err) + httpx.WriteError( + w, + http.StatusServiceUnavailable, + dto.ErrorCodeUnavailable, + "service unavailable", + w.Header().Get("X-Request-Id"), + ) + return + } + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + + _ = json.NewEncoder(w).Encode(dto.HealthResponse{ + Status: "ok", + }) +} diff --git a/internal/handler/message.go b/internal/handler/message.go new file mode 100644 index 00000000..bd926ba0 --- /dev/null +++ b/internal/handler/message.go @@ -0,0 +1,188 @@ +package handler + +import ( + "errors" + "net/http" + "regexp" + + "github.com/go-chi/chi/v5" + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +var idempotencyKeyReq = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +type MessageHandler struct { + service *service.MessageService +} + +func NewMessageHandler(service *service.MessageService) *MessageHandler { + return &MessageHandler{service: service} +} + +func (h *MessageHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + key := r.Header.Get("Idempotency-Key") + if !idempotencyKeyReq.MatchString(key) { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid Idempotency-Key", + requestID, + ) + return + } + + var req dto.CreateMessageRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + attachmentIDs := make([]uuid.UUID, 0, len(req.AttachmentIDs)) + for _, s := range req.AttachmentIDs { + id, err := uuid.Parse(s) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid attachment_id", + requestID, + ) + return + } + attachmentIDs = append(attachmentIDs, id) + } + + message, err := h.service.Create(r.Context(), userID, chatID, key, req.Text, attachmentIDs) + switch { + case errors.Is(err, service.ErrMessageChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case errors.Is(err, service.ErrAttachmentNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "attachment not found", + requestID, + ) + return + case errors.Is(err, service.ErrAttachmentNotReady): + httpx.WriteError( + w, + http.StatusConflict, + dto.ErrorCodeConflict, + "attachment not ready", + requestID, + ) + return + case errors.Is(err, service.ErrIdempotencyKeyConflict): + httpx.WriteError( + w, + http.StatusConflict, + dto.ErrorCodeConflict, + "idempotency key reused with different request", + requestID, + ) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.ToMessageResponse(message)) +} + +func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + limit, cursor, ok := httpx.ParsePagination(w, r, requestID) + if !ok { + return + } + + messages, nextCursor, err := h.service.List(r.Context(), userID, chatID, limit, cursor) + switch { + case errors.Is(err, service.ErrMessageChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case errors.Is(err, service.ErrInvalidCursor): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid cursor", + requestID, + ) + return + case err != nil: + httpx.WriteInternalError(w, requestID, err) + return + } + + items := make([]dto.MessageResponse, 0, len(messages)) + for _, m := range messages { + items = append(items, dto.ToMessageResponse(m)) + } + + httpx.WriteJSON(w, http.StatusOK, dto.MessagePageResponse{ + Items: items, + NextCursor: nextCursor, + }) +} diff --git a/internal/handler/user.go b/internal/handler/user.go new file mode 100644 index 00000000..66cc985a --- /dev/null +++ b/internal/handler/user.go @@ -0,0 +1,95 @@ +package handler + +import ( + "errors" + "net/http" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type UserHandler struct { + service *service.UserService +} + +func NewUserHandler(service *service.UserService) *UserHandler { + return &UserHandler{service: service} +} + +func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + + var req dto.CreateUserRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + user, err := h.service.Create( + r.Context(), + req.Username, + req.DisplayName, + req.Password, + ) + if errors.Is(err, service.ErrUsernameTaken) { + httpx.WriteError( + w, + http.StatusConflict, + dto.ErrorCodeConflict, + "username already taken", + requestID, + ) + return + } + if err != nil { + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.UserResponse{ + ID: user.ID, + Username: user.Username, + DisplayName: user.DisplayName, + CreatedAt: user.CreatedAt, + }) +} + +func (h *UserHandler) Me(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + user, err := h.service.GetByID(r.Context(), userID) + if errors.Is(err, service.ErrUserNotFound) { + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "user not found", + requestID, + ) + return + } + if err != nil { + httpx.WriteInternalError(w, requestID, err) + return + } + + httpx.WriteJSON(w, http.StatusOK, dto.UserResponse{ + ID: user.ID, + Username: user.Username, + DisplayName: user.DisplayName, + CreatedAt: user.CreatedAt, + }) +} diff --git a/internal/httpx/auth.go b/internal/httpx/auth.go new file mode 100644 index 00000000..b2fb421c --- /dev/null +++ b/internal/httpx/auth.go @@ -0,0 +1,37 @@ +package httpx + +import ( + "net/http" + "strings" + + "mtusi2026-messenger/internal/dto" +) + +const ( + BasicChallenge = `Basic realm="messenger", charset="UTF-8"` + BearerChallenge = `Bearer realm="messenger"` +) + +func BearerToken(r *http.Request) (string, bool) { + const prefix = "Bearer " + + header := r.Header.Get("Authorization") + if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) { + return "", false + } + + token := strings.TrimSpace(header[len(prefix):]) + + return token, token != "" +} + +func WriteUnauthorized(w http.ResponseWriter, challenge, requestID string) { + w.Header().Set("WWW-Authenticate", challenge) + WriteError( + w, + http.StatusUnauthorized, + dto.ErrorCodeUnauthorized, + "unauthorized", + requestID, + ) +} diff --git a/internal/httpx/pagination.go b/internal/httpx/pagination.go new file mode 100644 index 00000000..2e7e0222 --- /dev/null +++ b/internal/httpx/pagination.go @@ -0,0 +1,34 @@ +package httpx + +import ( + "net/http" + "strconv" + + "mtusi2026-messenger/internal/dto" +) + +func ParsePagination(w http.ResponseWriter, r *http.Request, requestID string) (limit int, cursor *string, ok bool) { + q := r.URL.Query() + + limit = 50 + if raw := q.Get("limit"); raw != "" { + v, err := strconv.Atoi(raw) + if err != nil || v < 1 || v > 100 { + WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "limit must be an integer between 1 and 100", + requestID, + ) + return 0, nil, false + } + limit = v + } + + if raw := q.Get("cursor"); raw != "" { + cursor = &raw + } + + return limit, cursor, true +} diff --git a/internal/httpx/request.go b/internal/httpx/request.go new file mode 100644 index 00000000..4a84ebae --- /dev/null +++ b/internal/httpx/request.go @@ -0,0 +1,49 @@ +package httpx + +import ( + "encoding/json" + "errors" + "io" + "mime" + "net/http" + + "mtusi2026-messenger/internal/dto" +) + +func DecodeJSONBody(w http.ResponseWriter, r *http.Request, requestID string, dst any) bool { + if ct := r.Header.Get("Content-Type"); ct != "" { + mt, _, err := mime.ParseMediaType(ct) + if err != nil || mt != "application/json" { + WriteError(w, http.StatusUnsupportedMediaType, dto.ErrorCodeUnsupportedMediaType, "expected application/json", requestID) + return false + } + } + + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + + if err := decoder.Decode(dst); err != nil { + WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID) + return false + } + + if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) { + WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID) + return false + } + + return true +} + +func RejectBody(w http.ResponseWriter, r *http.Request, requestID string) bool { + if r.Body == nil || r.Body == http.NoBody { + return true + } + + var b [1]byte + if n, _ := r.Body.Read(b[:]); n > 0 { + WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID) + return false + } + return true +} diff --git a/internal/httpx/response.go b/internal/httpx/response.go new file mode 100644 index 00000000..23f2771a --- /dev/null +++ b/internal/httpx/response.go @@ -0,0 +1,68 @@ +package httpx + +import ( + "context" + "encoding/json" + "errors" + "net" + "net/http" + "strings" + + "github.com/jackc/pgx/v5/pgconn" + + "mtusi2026-messenger/internal/dto" + s3store "mtusi2026-messenger/internal/s3" +) + +func WriteJSON(w http.ResponseWriter, status int, body any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(body) +} + +func WriteError(w http.ResponseWriter, status int, code dto.ErrorCode, message, requestID string) { + WriteJSON(w, status, dto.ErrorResponse{ + Error: dto.Error{ + Code: code, + Message: message, + RequestID: requestID, + }, + }) +} + +func WriteInternalError(w http.ResponseWriter, requestID string, err error) { + if isUnavailable(err) { + WriteError( + w, + http.StatusServiceUnavailable, + dto.ErrorCodeUnavailable, + "dependency unavailable", + requestID, + ) + return + } + + WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) +} + +func isUnavailable(err error) bool { + if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, s3store.ErrUnavailable) { + return true + } + + if _, ok := errors.AsType[net.Error](err); ok { + return true + } + + if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok { + return strings.HasPrefix(pgErr.Code, "08") || pgErr.Code == "57P01" + } + + return false +} diff --git a/internal/logger/logger.go b/internal/logger/logger.go new file mode 100644 index 00000000..89ce6002 --- /dev/null +++ b/internal/logger/logger.go @@ -0,0 +1,14 @@ +package logger + +import ( + "log/slog" + "os" +) + +func New(level slog.Level) *slog.Logger { + return slog.New( + slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ + Level: level, + }), + ) +} diff --git a/internal/middleware/auth.go b/internal/middleware/auth.go new file mode 100644 index 00000000..5ade80c3 --- /dev/null +++ b/internal/middleware/auth.go @@ -0,0 +1,50 @@ +package middleware + +import ( + "context" + "errors" + "net/http" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/service" +) + +type userIDContextKey struct{} + +type authenticator interface { + Authenticate(ctx context.Context, token string) (uuid.UUID, error) +} + +func Auth(auth authenticator) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requestID := GetRequestID(r.Context()) + + token, ok := httpx.BearerToken(r) + if !ok { + httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID) + return + } + + userID, err := auth.Authenticate(r.Context(), token) + if errors.Is(err, service.ErrUnauthorized) { + httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID) + return + } + if err != nil { + httpx.WriteInternalError(w, requestID, err) + return + } + + ctx := context.WithValue(r.Context(), userIDContextKey{}, userID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +func GetUserID(ctx context.Context) uuid.UUID { + id, _ := ctx.Value(userIDContextKey{}).(uuid.UUID) + return id +} diff --git a/internal/middleware/concurrency.go b/internal/middleware/concurrency.go new file mode 100644 index 00000000..631f4bce --- /dev/null +++ b/internal/middleware/concurrency.go @@ -0,0 +1,41 @@ +package middleware + +import ( + "net/http" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" +) + +func ConcurrencyLimit(max int) func(http.Handler) http.Handler { + if max <= 0 { + return func(next http.Handler) http.Handler { + return next + } + } + + slots := make(chan struct{}, max) + + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + select { + case slots <- struct{}{}: + defer func() { + <-slots + }() + + next.ServeHTTP(w, r) + + default: + w.Header().Set("Retry-After", "1") + httpx.WriteError( + w, + http.StatusTooManyRequests, + dto.ErrorCodeRateLimited, + "too many requests", + GetRequestID(r.Context()), + ) + } + }) + } +} diff --git a/internal/middleware/instance_id.go b/internal/middleware/instance_id.go new file mode 100644 index 00000000..5fa86d18 --- /dev/null +++ b/internal/middleware/instance_id.go @@ -0,0 +1,14 @@ +package middleware + +import ( + "net/http" +) + +func InstanceID(id string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Instance-Id", id) + next.ServeHTTP(w, r) + }) + } +} diff --git a/internal/middleware/logging.go b/internal/middleware/logging.go new file mode 100644 index 00000000..7d7da2cb --- /dev/null +++ b/internal/middleware/logging.go @@ -0,0 +1,53 @@ +package middleware + +import ( + "log/slog" + "net/http" + "time" +) + +type responseWriter struct { + http.ResponseWriter + status int +} + +func (w *responseWriter) Unwrap() http.ResponseWriter { + return w.ResponseWriter +} + +func (w *responseWriter) WriteHeader(status int) { + w.status = status + w.ResponseWriter.WriteHeader(status) +} + +func Logging(log *slog.Logger) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + + writer := &responseWriter{ + ResponseWriter: w, + status: http.StatusOK, + } + + next.ServeHTTP(writer, r) + + level := slog.LevelInfo + + switch { + case writer.status >= 500: + level = slog.LevelError + case writer.status >= 400: + level = slog.LevelWarn + } + + log.Log(r.Context(), level, "http request", + "request_id", GetRequestID(r.Context()), + "method", r.Method, + "path", r.URL.Path, + "status", writer.status, + "duration_ms", time.Since(start).Milliseconds(), + ) + }) + } +} diff --git a/internal/middleware/request_id.go b/internal/middleware/request_id.go new file mode 100644 index 00000000..d62808b0 --- /dev/null +++ b/internal/middleware/request_id.go @@ -0,0 +1,30 @@ +package middleware + +import ( + "context" + "net/http" + + "github.com/google/uuid" +) + +type requestIDContextKey struct{} + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requestID := r.Header.Get("X-Request-Id") + + if requestID == "" { + requestID = uuid.NewString() + } + + w.Header().Set("X-Request-Id", requestID) + + ctx := context.WithValue(r.Context(), requestIDContextKey{}, requestID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func GetRequestID(ctx context.Context) string { + id, _ := ctx.Value(requestIDContextKey{}).(string) + return id +} diff --git a/internal/middleware/timeout.go b/internal/middleware/timeout.go new file mode 100644 index 00000000..9486fa30 --- /dev/null +++ b/internal/middleware/timeout.go @@ -0,0 +1,17 @@ +package middleware + +import ( + "context" + "net/http" + "time" +) + +func RequestTimeout(d time.Duration) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + ctx, cancel := context.WithTimeout(r.Context(), d) + defer cancel() + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} diff --git a/internal/model/attachment.go b/internal/model/attachment.go new file mode 100644 index 00000000..c3c76ea4 --- /dev/null +++ b/internal/model/attachment.go @@ -0,0 +1,34 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type ContentType string + +const ( + ContentTypePNG ContentType = "image/png" + ContentTypeJPEG ContentType = "image/jpeg" +) + +type AttachmentStatus string + +const ( + AttachmentStatusReady AttachmentStatus = "ready" +) + +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + ContentType ContentType + SizeBytes int + Sha256 string + Status AttachmentStatus + ErrorCode *string + CreatedAt time.Time + UpdatedAt time.Time +} diff --git a/internal/model/chat.go b/internal/model/chat.go new file mode 100644 index 00000000..2c47c490 --- /dev/null +++ b/internal/model/chat.go @@ -0,0 +1,14 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type Chat struct { + ID uuid.UUID + Title string + MemberIDs []uuid.UUID + CreatedAt time.Time +} diff --git a/internal/model/message.go b/internal/model/message.go new file mode 100644 index 00000000..8db0c61c --- /dev/null +++ b/internal/model/message.go @@ -0,0 +1,16 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + AttachmentIDs []uuid.UUID + CreatedAt time.Time +} diff --git a/internal/model/session.go b/internal/model/session.go new file mode 100644 index 00000000..4129b793 --- /dev/null +++ b/internal/model/session.go @@ -0,0 +1,9 @@ +package model + +import "time" + +type Session struct { + Token string + ExpiresAt time.Time + User User +} diff --git a/internal/model/user.go b/internal/model/user.go new file mode 100644 index 00000000..dc7eff16 --- /dev/null +++ b/internal/model/user.go @@ -0,0 +1,14 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type User struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} diff --git a/internal/postgres/errors.go b/internal/postgres/errors.go new file mode 100644 index 00000000..961f069e --- /dev/null +++ b/internal/postgres/errors.go @@ -0,0 +1,25 @@ +package postgres + +import ( + "errors" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" +) + +const ( + CodeUniqueViolation = "23505" + CodeForeignKeyViolation = "23503" + CodeCheckViolation = "23514" +) + +func ErrCode(err error) string { + if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok { + return pgErr.Code + } + return "" +} + +func IsNotFound(err error) bool { + return errors.Is(err, pgx.ErrNoRows) +} diff --git a/internal/postgres/pool.go b/internal/postgres/pool.go new file mode 100644 index 00000000..4a1361aa --- /dev/null +++ b/internal/postgres/pool.go @@ -0,0 +1,34 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +func New(ctx context.Context, url string) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(url) + if err != nil { + return nil, fmt.Errorf("parse database url: %w", err) + } + + cfg.MaxConns = 10 + cfg.ConnConfig.ConnectTimeout = 5 * time.Second + cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000" + + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, fmt.Errorf("create pool: %w", err) + } + + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping database: %w", err) + } + + return pool, nil +} diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go new file mode 100644 index 00000000..11bb3279 --- /dev/null +++ b/internal/reconcile/reconcile.go @@ -0,0 +1,295 @@ +package reconcile + +import ( + "context" + "fmt" + "log/slog" + "sort" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/db" + s3store "mtusi2026-messenger/internal/s3" +) + +const ( + Prefix = "chats/" + DefaultGrace = time.Hour + DefaultMaxDeletes = 100 + ErrorCodeObjectMissing = "object_missing" +) + +type Options struct { + DryRun bool + Grace time.Duration + MaxDeletes int +} + +type Report struct { + ScannedObjects int `json:"scanned_objects"` + ScannedRows int `json:"scanned_rows"` + ListPages int `json:"list_pages"` + OrphanObjects []string `json:"orphan_objects"` + MissingAttachments []uuid.UUID `json:"missing_attachments"` + StaleUploads []uuid.UUID `json:"stale_uploads"` + CorruptObjects []string `json:"corrupt_objects"` + SkippedFresh int `json:"skipped_fresh"` + SkippedReferenced int `json:"skipped_referenced"` + SkippedInactive int `json:"skipped_inactive"` + DeletedObjects int `json:"deleted_objects"` + DeletedRows int `json:"deleted_rows"` + MarkedFailed int `json:"marked_failed"` + DryRun bool `json:"dry_run"` + Errors []string `json:"errors"` + DurationMS int64 `json:"duration_ms"` +} + +type ObjectClient interface { + ListAll(ctx context.Context, prefix string) (s3store.ListResult, error) + DeleteAdmin(ctx context.Context, key string) error +} + +type AttachmentQueries interface { + ListAttachmentsForReconcile(ctx context.Context) ([]db.ListAttachmentsForReconcileRow, error) + DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) + MarkAttachmentFailedIfReady(ctx context.Context, arg db.MarkAttachmentFailedIfReadyParams) (int64, error) +} + +type Reconciler struct { + q AttachmentQueries + store ObjectClient + log *slog.Logger + now func() time.Time +} + +type plan struct { + orphans []s3store.ObjectInfo + staleUploads []db.ListAttachmentsForReconcileRow + missing []db.ListAttachmentsForReconcileRow + corrupt []s3store.ObjectInfo + skippedFresh int + skippedReferenced int + skippedInactive int +} + +func New(store ObjectClient, queries AttachmentQueries, log *slog.Logger) *Reconciler { + if log == nil { + log = slog.Default() + } + + return &Reconciler{ + store: store, + q: queries, + log: log, + now: time.Now, + } +} + +func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { + opts = opts.withDefaults() + started := r.now() + + report := Report{ + OrphanObjects: []string{}, + MissingAttachments: []uuid.UUID{}, + StaleUploads: []uuid.UUID{}, + CorruptObjects: []string{}, + DryRun: opts.DryRun, + Errors: []string{}, + } + + listed, err := r.store.ListAll(ctx, Prefix) + if err != nil { + return report, err + } + + rows, err := r.q.ListAttachmentsForReconcile(ctx) + if err != nil { + return report, err + } + + report.ScannedObjects = len(listed.Objects) + report.ScannedRows = len(rows) + report.ListPages = listed.Pages + + p := buildPlan(listed.Objects, rows, started, opts.Grace) + + for _, obj := range p.orphans { + report.OrphanObjects = append(report.OrphanObjects, obj.Key) + } + for _, obj := range p.corrupt { + report.CorruptObjects = append(report.CorruptObjects, obj.Key) + } + for _, row := range p.staleUploads { + report.StaleUploads = append(report.StaleUploads, row.ID) + } + for _, row := range p.missing { + report.MissingAttachments = append(report.MissingAttachments, row.ID) + } + + report.SkippedFresh = p.skippedFresh + report.SkippedReferenced = p.skippedReferenced + report.SkippedInactive = p.skippedInactive + + if !opts.DryRun { + r.apply(ctx, opts, p, &report) + } + + report.DurationMS = r.now().Sub(started).Milliseconds() + + r.log.Info( + "attachment reconcile finished", + "dry_run", opts.DryRun, + "scanned_objects", report.ScannedObjects, + "scanned_rows", report.ScannedRows, + "list_pages", report.ListPages, + "orphan_objects", len(report.OrphanObjects), + "missing_attachments", len(report.MissingAttachments), + "stale_uploads", len(report.StaleUploads), + "corrupt_objects", len(report.CorruptObjects), + "deleted_objects", report.DeletedObjects, + "deleted_rows", report.DeletedRows, + "marked_failed", report.MarkedFailed, + "errors", len(report.Errors), + ) + + return report, nil +} + +func (o Options) withDefaults() Options { + if o.Grace <= 0 { + o.Grace = DefaultGrace + } + if o.MaxDeletes <= 0 { + o.MaxDeletes = DefaultMaxDeletes + } + + return o +} + +func buildPlan( + objects []s3store.ObjectInfo, + rows []db.ListAttachmentsForReconcileRow, + now time.Time, + grace time.Duration, +) plan { + var p plan + + byKey := make(map[string]s3store.ObjectInfo, len(objects)) + for _, obj := range objects { + byKey[obj.Key] = obj + } + + for _, row := range rows { + obj, exists := byKey[row.S3Key] + if exists { + delete(byKey, row.S3Key) + } + + switch row.Status { + case db.AttachmentStatusQueued: + if now.Sub(row.CreatedAt) < grace { + p.skippedFresh++ + continue + } + if row.Referenced { + p.skippedReferenced++ + continue + } + p.staleUploads = append(p.staleUploads, row) + case db.AttachmentStatusReady: + if !exists { + p.missing = append(p.missing, row) + continue + } + if obj.Size != int64(row.SizeBytes) { + p.corrupt = append(p.corrupt, obj) + } + default: + if exists { + p.skippedInactive++ + } + } + } + + for _, obj := range byKey { + if now.Sub(obj.LastModified) < grace { + p.skippedFresh++ + continue + } + p.orphans = append(p.orphans, obj) + } + + sort.Slice(p.orphans, func(i, j int) bool { + return p.orphans[i].Key < p.orphans[j].Key + }) + sort.Slice(p.corrupt, func(i, j int) bool { + return p.corrupt[i].Key < p.corrupt[j].Key + }) + sort.Slice(p.staleUploads, func(i, j int) bool { + return p.staleUploads[i].ID.String() < p.staleUploads[j].ID.String() + }) + sort.Slice(p.missing, func(i, j int) bool { + return p.missing[i].ID.String() < p.missing[j].ID.String() + }) + + return p +} + +func (r *Reconciler) apply(ctx context.Context, opts Options, p plan, report *Report) { + deletes := 0 + + for _, row := range p.staleUploads { + if deletes >= opts.MaxDeletes { + report.Errors = append(report.Errors, "max deletes reached") + break + } + + removed, err := r.q.DeleteQueuedAttachment(ctx, row.ID) + if err != nil { + report.Errors = append(report.Errors, fmt.Sprintf("delete row %s: %v", row.ID, err)) + continue + } + if removed == 0 { + continue + } + + deletes++ + report.DeletedRows++ + + if err := r.store.DeleteAdmin(ctx, row.S3Key); err != nil { + report.Errors = append(report.Errors, fmt.Sprintf("delete object %s: %v", row.S3Key, err)) + continue + } + report.DeletedObjects++ + } + + for _, obj := range p.orphans { + if deletes >= opts.MaxDeletes { + report.Errors = append(report.Errors, "max deletes reached") + break + } + + if err := r.store.DeleteAdmin(ctx, obj.Key); err != nil { + report.Errors = append(report.Errors, fmt.Sprintf("delete object %s: %v", obj.Key, err)) + continue + } + + deletes++ + report.DeletedObjects++ + } + + for _, row := range p.missing { + marked, err := r.q.MarkAttachmentFailedIfReady(ctx, db.MarkAttachmentFailedIfReadyParams{ + ID: row.ID, + ErrorCode: ErrorCodeObjectMissing, + }) + if err != nil { + report.Errors = append(report.Errors, fmt.Sprintf("mark failed %s: %v", row.ID, err)) + continue + } + + report.MarkedFailed += int(marked) + } +} diff --git a/internal/redis/client.go b/internal/redis/client.go new file mode 100644 index 00000000..65ccd3a2 --- /dev/null +++ b/internal/redis/client.go @@ -0,0 +1,32 @@ +package redis + +import ( + "context" + "fmt" + "log/slog" + "time" + + goredis "github.com/redis/go-redis/v9" +) + +func New(ctx context.Context, log *slog.Logger, url string) (*goredis.Client, error) { + opts, err := goredis.ParseURL(url) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + + opts.DialTimeout = 1 * time.Second + opts.ReadTimeout = 200 * time.Millisecond + opts.WriteTimeout = 200 * time.Millisecond + opts.MaxRetries = -1 + + client := goredis.NewClient(opts) + + pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + if err := client.Ping(pingCtx).Err(); err != nil { + log.Warn("redis unavailable, running without cache", "error", err) + } + + return client, nil +} diff --git a/internal/s3/client.go b/internal/s3/client.go new file mode 100644 index 00000000..c51188c4 --- /dev/null +++ b/internal/s3/client.go @@ -0,0 +1,279 @@ +package s3 + +import ( + "context" + "errors" + "io" + "log/slog" + "net" + "net/http" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" + awsconfig "github.com/aws/aws-sdk-go-v2/config" + "github.com/aws/aws-sdk-go-v2/credentials" + awss3 "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/smithy-go" + + appconfig "mtusi2026-messenger/internal/config" +) + +var ( + ErrUnavailable = errors.New("s3 unavailable") + ErrLoadConfig = errors.New("load aws config") + ErrHeadBucket = errors.New("head bucket") + ErrCreateBucket = errors.New("create bucket") + ErrObjectNotFound = errors.New("object not found") + ErrPutObject = errors.New("put object") + ErrGetObject = errors.New("get object") + ErrListObjects = errors.New("list objects") + ErrDeleteObject = errors.New("delete object") +) + +type Client struct { + bucket string + bootstrap *awss3.Client + api *awss3.Client + log *slog.Logger +} + +type ObjectInfo struct { + Key string + Size int64 + LastModified time.Time +} + +type ListResult struct { + Objects []ObjectInfo + Pages int +} + +func New(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client, error) { + apiAccessKey, err := cfg.APIAccessKey() + if err != nil { + log.Error("read s3 api access key", "error", err) + return nil, err + } + + apiSecretKey, err := cfg.APISecretKey() + if err != nil { + log.Error("read s3 api secret key", "error", err) + return nil, err + } + + bootstrapAccessKey, err := cfg.BootstrapAccessKey() + if err != nil { + log.Error("read s3 bootstrap access key", "error", err) + return nil, err + } + + bootstrapSecretKey, err := cfg.BootstrapSecretKey() + if err != nil { + log.Error("read s3 bootstrap secret key", "error", err) + return nil, err + } + + bootstrap, err := newS3Client(ctx, log, cfg.Endpoint, cfg.Region, bootstrapAccessKey, bootstrapSecretKey) + if err != nil { + return nil, err + } + + api, err := newS3Client(ctx, log, cfg.Endpoint, cfg.Region, apiAccessKey, apiSecretKey) + if err != nil { + return nil, err + } + + return &Client{ + bucket: cfg.Bucket, + bootstrap: bootstrap, + api: api, + log: log, + }, nil +} + +func (c *Client) Bucket() string { + return c.bucket +} + +func (c *Client) EnsureBucket(ctx context.Context) error { + _, err := c.bootstrap.HeadBucket(ctx, &awss3.HeadBucketInput{ + Bucket: aws.String(c.bucket), + }) + if err == nil { + return nil + } + + if !isNotFound(err) { + c.log.Error("head bucket", "bucket", c.bucket, "error", err) + return ErrHeadBucket + } + + _, err = c.bootstrap.CreateBucket(ctx, &awss3.CreateBucketInput{ + Bucket: aws.String(c.bucket), + }) + if err == nil || isAlreadyExists(err) { + return nil + } + + c.log.Error("create bucket", "bucket", c.bucket, "error", err) + return ErrCreateBucket +} + +func (c *Client) Ping(ctx context.Context) error { + _, err := c.api.HeadBucket(ctx, &awss3.HeadBucketInput{Bucket: aws.String(c.bucket)}) + if err != nil { + c.log.Error("head bucket", "bucket", c.bucket, "error", err) + return operationError(ErrHeadBucket, err) + } + return nil +} + +func (c *Client) Put( + ctx context.Context, + key string, + body io.ReadSeeker, + size int64, + contentType string, +) error { + _, err := c.api.PutObject(ctx, &awss3.PutObjectInput{ + Bucket: aws.String(c.bucket), + Key: aws.String(key), + Body: body, + ContentLength: aws.Int64(size), + ContentType: aws.String(contentType), + }) + if err != nil { + c.log.Error("put object", "bucket", c.bucket, "key", key, "error", err) + return operationError(ErrPutObject, err) + } + + return nil +} + +func (c *Client) Get(ctx context.Context, key string) (*awss3.GetObjectOutput, error) { + out, err := c.api.GetObject(ctx, &awss3.GetObjectInput{ + Bucket: aws.String(c.bucket), + Key: aws.String(key), + }) + if isNotFound(err) { + c.log.Warn("get object", "bucket", c.bucket, "key", key, "error", err) + return nil, ErrObjectNotFound + } + if err != nil { + c.log.Error("get object", "bucket", c.bucket, "key", key, "error", err) + return nil, operationError(ErrGetObject, err) + } + + return out, nil +} + +func (c *Client) ListAll(ctx context.Context, prefix string) (ListResult, error) { + result := ListResult{Objects: []ObjectInfo{}} + + paginator := awss3.NewListObjectsV2Paginator(c.bootstrap, &awss3.ListObjectsV2Input{ + Bucket: aws.String(c.bucket), + Prefix: aws.String(prefix), + }) + + for paginator.HasMorePages() { + page, err := paginator.NextPage(ctx) + if err != nil { + c.log.Error("list objects", "bucket", c.bucket, "prefix", prefix, "error", err) + return ListResult{}, ErrListObjects + } + + result.Pages++ + + for _, obj := range page.Contents { + result.Objects = append(result.Objects, ObjectInfo{ + Key: aws.ToString(obj.Key), + Size: aws.ToInt64(obj.Size), + LastModified: aws.ToTime(obj.LastModified), + }) + } + } + + return result, nil +} + +func (c *Client) DeleteAdmin(ctx context.Context, key string) error { + _, err := c.bootstrap.DeleteObject(ctx, &awss3.DeleteObjectInput{ + Bucket: aws.String(c.bucket), + Key: aws.String(key), + }) + if isNotFound(err) { + return nil + } + if err != nil { + c.log.Error("delete admin object", "bucket", c.bucket, "key", key, "error", err) + return ErrDeleteObject + } + + return nil +} + +func newS3Client( + ctx context.Context, + log *slog.Logger, + endpoint string, + region string, + accessKey string, + secretKey string, +) (*awss3.Client, error) { + cfg, err := awsconfig.LoadDefaultConfig( + ctx, + awsconfig.WithRegion(region), + awsconfig.WithCredentialsProvider( + credentials.NewStaticCredentialsProvider(accessKey, secretKey, ""), + ), + ) + if err != nil { + log.Error("load aws config", "endpoint", endpoint, "region", region, "error", err) + return nil, ErrLoadConfig + } + + return awss3.NewFromConfig(cfg, func(o *awss3.Options) { + o.BaseEndpoint = aws.String(endpoint) + o.UsePathStyle = true + }), nil +} + +func operationError(operation, err error) error { + var networkError net.Error + var responseError *awshttp.ResponseError + if errors.Is(err, context.DeadlineExceeded) || errors.As(err, &networkError) || + (errors.As(err, &responseError) && responseError.HTTPStatusCode() >= 500) { + return ErrUnavailable + } + return operation +} + +func isNotFound(err error) bool { + var responseErr *awshttp.ResponseError + if errors.As(err, &responseErr) && responseErr.HTTPStatusCode() == http.StatusNotFound { + return true + } + + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + switch apiErr.ErrorCode() { + case "NotFound", "NoSuchBucket", "NoSuchKey": + return true + } + } + + return false +} + +func isAlreadyExists(err error) bool { + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + switch apiErr.ErrorCode() { + case "BucketAlreadyOwnedByYou", "BucketAlreadyExists": + return true + } + } + + return false +} diff --git a/internal/s3/config.go b/internal/s3/config.go new file mode 100644 index 00000000..672c33c2 --- /dev/null +++ b/internal/s3/config.go @@ -0,0 +1,99 @@ +package s3 + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + + "mtusi2026-messenger/internal/config" +) + +const ( + seaweedUID = 1000 + seaweedGID = 1000 +) + +type Credential struct { + AccessKey string `json:"accessKey"` + SecretKey string `json:"secretKey"` +} + +type Identity struct { + Name string `json:"name"` + Credentials []Credential `json:"credentials"` + Actions []string `json:"actions"` +} + +type Config struct { + Identities []Identity `json:"identities"` +} + +func WriteConfig(output string, cfg config.S3Config) error { + apiAccessKey, err := cfg.APIAccessKey() + if err != nil { + return err + } + + apiSecretKey, err := cfg.APISecretKey() + if err != nil { + return err + } + + bootstrapAccessKey, err := cfg.BootstrapAccessKey() + if err != nil { + return err + } + + bootstrapSecretKey, err := cfg.BootstrapSecretKey() + if err != nil { + return err + } + + config := Config{ + Identities: []Identity{ + { + Name: "bootstrap", + Credentials: []Credential{ + {AccessKey: bootstrapAccessKey, SecretKey: bootstrapSecretKey}, + }, + Actions: []string{"Admin", "Read", "Write", "List", "Tagging"}, + }, + { + Name: "api", + Credentials: []Credential{ + {AccessKey: apiAccessKey, SecretKey: apiSecretKey}, + }, + Actions: []string{"Read", "Write", "List", "Tagging"}, + }, + }, + } + + data, err := json.MarshalIndent(config, "", " ") + if err != nil { + return fmt.Errorf("marshal s3 config: %w", err) + } + + if err := os.MkdirAll(filepath.Dir(output), 0o755); err != nil { + return fmt.Errorf("create config directory: %w", err) + } + + tmp := output + ".tmp" + if err := os.WriteFile(tmp, append(data, '\n'), 0o600); err != nil { + return fmt.Errorf("write config: %w", err) + } + + if err := os.Chown(tmp, seaweedUID, seaweedGID); err != nil { + return fmt.Errorf("chown config: %w", err) + } + + if err := os.Chmod(tmp, 0o400); err != nil { + return fmt.Errorf("chmod config: %w", err) + } + + if err := os.Rename(tmp, output); err != nil { + return fmt.Errorf("replace config: %w", err) + } + + return nil +} diff --git a/internal/service/attachment.go b/internal/service/attachment.go new file mode 100644 index 00000000..63112c94 --- /dev/null +++ b/internal/service/attachment.go @@ -0,0 +1,286 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "net" + "net/http" + "os" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/postgres" + s3store "mtusi2026-messenger/internal/s3" +) + +var ( + ErrAttachmentNotFound = errors.New("attachment not found") + ErrAttachmentNotReady = errors.New("attachment not ready") + ErrInvalidImage = errors.New("invalid image") + ErrInvalidSize = errors.New("invalid size") + ErrUploadReadTimeout = errors.New("upload body read timed out") +) + +type attachmentQueries interface { + CreateAttachment(ctx context.Context, arg db.CreateAttachmentParams) (db.Attachment, error) + GetAttachmentByID(ctx context.Context, id uuid.UUID) (db.Attachment, error) + IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error) + MarkAttachmentReady(ctx context.Context, id uuid.UUID) (db.Attachment, error) +} + +type AttachmentService struct { + q attachmentQueries + s3 *s3store.Client + maxBytes int + maxPixels int + decodeSlot chan struct{} +} + +func NewAttachmentService( + q attachmentQueries, + s3 *s3store.Client, + maxBytes, maxPixels int, +) *AttachmentService { + return &AttachmentService{ + q: q, + s3: s3, + maxBytes: maxBytes, + maxPixels: maxPixels, + decodeSlot: make(chan struct{}, 1), + } +} + +func (s *AttachmentService) Upload( + ctx context.Context, + userID, chatID uuid.UUID, + filename string, + body io.Reader, + contentType string, +) (model.Attachment, error) { + if err := s.ensureMember(ctx, userID, chatID); err != nil { + return model.Attachment{}, err + } + + tmp, err := os.CreateTemp("", "upload-*.tmp") + if err != nil { + return model.Attachment{}, err + } + defer func() { + _ = tmp.Close() + _ = os.Remove(tmp.Name()) + }() + + hasher := sha256.New() + size, err := io.Copy(io.MultiWriter(tmp, hasher), body) + if err != nil { + var maxBytesErr *http.MaxBytesError + if errors.As(err, &maxBytesErr) { + return model.Attachment{}, ErrInvalidSize + } + var networkErr net.Error + if errors.As(err, &networkErr) && networkErr.Timeout() { + return model.Attachment{}, ErrUploadReadTimeout + } + return model.Attachment{}, err + } + if size > int64(s.maxBytes) { + return model.Attachment{}, ErrInvalidSize + } + + if _, err := tmp.Seek(0, io.SeekStart); err != nil { + return model.Attachment{}, err + } + detectedType, err := s.checkImage(ctx, tmp, contentType) + if err != nil { + return model.Attachment{}, err + } + + id, err := uuid.NewV7() + if err != nil { + return model.Attachment{}, err + } + + hash := hex.EncodeToString(hasher.Sum(nil)) + key := "chats/" + chatID.String() + "/attachments/" + id.String() + + if _, err := tmp.Seek(0, io.SeekStart); err != nil { + return model.Attachment{}, err + } + + _, err = s.q.CreateAttachment(ctx, db.CreateAttachmentParams{ + ID: id, + ChatID: chatID, + OwnerID: userID, + S3Key: key, + Filename: filename, + ContentType: db.AttachmentContentType(detectedType), + SizeBytes: int(size), + Sha256: hash, + ErrorCode: "", + }) + if postgres.IsNotFound(err) { + return model.Attachment{}, ErrAttachmentNotFound + } + if err != nil { + return model.Attachment{}, err + } + + if err := s.s3.Put(ctx, key, tmp, size, string(detectedType)); err != nil { + return model.Attachment{}, err + } + + row, err := s.q.MarkAttachmentReady(ctx, id) + if err != nil { + return model.Attachment{}, err + } + + return model.Attachment{ + ID: row.ID, + ChatID: row.ChatID, + OwnerID: row.OwnerID, + Filename: row.Filename, + ContentType: model.ContentType(row.ContentType), + SizeBytes: row.SizeBytes, + Sha256: row.Sha256, + Status: model.AttachmentStatus(row.Status), + ErrorCode: row.ErrorCode, + CreatedAt: row.CreatedAt, + UpdatedAt: row.UpdatedAt, + }, nil +} + +func (s *AttachmentService) Get( + ctx context.Context, + userID, attachmentID uuid.UUID, +) (model.Attachment, error) { + row, err := s.q.GetAttachmentByID(ctx, attachmentID) + if postgres.IsNotFound(err) { + return model.Attachment{}, ErrAttachmentNotFound + } + if err != nil { + return model.Attachment{}, err + } + + if err := s.ensureMember(ctx, userID, row.ChatID); err != nil { + return model.Attachment{}, err + } + + return model.Attachment{ + ID: row.ID, + ChatID: row.ChatID, + OwnerID: row.OwnerID, + Filename: row.Filename, + ContentType: model.ContentType(row.ContentType), + SizeBytes: row.SizeBytes, + Sha256: row.Sha256, + Status: model.AttachmentStatus(row.Status), + ErrorCode: row.ErrorCode, + CreatedAt: row.CreatedAt, + UpdatedAt: row.UpdatedAt, + }, nil +} + +func (s *AttachmentService) GetContent( + ctx context.Context, + userID, attachmentID uuid.UUID, +) ([]byte, model.ContentType, error) { + row, err := s.q.GetAttachmentByID(ctx, attachmentID) + if postgres.IsNotFound(err) { + return nil, "", ErrAttachmentNotFound + } + if err != nil { + return nil, "", err + } + + if err := s.ensureMember(ctx, userID, row.ChatID); err != nil { + return nil, "", err + } + + if model.AttachmentStatus(row.Status) != model.AttachmentStatusReady { + return nil, "", ErrAttachmentNotReady + } + + out, err := s.s3.Get(ctx, row.S3Key) + if err != nil { + return nil, "", err + } + defer out.Body.Close() + + data, err := io.ReadAll(out.Body) + if err != nil { + return nil, "", err + } + + return data, model.ContentType(row.ContentType), nil +} + +func (s *AttachmentService) checkImage(ctx context.Context, r io.ReadSeeker, contentType string) (model.ContentType, error) { + cfg, format, err := image.DecodeConfig(r) + if err != nil { + return "", ErrInvalidImage + } + + if cfg.Width <= 0 || cfg.Height <= 0 { + return "", ErrInvalidImage + } + if cfg.Width > s.maxPixels/cfg.Height { + return "", ErrInvalidSize + } + + var detectedType model.ContentType + switch format { + case "png": + if contentType != string(model.ContentTypePNG) { + return "", ErrInvalidImage + } + detectedType = model.ContentTypePNG + case "jpeg": + if contentType != string(model.ContentTypeJPEG) { + return "", ErrInvalidImage + } + detectedType = model.ContentTypeJPEG + default: + return "", ErrInvalidImage + } + + select { + case s.decodeSlot <- struct{}{}: + defer func() { <-s.decodeSlot }() + case <-ctx.Done(): + return "", ctx.Err() + } + if err := ctx.Err(); err != nil { + return "", err + } + if _, err := r.Seek(0, io.SeekStart); err != nil { + return "", err + } + if _, _, err := image.Decode(r); err != nil { + return "", ErrInvalidImage + } + + return detectedType, nil +} + +func (s *AttachmentService) ensureMember(ctx context.Context, userID, chatID uuid.UUID) error { + member, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{ + ChatID: chatID, + UserID: userID, + }) + if err != nil { + return err + } + if !member { + return ErrAttachmentNotFound + } + + return nil +} diff --git a/internal/service/auth.go b/internal/service/auth.go new file mode 100644 index 00000000..6e4ac775 --- /dev/null +++ b/internal/service/auth.go @@ -0,0 +1,188 @@ +package service + +import ( + "context" + "errors" + "log/slog" + "time" + + "mtusi2026-messenger/internal/credentials" + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/postgres" + + "github.com/google/uuid" + goredis "github.com/redis/go-redis/v9" +) + +const sessionCacheTTL = 60 * time.Second +const cacheOpTimeout = 300 * time.Millisecond + +var ( + ErrInvalidCredentials = errors.New("invalid credentials") + ErrUnauthorized = errors.New("unauthorized") + ErrSessionCacheUnavailable = errors.New("session cache unavailable") +) + +type authQueries interface { + CreateSession(ctx context.Context, arg db.CreateSessionParams) error + DeleteSession(ctx context.Context, tokenHash string) (int64, error) + GetActiveSession(ctx context.Context, tokenHash string) (db.GetActiveSessionRow, error) + GetUserByUsername(ctx context.Context, username string) (db.User, error) +} + +type AuthService struct { + q authQueries + cache *goredis.Client + sessionTTL time.Duration + log *slog.Logger +} + +func NewAuthService(q authQueries, cache *goredis.Client, sessionTTL time.Duration, log *slog.Logger) *AuthService { + return &AuthService{ + q: q, + cache: cache, + sessionTTL: sessionTTL, + log: log, + } +} + +var dummyHash, _ = credentials.HashPassword("dummy-password-for-timing") + +func (s *AuthService) Login(ctx context.Context, username, plain string) (model.Session, error) { + user, err := s.q.GetUserByUsername(ctx, username) + if postgres.IsNotFound(err) { + _ = credentials.VerifyPassword(dummyHash, plain) + return model.Session{}, ErrInvalidCredentials + } + if err != nil { + return model.Session{}, err + } + + if err := credentials.VerifyPassword(user.PasswordHash, plain); err != nil { + if errors.Is(err, credentials.ErrPasswordMismatch) { + return model.Session{}, ErrInvalidCredentials + } + return model.Session{}, err + } + + token := credentials.NewToken() + expiresAt := time.Now().UTC().Add(s.sessionTTL) + + err = s.q.CreateSession(ctx, db.CreateSessionParams{ + TokenHash: credentials.HashToken(token), + UserID: user.ID, + ExpiresAt: expiresAt, + }) + if err != nil { + return model.Session{}, err + } + + return model.Session{ + Token: token, + ExpiresAt: expiresAt, + User: model.User{ + ID: user.ID, + Username: user.Username, + DisplayName: user.DisplayName, + CreatedAt: user.CreatedAt.UTC(), + }, + }, nil +} + +func (s *AuthService) Authenticate(ctx context.Context, token string) (uuid.UUID, error) { + tokenHash := credentials.HashToken(token) + key := cacheKey(tokenHash) + + if id, ok := s.cacheGet(ctx, key); ok { + return id, nil + } + + row, err := s.q.GetActiveSession(ctx, tokenHash) + if postgres.IsNotFound(err) { + return uuid.Nil, ErrUnauthorized + } + if err != nil { + return uuid.Nil, err + } + + s.cacheSet(ctx, key, row.UserID, min(time.Until(row.ExpiresAt), sessionCacheTTL)) + + return row.UserID, nil +} + +func (s *AuthService) Logout(ctx context.Context, token string) error { + tokenHash := credentials.HashToken(token) + + n, err := s.q.DeleteSession(ctx, tokenHash) + if err != nil { + return err + } + + if err := s.cacheDel(ctx, cacheKey(tokenHash)); err != nil { + return ErrSessionCacheUnavailable + } + + if n == 0 { + return ErrUnauthorized + } + return nil +} + +func cacheKey(tokenHash string) string { + return "session:" + tokenHash +} + +func (s *AuthService) cacheGet(ctx context.Context, key string) (uuid.UUID, bool) { + if s.cache == nil { + return uuid.Nil, false + } + + cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout) + defer cancel() + + val, err := s.cache.Get(cctx, key).Result() + switch { + case err == nil: + id, perr := uuid.Parse(val) + if perr != nil { + s.log.Warn("session cache value is not a uuid", "error", perr) + return uuid.Nil, false + } + s.log.Debug("session cache hit") + return id, true + case errors.Is(err, goredis.Nil): + s.log.Debug("session cache miss") + default: + s.log.Warn("session cache get failed, falling back to database", "error", err) + } + return uuid.Nil, false +} + +func (s *AuthService) cacheSet(ctx context.Context, key string, id uuid.UUID, ttl time.Duration) { + if s.cache == nil || ttl <= 0 { + return + } + + cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout) + defer cancel() + + if err := s.cache.Set(cctx, key, id.String(), ttl).Err(); err != nil { + s.log.Warn("session cache set failed", "error", err) + } +} + +func (s *AuthService) cacheDel(ctx context.Context, key string) error { + if s.cache == nil { + return nil + } + + cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout) + defer cancel() + + if err := s.cache.Del(cctx, key).Err(); err != nil { + s.log.Warn("session cache delete failed", "error", err) + return err + } + return nil +} diff --git a/internal/service/chat.go b/internal/service/chat.go new file mode 100644 index 00000000..c00caa8d --- /dev/null +++ b/internal/service/chat.go @@ -0,0 +1,204 @@ +package service + +import ( + "bytes" + "context" + "errors" + "slices" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/postgres" +) + +var ( + ErrChatNotFound = errors.New("chat not found") + ErrNotChatMember = errors.New("caller must be a member of member_ids") + ErrDuplicateMember = errors.New("member_ids contains duplicates") + ErrUnknownMember = errors.New("member_ids contains unknown user") +) + +type chatQueries interface { + AddChatMembers(ctx context.Context, arg db.AddChatMembersParams) error + CreateChat(ctx context.Context, arg db.CreateChatParams) (db.Chat, error) + GetChat(ctx context.Context, arg db.GetChatParams) (db.GetChatRow, error) + ListChatsAfter(ctx context.Context, arg db.ListChatsAfterParams) ([]db.ListChatsAfterRow, error) + ListChatsFirstPage(ctx context.Context, arg db.ListChatsFirstPageParams) ([]db.ListChatsFirstPageRow, error) +} + +type ChatService struct { + pool txBeginner + q chatQueries + withTx func(pgx.Tx) chatQueries +} + +func NewChatService(pool *pgxpool.Pool, q *db.Queries) *ChatService { + return &ChatService{ + pool: pool, + q: q, + withTx: func(tx pgx.Tx) chatQueries { + return q.WithTx(tx) + }, + } +} + +func (s *ChatService) Create( + ctx context.Context, + userID uuid.UUID, + title string, + memberIDs []uuid.UUID, +) (model.Chat, error) { + if !slices.Contains(memberIDs, userID) { + return model.Chat{}, ErrNotChatMember + } + + tx, err := s.pool.Begin(ctx) + if err != nil { + return model.Chat{}, err + } + defer tx.Rollback(ctx) + + q := s.withTx(tx) + + id, err := uuid.NewV7() + if err != nil { + return model.Chat{}, err + } + + row, err := q.CreateChat(ctx, db.CreateChatParams{ + ID: id, + Title: title, + }) + if err != nil { + return model.Chat{}, err + } + + err = q.AddChatMembers(ctx, db.AddChatMembersParams{ + ChatID: row.ID, + UserIds: memberIDs, + }) + switch postgres.ErrCode(err) { + case postgres.CodeUniqueViolation: + return model.Chat{}, ErrDuplicateMember + case postgres.CodeForeignKeyViolation: + return model.Chat{}, ErrUnknownMember + } + if err != nil { + return model.Chat{}, err + } + + if err := tx.Commit(ctx); err != nil { + return model.Chat{}, err + } + + ids := slices.Clone(memberIDs) + slices.SortFunc(ids, func(a, b uuid.UUID) int { + return bytes.Compare(a[:], b[:]) + }) + + return model.Chat{ + ID: row.ID, + Title: row.Title, + CreatedAt: row.CreatedAt, + MemberIDs: ids, + }, nil +} + +func (s *ChatService) Get( + ctx context.Context, + userID uuid.UUID, + chatID uuid.UUID, +) (model.Chat, error) { + row, err := s.q.GetChat(ctx, db.GetChatParams{ + ID: chatID, + UserID: userID, + }) + if postgres.IsNotFound(err) { + return model.Chat{}, ErrChatNotFound + } + if err != nil { + return model.Chat{}, err + } + + return model.Chat{ + ID: row.ID, + Title: row.Title, + CreatedAt: row.CreatedAt, + MemberIDs: row.MemberIds, + }, nil +} + +func (s *ChatService) List( + ctx context.Context, + userID uuid.UUID, + limit int, + cursor *string, +) ([]model.Chat, *string, error) { + var chats []model.Chat + + if cursor == nil { + rows, err := s.q.ListChatsFirstPage(ctx, db.ListChatsFirstPageParams{ + UserID: userID, + Lim: limit + 1, + }) + if err != nil { + return nil, nil, err + } + + chats = make([]model.Chat, 0, len(rows)) + for _, r := range rows { + chats = append(chats, model.Chat{ + ID: r.ID, + Title: r.Title, + CreatedAt: r.CreatedAt, + MemberIDs: r.MemberIds, + }) + } + } else { + decoded, derr := decodeCursor(*cursor, uuid.Nil) + if derr != nil { + return nil, nil, ErrInvalidCursor + } + + rows, err := s.q.ListChatsAfter(ctx, db.ListChatsAfterParams{ + UserID: userID, + AfterCreatedAt: decoded.CreatedAt, + AfterID: decoded.ID, + Lim: limit + 1, + }) + if err != nil { + return nil, nil, err + } + + chats = make([]model.Chat, 0, len(rows)) + for _, r := range rows { + chats = append(chats, model.Chat{ + ID: r.ID, + Title: r.Title, + CreatedAt: r.CreatedAt, + MemberIDs: r.MemberIds, + }) + } + } + + hasMore := len(chats) > limit + if hasMore { + chats = chats[:limit] + } + + var next *string + if hasMore { + last := chats[len(chats)-1] + c := encodeCursor(Cursor{ + CreatedAt: last.CreatedAt, + ID: last.ID, + }) + next = &c + } + + return chats, next, nil +} diff --git a/internal/service/cursor.go b/internal/service/cursor.go new file mode 100644 index 00000000..4709543f --- /dev/null +++ b/internal/service/cursor.go @@ -0,0 +1,41 @@ +package service + +import ( + "encoding/base64" + "encoding/json" + "errors" + "time" + + "github.com/google/uuid" +) + +var ErrInvalidCursor = errors.New("invalid cursor") + +type Cursor struct { + ChatID uuid.UUID `json:"chat_id"` + CreatedAt time.Time `json:"created_at"` + ID uuid.UUID `json:"id"` +} + +func encodeCursor(cursor Cursor) string { + data, _ := json.Marshal(cursor) + return base64.RawURLEncoding.EncodeToString(data) +} + +func decodeCursor(raw string, chatID uuid.UUID) (Cursor, error) { + data, err := base64.RawURLEncoding.DecodeString(raw) + if err != nil { + return Cursor{}, ErrInvalidCursor + } + + var cursor Cursor + if err := json.Unmarshal(data, &cursor); err != nil { + return Cursor{}, ErrInvalidCursor + } + + if cursor.ID == uuid.Nil || cursor.CreatedAt.IsZero() || cursor.ChatID != chatID { + return Cursor{}, ErrInvalidCursor + } + + return cursor, nil +} diff --git a/internal/service/message.go b/internal/service/message.go new file mode 100644 index 00000000..a6316e35 --- /dev/null +++ b/internal/service/message.go @@ -0,0 +1,289 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "net/http" + "sort" + "strings" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/postgres" +) + +var ( + ErrMessageChatNotFound = errors.New("chat not found") + ErrIdempotencyKeyConflict = errors.New("idempotency key reused with different request") +) + +type messageQueries interface { + CreateIdempotencyKey(ctx context.Context, arg db.CreateIdempotencyKeyParams) (int64, error) + CreateMessage(ctx context.Context, arg db.CreateMessageParams) (db.Message, error) + CreateMessageAttachment(ctx context.Context, arg db.CreateMessageAttachmentParams) error + GetIdempotentMessage(ctx context.Context, arg db.GetIdempotentMessageParams) (db.GetIdempotentMessageRow, error) + IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error) + ListAttachmentsByIDs(ctx context.Context, arg db.ListAttachmentsByIDsParams) ([]db.AttachmentStatus, error) + ListMessageAttachmentIDs(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) + ListMessageAttachmentsByMessageIDs(ctx context.Context, messageIDs []uuid.UUID) ([]db.ListMessageAttachmentsByMessageIDsRow, error) + ListMessagesAfter(ctx context.Context, arg db.ListMessagesAfterParams) ([]db.Message, error) + ListMessagesFirstPage(ctx context.Context, arg db.ListMessagesFirstPageParams) ([]db.Message, error) +} + +type MessageService struct { + pool txBeginner + q *db.Queries + withTx func(pgx.Tx) messageQueries +} + +func NewMessageService(pool *pgxpool.Pool, q *db.Queries) *MessageService { + return &MessageService{ + pool: pool, + q: q, + withTx: func(tx pgx.Tx) messageQueries { + return q.WithTx(tx) + }, + } +} + +func (s *MessageService) Create( + ctx context.Context, + userID uuid.UUID, + chatID uuid.UUID, + key string, + text string, + attachmentIDs []uuid.UUID, +) (model.Message, error) { + id, err := uuid.NewV7() + if err != nil { + return model.Message{}, err + } + + if len(attachmentIDs) > 0 { + statuses, err := s.q.ListAttachmentsByIDs(ctx, db.ListAttachmentsByIDsParams{ + ChatID: chatID, + Ids: attachmentIDs, + }) + if err != nil { + return model.Message{}, err + } + if len(statuses) != len(attachmentIDs) { + return model.Message{}, ErrAttachmentNotFound + } + for _, status := range statuses { + if status != db.AttachmentStatusReady { + return model.Message{}, ErrAttachmentNotReady + } + } + } + + hashInput := text + "|" + normalizeAttachmentIDs(attachmentIDs) + sum := sha256.Sum256([]byte(hashInput)) + hash := hex.EncodeToString(sum[:]) + path := "/api/v1/chats/" + chatID.String() + "/messages" + + tx, err := s.pool.Begin(ctx) + if err != nil { + return model.Message{}, err + } + defer tx.Rollback(ctx) + + q := s.withTx(tx) + + inserted, err := q.CreateIdempotencyKey(ctx, db.CreateIdempotencyKeyParams{ + UserID: userID, + Method: http.MethodPost, + Path: path, + Key: key, + RequestHash: hash, + MessageID: id, + }) + if err != nil { + return model.Message{}, err + } + + if inserted == 0 { + isMember, err := q.IsChatMember(ctx, db.IsChatMemberParams{ + ChatID: chatID, + UserID: userID, + }) + if err != nil { + return model.Message{}, err + } + if !isMember { + return model.Message{}, ErrMessageChatNotFound + } + + stored, err := q.GetIdempotentMessage(ctx, db.GetIdempotentMessageParams{ + UserID: userID, + Method: http.MethodPost, + Path: path, + Key: key, + }) + if err != nil { + return model.Message{}, err + } + if stored.RequestHash != hash { + return model.Message{}, ErrIdempotencyKeyConflict + } + + storedAttachmentIDs, err := q.ListMessageAttachmentIDs(ctx, stored.ID) + if err != nil { + return model.Message{}, err + } + + return model.Message{ + ID: stored.ID, + ChatID: stored.ChatID, + SenderID: stored.SenderID, + Text: stored.Text, + AttachmentIDs: storedAttachmentIDs, + CreatedAt: stored.CreatedAt, + }, nil + } + + row, err := q.CreateMessage(ctx, db.CreateMessageParams{ + ID: id, + ChatID: chatID, + SenderID: userID, + Text: text, + }) + if postgres.IsNotFound(err) { + return model.Message{}, ErrMessageChatNotFound + } + if err != nil { + return model.Message{}, err + } + + for i, attachmentID := range attachmentIDs { + if err := q.CreateMessageAttachment(ctx, db.CreateMessageAttachmentParams{ + MessageID: id, + AttachmentID: attachmentID, + Position: i, + }); err != nil { + return model.Message{}, err + } + } + + if err := tx.Commit(ctx); err != nil { + return model.Message{}, err + } + + return model.Message{ + ID: row.ID, + ChatID: row.ChatID, + SenderID: row.SenderID, + Text: row.Text, + AttachmentIDs: attachmentIDs, + CreatedAt: row.CreatedAt, + }, nil +} + +func (s *MessageService) List( + ctx context.Context, + userID uuid.UUID, + chatID uuid.UUID, + limit int, + cursor *string, +) ([]model.Message, *string, error) { + isMember, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{ + ChatID: chatID, + UserID: userID, + }) + if err != nil { + return nil, nil, err + } + if !isMember { + return nil, nil, ErrMessageChatNotFound + } + + var rows []db.Message + + if cursor == nil { + rows, err = s.q.ListMessagesFirstPage(ctx, db.ListMessagesFirstPageParams{ + ChatID: chatID, + Lim: limit + 1, + }) + } else { + decoded, derr := decodeCursor(*cursor, chatID) + if derr != nil { + return nil, nil, ErrInvalidCursor + } + + rows, err = s.q.ListMessagesAfter(ctx, db.ListMessagesAfterParams{ + ChatID: chatID, + AfterCreatedAt: decoded.CreatedAt, + AfterID: decoded.ID, + Lim: limit + 1, + }) + } + if err != nil { + return nil, nil, err + } + + hasMore := len(rows) > limit + if hasMore { + rows = rows[:limit] + } + + attachmentsByMessage := make(map[uuid.UUID][]uuid.UUID, len(rows)) + if len(rows) > 0 { + messageIDs := make([]uuid.UUID, len(rows)) + for i, r := range rows { + messageIDs[i] = r.ID + } + + links, err := s.q.ListMessageAttachmentsByMessageIDs(ctx, messageIDs) + if err != nil { + return nil, nil, err + } + for _, l := range links { + attachmentsByMessage[l.MessageID] = append(attachmentsByMessage[l.MessageID], l.AttachmentID) + } + } + + messages := make([]model.Message, 0, len(rows)) + for _, r := range rows { + messages = append(messages, model.Message{ + ID: r.ID, + ChatID: r.ChatID, + SenderID: r.SenderID, + Text: r.Text, + AttachmentIDs: attachmentsByMessage[r.ID], + CreatedAt: r.CreatedAt, + }) + } + + var next *string + if hasMore { + last := messages[len(messages)-1] + c := encodeCursor(Cursor{ + ChatID: chatID, + CreatedAt: last.CreatedAt, + ID: last.ID, + }) + next = &c + } + + return messages, next, nil +} + +func normalizeAttachmentIDs(ids []uuid.UUID) string { + if len(ids) == 0 { + return "" + } + + parts := make([]string, len(ids)) + for i, id := range ids { + parts[i] = id.String() + } + sort.Strings(parts) + + return strings.Join(parts, ",") +} diff --git a/internal/service/tx.go b/internal/service/tx.go new file mode 100644 index 00000000..9b2b8673 --- /dev/null +++ b/internal/service/tx.go @@ -0,0 +1,11 @@ +package service + +import ( + "context" + + "github.com/jackc/pgx/v5" +) + +type txBeginner interface { + Begin(ctx context.Context) (pgx.Tx, error) +} diff --git a/internal/service/user.go b/internal/service/user.go new file mode 100644 index 00000000..555b8b09 --- /dev/null +++ b/internal/service/user.go @@ -0,0 +1,83 @@ +package service + +import ( + "context" + "errors" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/credentials" + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/postgres" +) + +var ( + ErrUsernameTaken = errors.New("username already taken") + ErrUserNotFound = errors.New("user not found") +) + +type userQueries interface { + CreateUser(ctx context.Context, arg db.CreateUserParams) (db.CreateUserRow, error) + GetUser(ctx context.Context, id uuid.UUID) (db.GetUserRow, error) +} + +type UserService struct { + q userQueries +} + +func NewUserService(q userQueries) *UserService { + return &UserService{q: q} +} + +func (s *UserService) Create( + ctx context.Context, + username, displayName, plain string, +) (model.User, error) { + hash, err := credentials.HashPassword(plain) + if err != nil { + return model.User{}, err + } + + id, err := uuid.NewV7() + if err != nil { + return model.User{}, err + } + + row, err := s.q.CreateUser(ctx, db.CreateUserParams{ + ID: id, + Username: username, + DisplayName: displayName, + PasswordHash: hash, + }) + if err != nil { + if postgres.ErrCode(err) == postgres.CodeUniqueViolation { + return model.User{}, ErrUsernameTaken + } + return model.User{}, err + } + + return model.User{ + ID: row.ID, + Username: row.Username, + DisplayName: row.DisplayName, + CreatedAt: row.CreatedAt.UTC(), + }, nil +} + +func (s *UserService) GetByID(ctx context.Context, id uuid.UUID) (model.User, error) { + row, err := s.q.GetUser(ctx, id) + if postgres.IsNotFound(err) { + return model.User{}, ErrUserNotFound + } + if err != nil { + return model.User{}, err + } + + return model.User{ + ID: row.ID, + Username: row.Username, + DisplayName: row.DisplayName, + CreatedAt: row.CreatedAt.UTC(), + }, nil +} diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..cd3cda19 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu + +docker compose down +docker compose up -d --wait diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..b7f8570f --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +service=$(docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}}' "$TARGET_INSTANCE_ID") +[ "$service" = "api" ] || { echo "not an api container" >&2; exit 1; } + +docker stop -t 5 "$TARGET_INSTANCE_ID" >/dev/null diff --git a/sqlc.yaml b/sqlc.yaml new file mode 100644 index 00000000..8743b614 --- /dev/null +++ b/sqlc.yaml @@ -0,0 +1,34 @@ +version: "2" +sql: + - engine: "postgresql" + queries: "db/queries" + schema: "db/migrations" + gen: + go: + package: "db" + out: "internal/db" + sql_package: "pgx/v5" + emit_empty_slices: true + emit_pointers_for_null_types: true + overrides: + - db_type: "integer" + go_type: "int" + - db_type: "pg_catalog.int4" + go_type: "int" + - db_type: "uuid" + go_type: "github.com/google/uuid.UUID" + - db_type: "uuid" + nullable: true + go_type: + import: "github.com/google/uuid" + type: "UUID" + pointer: true + + - db_type: "timestamptz" + go_type: "time.Time" + - db_type: "timestamptz" + nullable: true + go_type: + import: "time" + type: "Time" + pointer: true diff --git a/student-tests/attachment_failover_test.go b/student-tests/attachment_failover_test.go new file mode 100644 index 00000000..e37e1440 --- /dev/null +++ b/student-tests/attachment_failover_test.go @@ -0,0 +1,92 @@ +//go:build failure + +package studenttests_test + +import ( + "bytes" + "context" + "io" + "net/http" + "os/exec" + "strings" + "testing" + "time" + + "mtusi2026-messenger/internal/dto" +) + +func TestAttachmentUploaderFailover(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + original := makePNG(t, 32, 32) + resp := uploadAttachment(t, user, chat.ID, "failover.png", "image/png", original) + requireStatus(t, resp, http.StatusCreated) + uploader := resp.Header.Get("X-Instance-Id") + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + if uploader == "" { + t.Fatal("upload response has no X-Instance-Id") + } + + cmd := exec.Command("docker", "compose", "ps", "-q", "api") + cmd.Dir = ".." + out, err := cmd.Output() + if err != nil { + t.Fatalf("list API replicas: %v", err) + } + replicas := strings.Fields(string(out)) + if len(replicas) < 2 { + t.Fatal("at least two running API replicas required") + } + var target string + for _, id := range replicas { + if strings.HasPrefix(id, uploader) { + target = id + break + } + } + if target == "" { + t.Fatal("upload instance is not an API container in this Compose project") + } + t.Cleanup(func() { + if err := exec.Command("docker", "start", target).Run(); err != nil { + t.Errorf("restart uploader replica: %v", err) + } + }) + if err := exec.Command("docker", "stop", "-t", "5", target).Run(); err != nil { + t.Fatalf("stop uploader replica: %v", err) + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + for ctx.Err() == nil { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, *baseURL+"/api/v1/attachments/"+att.ID.String()+"/content", nil) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", "Bearer "+user.Token) + response, err := httpClient.Do(req) + if err == nil { + data, readErr := io.ReadAll(response.Body) + response.Body.Close() + if response.StatusCode == http.StatusOK { + downloader := response.Header.Get("X-Instance-Id") + if downloader == "" || downloader == uploader { + t.Fatal("download was not served by another replica") + } + if readErr != nil { + t.Fatal(readErr) + } + if !bytes.Equal(data, original) { + t.Fatal("downloaded original differs from uploaded file") + } + return + } + if response.StatusCode != http.StatusBadGateway && response.StatusCode != http.StatusServiceUnavailable && response.StatusCode != http.StatusGatewayTimeout { + t.Fatalf("unexpected download status: %d", response.StatusCode) + } + } + time.Sleep(200 * time.Millisecond) + } + t.Fatal("download through another replica did not recover within 10s") +} diff --git a/student-tests/attachment_helpers_test.go b/student-tests/attachment_helpers_test.go new file mode 100644 index 00000000..3da7613c --- /dev/null +++ b/student-tests/attachment_helpers_test.go @@ -0,0 +1,106 @@ +//go:build contract || reconcile || failure + +package studenttests_test + +import ( + "bytes" + "encoding/json" + "net/http" + "net/url" + "testing" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +const maxUploadBytes = 10 * 1024 * 1024 + +func uploadAttachment( + t *testing.T, + actor testUser, + chatID uuid.UUID, + filename string, + contentType string, + body []byte, +) *http.Response { + t.Helper() + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/chats/"+chatID.String()+"/attachments?filename="+url.QueryEscape(filename), + bytes.NewReader(body), + ) + if err != nil { + t.Fatalf("build upload request: %v", err) + } + req.Header.Set("Content-Type", contentType) + req.Header.Set("Authorization", "Bearer "+actor.Token) + + resp, err := httpClient.Do(req) + if err != nil { + t.Fatalf("upload request failed: %v", err) + } + + return resp +} + +func uploadPNG(t *testing.T, actor testUser, chatID uuid.UUID) dto.AttachmentResponse { + t.Helper() + + resp := uploadAttachment(t, actor, chatID, "sample.png", "image/png", makePNG(t, 32, 32)) + requireStatus(t, resp, http.StatusCreated) + + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + + return att +} + +func postMessage( + t *testing.T, + actor testUser, + chatID uuid.UUID, + text string, + attachmentIDs []uuid.UUID, +) *http.Response { + t.Helper() + + body, err := json.Marshal(map[string]any{ + "text": text, + "attachment_ids": attachmentIDs, + }) + if err != nil { + t.Fatalf("marshal message: %v", err) + } + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/chats/"+chatID.String()+"/messages", + bytes.NewReader(body), + ) + if err != nil { + t.Fatalf("build message request: %v", err) + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+actor.Token) + req.Header.Set("Idempotency-Key", uuid.NewString()) + + resp, err := httpClient.Do(req) + if err != nil { + t.Fatalf("message request failed: %v", err) + } + + return resp +} + +func requireErrorCode(t *testing.T, resp *http.Response, code dto.ErrorCode) { + t.Helper() + + var apiErr dto.ErrorResponse + mustDecode(t, resp, &apiErr) + + if apiErr.Error.Code != code { + t.Errorf("expected error code %q, got %q", code, apiErr.Error.Code) + } +} diff --git a/student-tests/attachment_load_test.go b/student-tests/attachment_load_test.go new file mode 100644 index 00000000..2d8a8549 --- /dev/null +++ b/student-tests/attachment_load_test.go @@ -0,0 +1,180 @@ +//go:build load + +package studenttests_test + +import ( + "bytes" + "net/http" + "os/exec" + "sort" + "strconv" + "strings" + "sync" + "testing" + "time" +) + +func dockerMem(filter string) map[string]float64 { + out, err := exec.Command("docker", "stats", "--no-stream", "--format", "{{.Name}}\t{{.MemUsage}}").Output() + if err != nil { + return nil + } + m := map[string]float64{} + for _, line := range strings.Split(string(out), "\n") { + parts := strings.SplitN(line, "\t", 2) + if len(parts) != 2 || (filter != "" && !strings.Contains(parts[0], filter)) { + continue + } + used := strings.SplitN(parts[1], "/", 2)[0] + m[parts[0]] = memBytes(used) + } + return m +} + +func memBytes(s string) float64 { + s = strings.TrimSpace(s) + units := []struct { + suf string + mult float64 + }{ + {"GiB", 1 << 30}, {"MiB", 1 << 20}, {"KiB", 1 << 10}, + {"GB", 1e9}, {"MB", 1e6}, {"kB", 1e3}, {"B", 1}, + } + for _, u := range units { + if strings.HasSuffix(s, u.suf) { + v, _ := strconv.ParseFloat(strings.TrimSpace(strings.TrimSuffix(s, u.suf)), 64) + return v * u.mult + } + } + return 0 +} + +func mib(v float64) string { + return strconv.FormatFloat(v/(1<<20), 'f', 1, 64) + "MiB" +} + +func TestConcurrentUploads(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + body := makePNG(t, 1870, 1870) + + url := *baseURL + "/api/v1/chats/" + chat.ID.String() + "/attachments?filename=load.png" + + baseline := dockerMem("api") + + stop := make(chan struct{}) + memDone := make(chan struct{}) + peak := map[string]float64{} + go func() { + defer close(memDone) + for { + for name, v := range dockerMem("api") { + if v > peak[name] { + peak[name] = v + } + } + select { + case <-stop: + return + case <-time.After(500 * time.Millisecond): + } + } + }() + + var ( + mu sync.Mutex + statuses = make(map[int]int) + latencies []time.Duration + errors int + ) + start := time.Now() + deadline := start.Add(*duration) + + var wg sync.WaitGroup + for w := 0; w < *workers; w++ { + wg.Add(1) + go func() { + defer wg.Done() + for time.Now().Before(deadline) { + req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body)) + if err != nil { + mu.Lock() + errors++ + mu.Unlock() + return + } + req.Header.Set("Content-Type", "image/png") + req.Header.Set("Authorization", "Bearer "+user.Token) + + reqStart := time.Now() + resp, err := httpClient.Do(req) + latency := time.Since(reqStart) + if err != nil { + mu.Lock() + errors++ + mu.Unlock() + continue + } + + mu.Lock() + statuses[resp.StatusCode]++ + if resp.StatusCode == http.StatusCreated { + latencies = append(latencies, latency) + } + mu.Unlock() + resp.Body.Close() + } + }() + } + wg.Wait() + close(stop) + <-memDone + + elapsed := time.Since(start) + + total := 0 + for _, n := range statuses { + total += n + } + total += errors + + t.Logf("workers=%d duration=%.1fs elapsed=%.1fs", *workers, duration.Seconds(), elapsed.Seconds()) + t.Logf("total uploads=%d transport_errors=%d", total, errors) + for status, n := range statuses { + t.Logf("HTTP %d: %d", status, n) + } + + successful := statuses[http.StatusCreated] + t.Logf("successful RPS: %.2f", float64(successful)/elapsed.Seconds()) + + if len(latencies) > 0 { + sort.Slice(latencies, func(i, j int) bool { return latencies[i] < latencies[j] }) + t.Logf("latency p50=%s p95=%s p99=%s", + percentile(latencies, 0.50), + percentile(latencies, 0.95), + percentile(latencies, 0.99), + ) + } + + names := make(map[string]struct{}, len(baseline)+len(peak)) + for name := range baseline { + names[name] = struct{}{} + } + for name := range peak { + names[name] = struct{}{} + } + sorted := make([]string, 0, len(names)) + for name := range names { + sorted = append(sorted, name) + } + sort.Strings(sorted) + + if len(sorted) == 0 { + t.Log("memory: docker stats not available (no containers matched)") + return + } + t.Log("memory per container (idle -> peak):") + for _, name := range sorted { + t.Logf(" %s: %s -> %s", name, mib(baseline[name]), mib(peak[name])) + } +} diff --git a/student-tests/attachment_test.go b/student-tests/attachment_test.go new file mode 100644 index 00000000..0cdd0ad2 --- /dev/null +++ b/student-tests/attachment_test.go @@ -0,0 +1,139 @@ +//go:build contract + +package studenttests_test + +import ( + "bytes" + "image/jpeg" + "image/png" + "io" + "net/http" + "testing" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +func TestAttachmentJPEG(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + img, err := png.Decode(bytes.NewReader(makePNG(t, 32, 32))) + if err != nil { + t.Fatalf("decode png: %v", err) + } + var body bytes.Buffer + if err := jpeg.Encode(&body, img, nil); err != nil { + t.Fatalf("encode jpeg: %v", err) + } + + resp := uploadAttachment(t, user, chat.ID, "sample.jpg", "image/jpeg", body.Bytes()) + requireStatus(t, resp, http.StatusCreated) + + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + if att.Status != "ready" { + t.Fatalf("expected ready attachment, got %q", att.Status) + } + + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + defer resp.Body.Close() + + original, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("read original: %v", err) + } + if !bytes.Equal(original, body.Bytes()) { + t.Error("downloaded JPEG differs from uploaded original") + } +} + +func TestAttachmentTooManyPixels(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + body := makePNG(t, 8000, 5001) + if len(body) > maxUploadBytes { + t.Fatal("pixel-limit fixture exceeds upload byte limit") + } + + resp := uploadAttachment(t, user, chat.ID, "large.png", "image/png", body) + requireStatus(t, resp, http.StatusRequestEntityTooLarge) + requireErrorCode(t, resp, dto.ErrorCodePayloadTooLarge) +} + +func TestAttachmentUnsafeFilename(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + resp := uploadAttachment(t, user, chat.ID, "../image.png", "image/png", makePNG(t, 32, 32)) + requireStatus(t, resp, http.StatusBadRequest) + requireErrorCode(t, resp, dto.ErrorCodeInvalidRequest) +} + +func TestAttachmentTooLarge(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + body := bytes.Repeat([]byte{0x00}, maxUploadBytes+1) + + resp := uploadAttachment(t, user, chat.ID, "big.png", "image/png", body) + requireStatus(t, resp, http.StatusRequestEntityTooLarge) + requireErrorCode(t, resp, dto.ErrorCodePayloadTooLarge) +} + +func TestAttachmentCorruptedImage(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + body := []byte("this is definitely not a png or jpeg image") + + resp := uploadAttachment(t, user, chat.ID, "broken.png", "image/png", body) + requireStatus(t, resp, http.StatusUnsupportedMediaType) + requireErrorCode(t, resp, dto.ErrorCodeUnsupportedMediaType) +} + +func TestAttachmentMimeSubstitution(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + resp := uploadAttachment(t, user, chat.ID, "actually-png.jpg", "image/jpeg", makePNG(t, 32, 32)) + requireStatus(t, resp, http.StatusUnsupportedMediaType) + requireErrorCode(t, resp, dto.ErrorCodeUnsupportedMediaType) +} + +func TestAttachmentForeignID(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + foreign := uuid.New() + + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+foreign.String(), user.Token, nil) + requireStatus(t, resp, http.StatusNotFound) + requireErrorCode(t, resp, dto.ErrorCodeNotFound) + + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+foreign.String()+"/content", user.Token, nil) + requireStatus(t, resp, http.StatusNotFound) + requireErrorCode(t, resp, dto.ErrorCodeNotFound) + + resp = postMessage(t, user, chat.ID, "", []uuid.UUID{foreign}) + requireStatus(t, resp, http.StatusNotFound) + requireErrorCode(t, resp, dto.ErrorCodeNotFound) +} + +func TestAttachmentFromAnotherChat(t *testing.T) { + user := createUser(t) + member := createUser(t) + + chatA := createChat(t, user, user.ID, member.ID) + chatB := createChat(t, user, user.ID) + + att := uploadPNG(t, user, chatA.ID) + + // The attachment belongs to chatA; linking it to a chatB message must fail. + resp := postMessage(t, user, chatB.ID, "", []uuid.UUID{att.ID}) + requireStatus(t, resp, http.StatusNotFound) + requireErrorCode(t, resp, dto.ErrorCodeNotFound) +} diff --git a/student-tests/chat_rollback_test.go b/student-tests/chat_rollback_test.go new file mode 100644 index 00000000..76cfb8d6 --- /dev/null +++ b/student-tests/chat_rollback_test.go @@ -0,0 +1,55 @@ +//go:build contract + +package studenttests_test + +import ( + "context" + "encoding/json" + "net/http" + "os" + "strings" + "testing" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" +) + +func TestCreateChatRollback(t *testing.T) { + data, err := os.ReadFile("../secrets/test_database_url.txt") + if err != nil { + t.Fatalf("read secrets/test_database_url: %v", err) + } + + ctx := context.Background() + conn, err := pgx.Connect(ctx, strings.TrimSpace(string(data))) + if err != nil { + t.Fatalf("connect to database: %v", err) + } + defer conn.Close(ctx) + + creator := createUser(t) + title := "rollback-" + uuid.NewString() + + body, err := json.Marshal(map[string]any{ + "title": title, + "member_ids": []uuid.UUID{creator.ID, uuid.New()}, + }) + if err != nil { + t.Fatalf("marshal body: %v", err) + } + + resp := doRequest(t, http.MethodPost, "/api/v1/chats", creator.Token, body) + resp.Body.Close() + if resp.StatusCode < 400 || resp.StatusCode >= 500 { + t.Fatalf("expected 4xx, got %d", resp.StatusCode) + } + + var n int + err = conn.QueryRow(ctx, "SELECT count(*) FROM chats WHERE title = $1", title).Scan(&n) + if err != nil { + t.Fatalf("count chats: %v", err) + } + if n != 0 { + t.Fatalf("expected no chat rows after failed creation, found %d", n) + } +} diff --git a/student-tests/contract_test.go b/student-tests/contract_test.go new file mode 100644 index 00000000..2aea9f28 --- /dev/null +++ b/student-tests/contract_test.go @@ -0,0 +1,134 @@ +//go:build contract + +package studenttests_test + +import ( + "encoding/json" + "net/http" + "net/url" + "strconv" + "testing" + + "mtusi2026-messenger/internal/dto" +) + +func TestInvalidJSON(t *testing.T) { + resp := doRequest(t, http.MethodPost, "/api/v1/users", "", []byte(`{"username": "broken",`)) + requireStatus(t, resp, http.StatusBadRequest) + + var apiErr dto.ErrorResponse + mustDecode(t, resp, &apiErr) + + if apiErr.Error.Code != dto.ErrorCodeInvalidRequest { + t.Errorf("expected code %q, got %q", dto.ErrorCodeInvalidRequest, apiErr.Error.Code) + } +} + +func TestForeignChat(t *testing.T) { + user1 := createUser(t) + user2 := createUser(t) + user3 := createUser(t) + + chat := createChat(t, user1, user1.ID, user2.ID) + + resp := doRequest(t, http.MethodGet, "/api/v1/chats/"+chat.ID.String(), user3.Token, nil) + requireStatus(t, resp, http.StatusNotFound) + + resp = sendMessage(t, user3, chat.ID, "should not land") + requireStatus(t, resp, http.StatusNotFound) +} + +func TestEmptyMessage(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + for _, text := range []string{"", " ", "\t\n"} { + resp := sendMessage(t, user, chat.ID, text) + requireStatus(t, resp, http.StatusBadRequest) + } +} + +func TestDuplicateUsername(t *testing.T) { + user := createUser(t) + + body, err := json.Marshal(map[string]string{ + "username": user.Username, + "display_name": "Someone else", + "password": testPassword, + }) + if err != nil { + t.Fatalf("marshal body: %v", err) + } + + resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body) + requireStatus(t, resp, http.StatusConflict) + + var apiErr dto.ErrorResponse + mustDecode(t, resp, &apiErr) + + if apiErr.Error.Code != dto.ErrorCodeConflict { + t.Errorf("expected code %q, got %q", dto.ErrorCodeConflict, apiErr.Error.Code) + } +} + +func TestPagination(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + const total = 25 + const pageSize = 4 + + sent := make(map[string]bool, total) + for i := 0; i < total; i++ { + resp := sendMessage(t, user, chat.ID, "msg") + requireStatus(t, resp, http.StatusCreated) + + var msg dto.MessageResponse + mustDecode(t, resp, &msg) + sent[msg.ID.String()] = true + } + + seen := make(map[string]bool, total) + cursor := "" + pages := 0 + + for { + path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=" + strconv.Itoa(pageSize) + if cursor != "" { + path += "&cursor=" + url.QueryEscape(cursor) + } + + resp := doRequest(t, http.MethodGet, path, user.Token, nil) + requireStatus(t, resp, http.StatusOK) + + var page dto.MessagePageResponse + mustDecode(t, resp, &page) + pages++ + + for _, msg := range page.Items { + id := msg.ID.String() + if seen[id] { + t.Fatalf("duplicate message id across pages: %s", id) + } + seen[id] = true + } + + if page.NextCursor == nil { + break + } + cursor = *page.NextCursor + + if pages > total { + t.Fatalf("too many pages: got %d, expected at most %d", pages, total) + } + } + + if len(seen) != total { + t.Fatalf("expected %d unique messages across all pages, got %d", total, len(seen)) + } + for id := range sent { + if !seen[id] { + t.Fatalf("message %s sent but never seen while paginating", id) + } + } +} diff --git a/student-tests/dependency_failure_test.go b/student-tests/dependency_failure_test.go new file mode 100644 index 00000000..59d7ba1c --- /dev/null +++ b/student-tests/dependency_failure_test.go @@ -0,0 +1,156 @@ +//go:build failure + +package studenttests_test + +import ( + "bytes" + "io" + "net/http" + "os/exec" + "testing" + "time" + + "mtusi2026-messenger/internal/dto" +) + +func compose(t *testing.T, args ...string) { + t.Helper() + + cmd := exec.Command("docker", append([]string{"compose"}, args...)...) + cmd.Dir = ".." + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("docker compose %v: %v\n%s", args, err, out) + } +} + +func stopService(t *testing.T, name string) { + t.Helper() + + compose(t, "stop", name) + t.Cleanup(func() { + compose(t, "start", name) + waitReady(t) + }) +} + +func waitReady(t *testing.T) { + t.Helper() + + deadline := time.Now().Add(60 * time.Second) + for time.Now().Before(deadline) { + resp, err := httpClient.Get(*baseURL + "/health/ready") + if err == nil { + resp.Body.Close() + if resp.StatusCode == http.StatusOK { + return + } + } + time.Sleep(500 * time.Millisecond) + } + t.Fatal("service did not become ready in 60s") +} + +func TestRedisDown(t *testing.T) { + user := createUser(t) + + stopService(t, "redis") + + // настоящий токен + resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + resp.Body.Close() + + // выдуманный токен + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() + + // без токена + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() +} + +func TestDatabaseDown(t *testing.T) { + user := createUser(t) // токен ещё не использован, ключа в Redis нет + + stopService(t, "postgres") + + // ключа в кэше нет, проверить сессию негде + resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusServiceUnavailable) + resp.Body.Close() + + // выдуманный токен + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil) + requireStatus(t, resp, http.StatusServiceUnavailable) + resp.Body.Close() + + // без токена + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() +} + +func TestS3Down(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + original := makePNG(t, 32, 32) + att := uploadPNG(t, user, chat.ID) + + stopService(t, "s3") + for _, path := range []string{"/health/ready", "/api/v1/attachments/" + att.ID.String() + "/content"} { + resp := doRequest(t, http.MethodGet, path, user.Token, nil) + requireStatus(t, resp, http.StatusServiceUnavailable) + requireErrorCode(t, resp, dto.ErrorCodeUnavailable) + } + resp := uploadAttachment(t, user, chat.ID, "outage.png", "image/png", original) + requireStatus(t, resp, http.StatusServiceUnavailable) + requireErrorCode(t, resp, dto.ErrorCodeUnavailable) + resp = doRequest(t, http.MethodGet, "/health/live", "", nil) + requireStatus(t, resp, http.StatusOK) + resp.Body.Close() + + compose(t, "start", "s3") + waitReady(t) + deadline := time.Now().Add(60 * time.Second) + downloaded, uploaded := false, false + for time.Now().Before(deadline) && (!downloaded || !uploaded) { + if !downloaded { + req, err := http.NewRequest(http.MethodGet, *baseURL+"/api/v1/attachments/"+att.ID.String()+"/content", nil) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", "Bearer "+user.Token) + response, err := httpClient.Do(req) + if err == nil { + data, readErr := io.ReadAll(response.Body) + response.Body.Close() + if response.StatusCode == http.StatusOK && readErr == nil { + if !bytes.Equal(data, original) { + t.Fatal("original changed across S3 outage") + } + downloaded = true + } else if response.StatusCode != http.StatusServiceUnavailable && response.StatusCode != http.StatusBadGateway && response.StatusCode != http.StatusGatewayTimeout { + t.Fatalf("unexpected download recovery status: %d", response.StatusCode) + } + } + } + if !uploaded { + response := uploadAttachment(t, user, chat.ID, "recovery.png", "image/png", original) + status := response.StatusCode + response.Body.Close() + if status == http.StatusCreated { + uploaded = true + } else if status != http.StatusServiceUnavailable { + t.Fatalf("unexpected upload recovery status: %d", status) + } + } + if !downloaded || !uploaded { + time.Sleep(500 * time.Millisecond) + } + } + if !downloaded || !uploaded { + t.Fatalf("S3 did not recover in 60s: download=%t upload=%t", downloaded, uploaded) + } +} diff --git a/student-tests/helpers_test.go b/student-tests/helpers_test.go new file mode 100644 index 00000000..91290f2a --- /dev/null +++ b/student-tests/helpers_test.go @@ -0,0 +1,236 @@ +package studenttests_test + +import ( + "bytes" + "encoding/json" + "flag" + "image" + "image/color" + "image/png" + "io" + "net/http" + "strings" + "testing" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +var baseURL = flag.String("base-url", "http://127.0.0.1:8080", "base URL of the running server") + +var httpClient = &http.Client{ + Timeout: 10 * time.Second, + Transport: &http.Transport{ + MaxIdleConns: 200, + IdleConnTimeout: 30 * time.Second, + MaxIdleConnsPerHost: 200, + MaxConnsPerHost: 200, + }, +} + +type testUser struct { + dto.UserResponse + Token string +} + +const testPassword = "correct-horse-battery" + +func doRequest(t *testing.T, method, path, token string, body []byte) *http.Response { + t.Helper() + + req, err := http.NewRequest(method, *baseURL+path, bytes.NewReader(body)) + if err != nil { + t.Fatalf("build request: %v", err) + } + + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + + if token != "" { + req.Header.Set("Authorization", "Bearer "+token) + } + + resp, err := httpClient.Do(req) + if err != nil { + t.Fatalf("%s %s: request failed: %v", method, path, err) + } + + return resp +} + +func mustDecode(t *testing.T, resp *http.Response, dst any) { + t.Helper() + defer resp.Body.Close() + + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("read body: %v", err) + } + + if err := json.Unmarshal(data, dst); err != nil { + t.Fatalf("decode body %q: %v", data, err) + } +} + +func requireStatus(t *testing.T, resp *http.Response, expected int) { + t.Helper() + + if resp.StatusCode != expected { + data, _ := io.ReadAll(resp.Body) + resp.Body.Close() + + t.Fatalf( + "expected status %d, got %d, body: %s", + expected, + resp.StatusCode, + data, + ) + } + + if resp.Header.Get("X-Request-Id") == "" { + t.Errorf("missing X-Request-Id header") + } +} + +func createUser(t *testing.T) testUser { + t.Helper() + + username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12] + + body, err := json.Marshal(map[string]string{ + "username": username, + "display_name": "Test " + username, + "password": testPassword, + }) + if err != nil { + t.Fatalf("marshal user: %v", err) + } + + resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body) + requireStatus(t, resp, http.StatusCreated) + + var u dto.UserResponse + mustDecode(t, resp, &u) + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/auth/sessions", + nil, + ) + if err != nil { + t.Fatalf("build login request: %v", err) + } + req.SetBasicAuth(username, testPassword) + + resp, err = httpClient.Do(req) + if err != nil { + t.Fatalf("login request failed: %v", err) + } + requireStatus(t, resp, http.StatusCreated) + + var session dto.SessionResponse + mustDecode(t, resp, &session) + + return testUser{UserResponse: u, Token: session.Token} +} + +func createChat( + t *testing.T, + creator testUser, + memberIDs ...uuid.UUID, +) dto.ChatResponse { + t.Helper() + + body, err := json.Marshal(map[string]any{ + "title": "Test chat " + uuid.NewString()[:8], + "member_ids": memberIDs, + }) + if err != nil { + t.Fatalf("marshal chat: %v", err) + } + + resp := doRequest( + t, + http.MethodPost, + "/api/v1/chats", + creator.Token, + body, + ) + + requireStatus(t, resp, http.StatusCreated) + + var c dto.ChatResponse + mustDecode(t, resp, &c) + + return c +} + +func sendMessage( + t *testing.T, + actor testUser, + chatID uuid.UUID, + text string, +) *http.Response { + t.Helper() + + resp, err := sendLoadMessage(actor, chatID, text) + if err != nil { + t.Fatalf("send message: %v", err) + } + + return resp +} + +func sendLoadMessage( + actor testUser, + chatID uuid.UUID, + text string, +) (*http.Response, error) { + body, err := json.Marshal(map[string]string{ + "text": text, + }) + if err != nil { + return nil, err + } + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/chats/"+chatID.String()+"/messages", + bytes.NewReader(body), + ) + if err != nil { + return nil, err + } + + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+actor.Token) + req.Header.Set("Idempotency-Key", uuid.NewString()) + + return httpClient.Do(req) +} + +func makePNG(t *testing.T, width, height int) []byte { + t.Helper() + + img := image.NewRGBA(image.Rect(0, 0, width, height)) + for y := 0; y < height; y++ { + for x := 0; x < width; x++ { + img.Set(x, y, color.RGBA{ + R: uint8((x * 7) % 256), + G: uint8((y * 13) % 256), + B: uint8((x + y) % 256), + A: 255, + }) + } + } + + var buf bytes.Buffer + if err := png.Encode(&buf, img); err != nil { + t.Fatalf("encode png: %v", err) + } + + return buf.Bytes() +} diff --git a/student-tests/idempotency_test.go b/student-tests/idempotency_test.go new file mode 100644 index 00000000..30d42675 --- /dev/null +++ b/student-tests/idempotency_test.go @@ -0,0 +1,169 @@ +//go:build race + +package studenttests_test + +import ( + "bytes" + "encoding/json" + "io" + "net/http" + "net/url" + "sync" + "testing" + + "github.com/google/uuid" +) + +const ( + concurrentRequests = 20 + concurrentRounds = 5 +) + +type keyedResult struct { + status int + instance string + body []byte + err error +} + +func postWithKey(actor testUser, chatID uuid.UUID, key, text string) keyedResult { + body, err := json.Marshal(map[string]string{"text": text}) + if err != nil { + return keyedResult{err: err} + } + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/chats/"+chatID.String()+"/messages", + bytes.NewReader(body), + ) + if err != nil { + return keyedResult{err: err} + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+actor.Token) + req.Header.Set("Idempotency-Key", key) + + resp, err := httpClient.Do(req) + if err != nil { + return keyedResult{err: err} + } + defer resp.Body.Close() + + data, err := io.ReadAll(resp.Body) + return keyedResult{ + status: resp.StatusCode, + instance: resp.Header.Get("X-Instance-Id"), + body: data, + err: err, + } +} + +func TestConcurrentIdempotencyAcrossReplicas(t *testing.T) { + alice := createUser(t) + bob := createUser(t) + chat := createChat(t, alice, alice.ID, bob.ID) + + instances := map[string]struct{}{} + + for round := 0; round < concurrentRounds; round++ { + key := uuid.NewString() + text := "concurrent " + key + + results := make([]keyedResult, concurrentRequests) + start := make(chan struct{}) + var wg sync.WaitGroup + + for i := range results { + wg.Add(1) + go func(i int) { + defer wg.Done() + <-start + results[i] = postWithKey(alice, chat.ID, key, text) + }(i) + } + close(start) + wg.Wait() + + createdIDs := map[string]struct{}{} + succeeded := 0 + + for i, r := range results { + if r.err != nil { + t.Fatalf("round %d, request %d: %v", round, i, r.err) + } + if r.instance != "" { + instances[r.instance] = struct{}{} + } + + switch r.status { + case http.StatusOK, http.StatusCreated: + succeeded++ + var m struct { + ID string `json:"id"` + } + if err := json.Unmarshal(r.body, &m); err != nil || m.ID == "" { + t.Fatalf("round %d: bad success body %q: %v", round, r.body, err) + } + createdIDs[m.ID] = struct{}{} + case http.StatusConflict: + default: + t.Errorf("round %d, request %d: unexpected status %d, body: %s", + round, i, r.status, r.body) + } + } + + if succeeded == 0 { + t.Fatalf("round %d: no request succeeded", round) + } + if len(createdIDs) != 1 { + t.Fatalf("round %d: responses returned %d different message ids, want 1: %v", + round, len(createdIDs), createdIDs) + } + + if got := countMessagesWithText(t, bob, chat.ID, text); got != 1 { + t.Fatalf("round %d: %d messages with text %q in history, want exactly 1", + round, got, text) + } + } + + if len(instances) < 2 { + t.Fatalf("requests were served by %d replica(s) %v, need at least 2", + len(instances), instances) + } + t.Logf("served by replicas: %v", instances) +} + +func countMessagesWithText(t *testing.T, actor testUser, chatID uuid.UUID, text string) int { + t.Helper() + + count := 0 + path := "/api/v1/chats/" + chatID.String() + "/messages?limit=100" + + for page := 0; page < 100; page++ { + resp := doRequest(t, http.MethodGet, path, actor.Token, nil) + requireStatus(t, resp, http.StatusOK) + + var body struct { + Items []struct { + Text string `json:"text"` + } `json:"items"` + NextCursor *string `json:"next_cursor"` + } + mustDecode(t, resp, &body) + + for _, m := range body.Items { + if m.Text == text { + count++ + } + } + if body.NextCursor == nil { + return count + } + path = "/api/v1/chats/" + chatID.String() + + "/messages?limit=100&cursor=" + url.QueryEscape(*body.NextCursor) + } + + t.Fatalf("history pagination exceeded safety bound") + return 0 +} diff --git a/student-tests/load_action_test.go b/student-tests/load_action_test.go new file mode 100644 index 00000000..1e387472 --- /dev/null +++ b/student-tests/load_action_test.go @@ -0,0 +1,150 @@ +//go:build load && action + +package studenttests_test + +import ( + "flag" + "io" + "net/http" + "os" + "os/exec" + "strings" + "sync" + "testing" + "time" +) + +var ( + actionScript = flag.String("action", "", "script to run during the load (e.g. scripts/stop-one.sh)") + actionAt = flag.Duration("action-at", 10*time.Second, "when to run the action, from test start") + replica = flag.Int("replica", 1, "which api replica to stop (1-based)") +) + +func resolveReplica(t *testing.T, n int) string { + t.Helper() + out, err := exec.Command("docker", "compose", "ps", "-q", "api").Output() + if err != nil { + t.Fatalf("docker compose ps: %v", err) + } + ids := strings.Fields(string(out)) + if n < 1 || n > len(ids) { + t.Fatalf("replica %d requested, but %d api containers found", n, len(ids)) + } + return ids[n-1] +} + +func actionCommand(path string) *exec.Cmd { + if strings.HasSuffix(path, ".sh") { + return exec.Command("sh", path) + } + return exec.Command(path) +} + +func TestLoadWithAction(t *testing.T) { + if *actionScript == "" { + t.Skip("-action is not set") + } + + if *actionAt+10*time.Second > *duration { + t.Fatalf("-duration (%s) must exceed -action-at (%s) by at least 10s", *duration, *actionAt) + } + + user1 := createUser(t) + user2 := createUser(t) + chat := createChat(t, user1, user1.ID, user2.ID) + + type sample struct { + at time.Duration + ok bool + } + var ( + mu sync.Mutex + samples []sample + wg sync.WaitGroup + ) + + targetID := resolveReplica(t, *replica) + start := time.Now() + deadline := start.Add(*duration) + interval := time.Second / time.Duration(*rate) + + for w := 0; w < *workers; w++ { + wg.Add(1) + go func(id int) { + defer wg.Done() + actor := user1 + if id%2 == 1 { + actor = user2 + } + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + <-ticker.C + if time.Now().After(deadline) { + return + } + resp, err := sendLoadMessage(actor, chat.ID, "load-msg") + ok := err == nil && resp.StatusCode == http.StatusCreated + if err == nil { + io.Copy(io.Discard, resp.Body) + resp.Body.Close() + } + mu.Lock() + samples = append(samples, sample{time.Since(start), ok}) + mu.Unlock() + } + }(w) + } + + var actionStart, actionEnd time.Duration + wg.Add(1) + go func() { + defer wg.Done() + time.Sleep(*actionAt) + actionStart = time.Since(start) + cmd := actionCommand(*actionScript) + cmd.Env = append(os.Environ(), "TARGET_INSTANCE_ID="+targetID) + out, err := cmd.CombinedOutput() + actionEnd = time.Since(start) + if err != nil { + t.Errorf("action failed: %v\n%s", err, out) + } + }() + + wg.Wait() + elapsed := time.Since(start) + + seconds := int(elapsed.Seconds()) + 1 + okBySec := make([]int, seconds) + errBySec := make([]int, seconds) + var okTotal, errTotal int + var lastErr time.Duration + + for _, s := range samples { + sec := int(s.at.Seconds()) + if s.ok { + okBySec[sec]++ + okTotal++ + } else { + errBySec[sec]++ + errTotal++ + if s.at > lastErr { + lastErr = s.at + } + } + } + + for i := 0; i < seconds; i++ { + t.Logf("t=%2ds ok=%4d err=%3d", i, okBySec[i], errBySec[i]) + } + + t.Logf("action: started at %.2fs, finished at %.2fs", actionStart.Seconds(), actionEnd.Seconds()) + t.Logf("total ok=%d errors=%d, successful RPS=%.2f", okTotal, errTotal, float64(okTotal)/elapsed.Seconds()) + + if errTotal == 0 || lastErr < actionStart { + t.Logf("recovery time: 0s (no errors after action start)") + } else { + t.Logf("recovery time: %.2fs (last error at %.2fs)", (lastErr - actionStart).Seconds(), lastErr.Seconds()) + } +} diff --git a/student-tests/load_test.go b/student-tests/load_test.go new file mode 100644 index 00000000..a4a0902e --- /dev/null +++ b/student-tests/load_test.go @@ -0,0 +1,162 @@ +//go:build load + +package studenttests_test + +import ( + "flag" + "fmt" + "io" + "net/http" + "os" + "sort" + "sync" + "sync/atomic" + "testing" + "time" +) + +var ( + workers = flag.Int("workers", 20, "number of concurrent workers") + duration = flag.Duration("duration", 5*time.Second, "test duration") + rate = flag.Int("rate", 20, "maximum requests per second per worker") + csvPath = flag.String("csv", "", "append result row to this CSV file") + label = flag.String("label", "", "configuration label for CSV row") +) + +func TestLoad(t *testing.T) { + var ( + statuses = make(map[int]int64) + requestErrors int64 + latencies []time.Duration + statusMu sync.Mutex + latencyMu sync.Mutex + wg sync.WaitGroup + ) + + user1 := createUser(t) + user2 := createUser(t) + chat := createChat(t, user1, user1.ID, user2.ID) + + start := time.Now() + deadline := start.Add(*duration) + + interval := time.Second / time.Duration(*rate) + + for worker := 0; worker < *workers; worker++ { + wg.Add(1) + + go func(workerID int) { + defer wg.Done() + + actor := user1 + if workerID%2 == 1 { + actor = user2 + } + + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for time.Now().Before(deadline) { + <-ticker.C + + if time.Now().After(deadline) { + return + } + + requestStart := time.Now() + + resp, err := sendLoadMessage( + actor, + chat.ID, + "load-msg", + ) + + latency := time.Since(requestStart) + + if err != nil { + if atomic.AddInt64(&requestErrors, 1) == 1 { + t.Logf("first transport error: %v", err) + } + continue + } + + statusMu.Lock() + statuses[resp.StatusCode]++ + statusMu.Unlock() + + if resp.StatusCode == http.StatusCreated { + latencyMu.Lock() + latencies = append(latencies, latency) + latencyMu.Unlock() + } + + io.Copy(io.Discard, resp.Body) + resp.Body.Close() + } + }(worker) + } + + wg.Wait() + + elapsed := time.Since(start) + + var total int64 + for _, count := range statuses { + total += count + } + total += requestErrors + + t.Logf("duration: %.3fs", elapsed.Seconds()) + t.Logf("workers: %d", *workers) + t.Logf("rate per worker: %d req/s", *rate) + t.Logf("target rate: %d req/s", *workers**rate) + t.Logf("total requests: %d", total) + + for status, count := range statuses { + t.Logf("HTTP %d: %d", status, count) + } + + t.Logf("request errors: %d", requestErrors) + + successful := statuses[http.StatusCreated] + + t.Logf("successful RPS: %.2f", + float64(successful)/elapsed.Seconds(), + ) + + if len(latencies) > 0 { + sort.Slice(latencies, func(i, j int) bool { + return latencies[i] < latencies[j] + }) + + t.Logf("successful latency p50: %s", percentile(latencies, 0.50)) + t.Logf("successful latency p95: %s", percentile(latencies, 0.95)) + t.Logf("successful latency p99: %s", percentile(latencies, 0.99)) + } + + if *csvPath != "" { + var p50, p95, p99 time.Duration + if len(latencies) > 0 { + p50 = percentile(latencies, 0.50) + p95 = percentile(latencies, 0.95) + p99 = percentile(latencies, 0.99) + } + f, err := os.OpenFile(*csvPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) + if err != nil { + t.Fatalf("open csv: %v", err) + } + defer f.Close() + fmt.Fprintf(f, "%s,%d,%d,%d,%d,%d,%d,%.2f,%.1f,%.1f,%.1f\n", + *label, *workers, *rate, *workers**rate, + successful, total-successful-requestErrors, requestErrors, + float64(successful)/elapsed.Seconds(), + float64(p50.Microseconds())/1000, + float64(p95.Microseconds())/1000, + float64(p99.Microseconds())/1000) + } +} + +func percentile(values []time.Duration, p float64) time.Duration { + index := int(float64(len(values)-1) * p) + return values[index] +} diff --git a/student-tests/race_test.go b/student-tests/race_test.go new file mode 100644 index 00000000..3a4384dc --- /dev/null +++ b/student-tests/race_test.go @@ -0,0 +1,100 @@ +//go:build race + +package studenttests_test + +import ( + "net/http" + "sync" + "testing" + + "mtusi2026-messenger/internal/dto" +) + +func TestConcurrentMessages(t *testing.T) { + const clients = 10 + const messagesPerClient = 10 + const total = clients * messagesPerClient + + user1 := createUser(t) + user2 := createUser(t) + chat := createChat(t, user1, user1.ID, user2.ID) + + var wg sync.WaitGroup + var mu sync.Mutex + sentIDs := make(map[string]bool, total) + + start := make(chan struct{}) + + for worker := 0; worker < clients; worker++ { + wg.Add(1) + + go func(workerID int) { + defer wg.Done() + + actor := user1 + if workerID%2 == 1 { + actor = user2 + } + + <-start + + for i := 0; i < messagesPerClient; i++ { + resp := sendMessage(t, actor, chat.ID, "race-msg") + if resp.StatusCode != http.StatusCreated { + t.Errorf("worker %d msg %d: expected 201, got %d", workerID, i, resp.StatusCode) + resp.Body.Close() + continue + } + + var m dto.MessageResponse + mustDecode(t, resp, &m) + + mu.Lock() + sentIDs[m.ID.String()] = true + mu.Unlock() + } + }(worker) + } + + close(start) + wg.Wait() + + if t.Failed() { + t.Fatal("one or more send requests failed, see errors above") + } + + if len(sentIDs) != total { + t.Fatalf("expected %d successful sends, got %d unique ids", total, len(sentIDs)) + } + + seen := make(map[string]bool, total) + + path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=100" + resp := doRequest(t, http.MethodGet, path, user1.Token, nil) + requireStatus(t, resp, http.StatusOK) + + var page dto.MessagePageResponse + mustDecode(t, resp, &page) + + if page.NextCursor != nil { + t.Fatalf("expected next_cursor to be nil, history may contain more than %d messages", total) + } + + for _, msg := range page.Items { + id := msg.ID.String() + if seen[id] { + t.Fatalf("duplicate message id in history: %s", id) + } + if !sentIDs[id] { + t.Fatalf("message %s in history was never sent by this test", id) + } + seen[id] = true + } + + if len(seen) != total { + t.Fatalf("expected exactly %d unique messages in history, got %d", total, len(seen)) + } + + t.Logf("PASS: %d concurrent clients sent %d messages, exactly %d unique messages persisted", + clients, total, len(seen)) +} diff --git a/student-tests/reconcile_test.go b/student-tests/reconcile_test.go new file mode 100644 index 00000000..a95234c4 --- /dev/null +++ b/student-tests/reconcile_test.go @@ -0,0 +1,169 @@ +//go:build reconcile + +package studenttests_test + +import ( + "bytes" + "context" + "encoding/json" + "io" + "net/http" + "os" + "os/exec" + "slices" + "strings" + "testing" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + + "mtusi2026-messenger/internal/reconcile" +) + +func reconcileDB(t *testing.T) *pgx.Conn { + t.Helper() + secret, err := os.ReadFile("../secrets/test_database_url.txt") + if err != nil { + t.Fatalf("read test database URL: %v", err) + } + conn, err := pgx.Connect(context.Background(), strings.TrimSpace(string(secret))) + if err != nil { + t.Fatalf("connect to test database: %v", err) + } + t.Cleanup(func() { conn.Close(context.Background()) }) + return conn +} + +func reconcileSQL(t *testing.T, conn *pgx.Conn, query string, args ...any) { + t.Helper() + if _, err := conn.Exec(context.Background(), query, args...); err != nil { + t.Fatalf("prepare/check reconcile fixture: %v", err) + } +} + +func runReconcile(t *testing.T, dryRun bool, grace string) reconcile.Report { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + dry := "false" + if dryRun { + dry = "true" + } + cmd := exec.CommandContext(ctx, "docker", "compose", "--env-file", ".env", "run", "--rm", "--no-deps", "reconcile", "-json", "-dry-run="+dry, "-grace="+grace) + cmd.Dir = ".." + var stderr bytes.Buffer + cmd.Stderr = &stderr + output, err := cmd.Output() + if err != nil { + t.Fatalf("run reconciler: %v\n%s", err, stderr.String()) + } + var report reconcile.Report + if err := json.Unmarshal(output, &report); err != nil { + t.Fatalf("decode reconcile report: %v\n%s", err, output) + } + t.Logf("dry_run=%t objects=%d rows=%d list_pages=%d duration_ms=%d orphan=%d missing=%d stale=%d skipped_fresh=%d skipped_referenced=%d deleted_objects=%d deleted_rows=%d marked_failed=%d errors=%v", report.DryRun, report.ScannedObjects, report.ScannedRows, report.ListPages, report.DurationMS, len(report.OrphanObjects), len(report.MissingAttachments), len(report.StaleUploads), report.SkippedFresh, report.SkippedReferenced, report.DeletedObjects, report.DeletedRows, report.MarkedFailed, report.Errors) + if len(report.Errors) != 0 { + t.Fatal("reconciler reported errors") + } + return report +} + +func TestReconcileRepair(t *testing.T) { + conn := reconcileDB(t) + user := createUser(t) + chat := createChat(t, user, user.ID) + att := uploadPNG(t, user, chat.ID) + var originalKey string + if err := conn.QueryRow(context.Background(), "SELECT s3_key FROM attachments WHERE id=$1", att.ID).Scan(&originalKey); err != nil { + t.Fatal(err) + } + // Simulate lost metadata for the original object and metadata pointing at a missing object. + reconcileSQL(t, conn, "UPDATE attachments SET s3_key=$2 WHERE id=$1", att.ID, "chats/reconcile-missing/"+uuid.NewString()) + // Only this experiment uses a shortened grace period, to avoid waiting an hour. + time.Sleep(1100 * time.Millisecond) + dry := runReconcile(t, true, "1s") + if !slices.Contains(dry.OrphanObjects, originalKey) || !slices.Contains(dry.MissingAttachments, att.ID) { + t.Fatal("dry-run did not detect both injected inconsistencies") + } + if dry.DeletedObjects != 0 || dry.DeletedRows != 0 || dry.MarkedFailed != 0 { + t.Fatal("dry-run changed data") + } + var status, code string + if err := conn.QueryRow(context.Background(), "SELECT status::text FROM attachments WHERE id=$1", att.ID).Scan(&status); err != nil { + t.Fatal(err) + } + if status != "ready" { + t.Fatalf("dry-run changed status: %s", status) + } + repair := runReconcile(t, false, "1s") + if repair.DeletedObjects < 1 || repair.MarkedFailed < 1 { + t.Fatal("repair did not apply fixes") + } + if err := conn.QueryRow(context.Background(), "SELECT status::text, error_code FROM attachments WHERE id=$1", att.ID).Scan(&status, &code); err != nil { + t.Fatal(err) + } + if status != "failed" || code != "object_missing" { + t.Fatalf("unexpected repaired state: %s %s", status, code) + } + again := runReconcile(t, false, "1s") + if slices.Contains(again.OrphanObjects, originalKey) || slices.Contains(again.MissingAttachments, att.ID) { + t.Fatal("fixture still requires repair on repeat") + } + if again.DeletedObjects != 0 || again.DeletedRows != 0 || again.MarkedFailed != 0 { + t.Fatal("repeat repair changed data; run on an idle test stand") + } + t.Log("PASS: dry-run preserved data; orphan deleted; missing marked failed; repeat made no changes") +} + +func TestReconcileSafety(t *testing.T) { + conn := reconcileDB(t) + user := createUser(t) + chat := createChat(t, user, user.ID) + fresh := uploadPNG(t, user, chat.ID) + used := uploadPNG(t, user, chat.ID) + resp := postMessage(t, user, chat.ID, "", []uuid.UUID{used.ID}) + requireStatus(t, resp, http.StatusCreated) + resp.Body.Close() + // Exercise both grace-period protection and protection of referenced queued uploads. + reconcileSQL(t, conn, "UPDATE attachments SET status='queued' WHERE id=$1", fresh.ID) + reconcileSQL(t, conn, "UPDATE attachments SET status='queued', created_at=now()-interval '2 hours' WHERE id=$1", used.ID) + t.Cleanup(func() { + if _, err := conn.Exec(context.Background(), "UPDATE attachments SET status='ready' WHERE id=ANY($1::uuid[])", []uuid.UUID{fresh.ID, used.ID}); err != nil { + t.Errorf("restore fixture status: %v", err) + } + }) + for _, dryRun := range []bool{true, false} { + report := runReconcile(t, dryRun, "1h") + if report.SkippedFresh < 1 || report.SkippedReferenced < 1 { + t.Fatal("fresh/referenced protection was not exercised") + } + for _, att := range []uuid.UUID{fresh.ID, used.ID} { + var status string + if err := conn.QueryRow(context.Background(), "SELECT status::text FROM attachments WHERE id=$1", att).Scan(&status); err != nil { + t.Fatal(err) + } + if status != "queued" { + t.Fatalf("protected fixture changed status: %s", status) + } + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.String()+"/content", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + data, err := io.ReadAll(resp.Body) + resp.Body.Close() + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(data, makePNG(t, 32, 32)) { + t.Fatal("protected original changed") + } + } + } + t.Log("PASS: fresh and old referenced uploads preserved, originals unchanged") +} + +func TestReconcileCost(t *testing.T) { + for i := 1; i <= 3; i++ { + t.Logf("scan %d/3", i) + runReconcile(t, true, "1h") + } +} diff --git a/student-tests/registration_race_test.go b/student-tests/registration_race_test.go new file mode 100644 index 00000000..1f49203f --- /dev/null +++ b/student-tests/registration_race_test.go @@ -0,0 +1,77 @@ +//go:build race + +package studenttests_test + +import ( + "bytes" + "encoding/json" + "net/http" + "strings" + "sync" + "testing" + + "github.com/google/uuid" +) + +func TestConcurrentRegistration(t *testing.T) { + const workers = 20 + + username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12] + + body, err := json.Marshal(map[string]string{ + "username": username, + "display_name": "Racer", + "password": testPassword, + }) + if err != nil { + t.Fatalf("marshal body: %v", err) + } + + start := make(chan struct{}) + statuses := make(chan int, workers) + + var wg sync.WaitGroup + for i := 0; i < workers; i++ { + wg.Add(1) + go func() { + defer wg.Done() + <-start + + req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/users", bytes.NewReader(body)) + if err != nil { + t.Errorf("build request: %v", err) + return + } + req.Header.Set("Content-Type", "application/json") + + resp, err := httpClient.Do(req) + if err != nil { + t.Errorf("request failed: %v", err) + return + } + defer resp.Body.Close() + + statuses <- resp.StatusCode + }() + } + + close(start) + wg.Wait() + close(statuses) + + created, conflict := 0, 0 + for s := range statuses { + switch s { + case http.StatusCreated: + created++ + case http.StatusConflict: + conflict++ + default: + t.Errorf("unexpected status %d", s) + } + } + + if created != 1 || conflict != workers-1 { + t.Fatalf("expected 1 created and %d conflict, got %d created and %d conflict", workers-1, created, conflict) + } +} diff --git a/student-tests/session_expiry_test.go b/student-tests/session_expiry_test.go new file mode 100644 index 00000000..99eb098c --- /dev/null +++ b/student-tests/session_expiry_test.go @@ -0,0 +1,42 @@ +//go:build failure + +package studenttests_test + +import ( + "net/http" + "os/exec" + "testing" + "time" +) + +const shortTTLContainer = "api-short-ttl" +const shortTTLURL = "http://localhost:8081" + +func TestSessionExpiry(t *testing.T) { + _ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run() + + compose(t, "run", "-d", "--no-deps", "--name", shortTTLContainer, + "-e", "SESSION_TTL_SECONDS=3", + "-p", "127.0.0.1:8081:8080", "api") + t.Cleanup(func() { + _ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run() + }) + + old := *baseURL + *baseURL = shortTTLURL + t.Cleanup(func() { *baseURL = old }) + + waitReady(t) + + user := createUser(t) + + resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + resp.Body.Close() + + time.Sleep(4 * time.Second) + + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() +} diff --git a/student-tests/session_test.go b/student-tests/session_test.go new file mode 100644 index 00000000..d72097ef --- /dev/null +++ b/student-tests/session_test.go @@ -0,0 +1,58 @@ +//go:build contract + +package studenttests_test + +import ( + "net/http" + "testing" +) + +func basicLogin(t *testing.T, username, password string) *http.Response { + t.Helper() + + req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/auth/sessions", nil) + if err != nil { + t.Fatalf("build login request: %v", err) + } + req.SetBasicAuth(username, password) + + resp, err := httpClient.Do(req) + if err != nil { + t.Fatalf("login request failed: %v", err) + } + return resp +} + +func TestLoginWrongPassword(t *testing.T) { + user := createUser(t) + + resp := basicLogin(t, user.Username, "wrong-"+testPassword) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() + + resp = basicLogin(t, "no_such_user_"+user.Username, testPassword) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() +} + +func TestLogout(t *testing.T) { + user := createUser(t) + + resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + resp.Body.Close() + + resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil) + if resp.StatusCode >= 300 { + t.Fatalf("logout: unexpected status %d", resp.StatusCode) + } + resp.Body.Close() + + resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() + + resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil) + requireStatus(t, resp, http.StatusUnauthorized) + resp.Body.Close() +} diff --git a/student.mk b/student.mk new file mode 100644 index 00000000..6b2f745d --- /dev/null +++ b/student.mk @@ -0,0 +1,44 @@ +LOAD_ARGS = $(if $(LOAD_WORKERS),-workers=$(LOAD_WORKERS),) \ + $(if $(LOAD_DURATION),-duration=$(LOAD_DURATION),) \ + $(if $(LOAD_RATE),-rate=$(LOAD_RATE),) \ + $(if $(LOAD_CSV),-csv=$(LOAD_CSV),) \ + $(if $(LOAD_LABEL),-label=$(LOAD_LABEL),) +REPLICA ?= 1 +ACTION ?= stop-one.sh +ACTION_AT ?= 10s +DRY_RUN ?= true + +.PHONY: help-go contract-go race-go load-go failure-go load-action-go reconcile reconcile-test-go + +help-go: + @echo "contract-go: contract tests" + @echo "race-go: concurrency tests (-race)" + @echo "load-go: load test" + @echo "failure-go: dependency failure tests (stops redis/postgres/s3 containers)" + @echo "reconcile: attachment audit; DRY_RUN=false to repair" + +contract-go: + go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL) + +race-go: + go test -tags=race ./student-tests/... -race -v -args -base-url=$(BASE_URL) + +load-go: + go test -count=1 -tags=load ./student-tests/... -v -args -base-url=$(BASE_URL) $(LOAD_ARGS) + +failure-go: + go test -tags=failure ./student-tests/... -v -args -base-url=$(BASE_URL) + +load-action-go: + go test -tags=load,action ./student-tests/... -run TestLoadWithAction -v -args \ + -base-url=$(BASE_URL) $(LOAD_ARGS) \ + -replica=$(REPLICA) \ + -action=$(CURDIR)/scripts/$(ACTION) \ + -action-at=$(ACTION_AT) + +reconcile: + docker compose --env-file .env run --rm --no-deps reconcile -dry-run=$(DRY_RUN) + +reconcile-test-go: + docker compose --env-file .env build reconcile + go test -count=1 -tags=reconcile ./student-tests/... -v -args -base-url=$(BASE_URL) diff --git a/web/swagger/index.html b/web/swagger/index.html new file mode 100644 index 00000000..c498b1bf --- /dev/null +++ b/web/swagger/index.html @@ -0,0 +1,21 @@ + + + + + MTUSI Messenger API + + + +
+ + + + + \ No newline at end of file -- 2.54.0 From f2fc4b3e1f4a6aaaed0c90261ff33068df929182 Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 14:39:56 +0300 Subject: [PATCH 02/23] feat(attachments): add pipeline and outbox schema and queries --- db/migrations/00004_attachment_pipeline.sql | 54 ++++ db/queries/attachment_variants.sql | 28 ++ db/queries/attachments.sql | 99 +++++- db/queries/outbox.sql | 32 ++ internal/db/attachment_variants.sql.go | 105 +++++++ internal/db/attachments.sql.go | 332 +++++++++++++++++++- internal/db/models.go | 97 +++++- internal/db/outbox.sql.go | 108 +++++++ internal/service/attachment.go | 28 +- 9 files changed, 846 insertions(+), 37 deletions(-) create mode 100644 db/migrations/00004_attachment_pipeline.sql create mode 100644 db/queries/attachment_variants.sql create mode 100644 db/queries/outbox.sql create mode 100644 internal/db/attachment_variants.sql.go create mode 100644 internal/db/outbox.sql.go diff --git a/db/migrations/00004_attachment_pipeline.sql b/db/migrations/00004_attachment_pipeline.sql new file mode 100644 index 00000000..6ed6ec50 --- /dev/null +++ b/db/migrations/00004_attachment_pipeline.sql @@ -0,0 +1,54 @@ +-- +goose Up +CREATE TYPE attachment_variant_name AS ENUM ('thumbnail', 'crop', 'optimized'); + +ALTER TABLE attachments + ADD COLUMN staging_key text UNIQUE, + ADD COLUMN job_id uuid UNIQUE, + ADD COLUMN pipeline_version int NOT NULL DEFAULT 1 CHECK (pipeline_version > 0), + ADD COLUMN attempts int NOT NULL DEFAULT 0 CHECK (attempts >= 0), + ADD COLUMN width int CHECK (width > 0), + ADD COLUMN height int CHECK (height > 0), + ADD COLUMN lease_until timestamptz; + +CREATE INDEX idx_attachments_expired_lease ON attachments (lease_until) WHERE status = 'processing'; + +CREATE TABLE attachment_variants ( + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE CASCADE, + pipeline_version int NOT NULL CHECK (pipeline_version > 0), + variant attachment_variant_name NOT NULL, + s3_key text NOT NULL UNIQUE, + content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg', 'image/webp')), + size_bytes int NOT NULL CHECK (size_bytes > 0), + sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + width int NOT NULL CHECK (width > 0), + height int NOT NULL CHECK (height > 0), + PRIMARY KEY (attachment_id, pipeline_version, variant) +); + +CREATE TABLE outbox ( + id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + job_id uuid NOT NULL REFERENCES attachments (job_id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE CASCADE, + pipeline_version int NOT NULL CHECK (pipeline_version > 0), + attempt int NOT NULL CHECK (attempt > 0), + created_at timestamptz NOT NULL DEFAULT now(), + available_at timestamptz NOT NULL DEFAULT now(), + published_at timestamptz, + UNIQUE (job_id, attempt) +); + +CREATE INDEX idx_outbox_pending ON outbox (available_at, id) WHERE published_at IS NULL; + +-- +goose Down +DROP TABLE outbox; +DROP TABLE attachment_variants; +DROP TYPE attachment_variant_name; +DROP INDEX idx_attachments_expired_lease; +ALTER TABLE attachments + DROP COLUMN height, + DROP COLUMN width, + DROP COLUMN lease_until, + DROP COLUMN attempts, + DROP COLUMN pipeline_version, + DROP COLUMN job_id, + DROP COLUMN staging_key; diff --git a/db/queries/attachment_variants.sql b/db/queries/attachment_variants.sql new file mode 100644 index 00000000..6b38542f --- /dev/null +++ b/db/queries/attachment_variants.sql @@ -0,0 +1,28 @@ +-- name: CreateAttachmentVariant :exec +INSERT INTO attachment_variants ( + attachment_id, + pipeline_version, + variant, + s3_key, + content_type, + size_bytes, + width, + height, + sha256 +) VALUES ( + sqlc.arg(attachment_id), + sqlc.arg(pipeline_version), + sqlc.arg(variant), + sqlc.arg(s3_key), + sqlc.arg(content_type), + sqlc.arg(size_bytes), + sqlc.arg(width), + sqlc.arg(height), + sqlc.arg(sha256) +); + +-- name: ListAttachmentVariants :many +SELECT * FROM attachment_variants +WHERE attachment_id = sqlc.arg(attachment_id)::uuid + AND pipeline_version = sqlc.arg(pipeline_version)::int +ORDER BY variant; diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index 9f6ce774..9eecedbf 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -4,10 +4,14 @@ INSERT INTO attachments ( chat_id, owner_id, s3_key, + staging_key, + job_id, filename, content_type, size_bytes, sha256, + width, + height, error_code ) SELECT @@ -15,10 +19,14 @@ SELECT sqlc.arg(chat_id)::uuid, sqlc.arg(owner_id)::uuid, sqlc.arg(s3_key)::text, + sqlc.narg(staging_key)::text, + sqlc.narg(job_id)::uuid, sqlc.arg(filename)::text, sqlc.arg(content_type)::attachment_content_type, sqlc.arg(size_bytes)::int, sqlc.arg(sha256)::text, + sqlc.arg(width)::int, + sqlc.arg(height)::int, NULLIF(sqlc.arg(error_code)::text, '') WHERE EXISTS ( SELECT 1 FROM chat_members @@ -77,6 +85,30 @@ SELECT ) AS referenced FROM attachments a; +-- name: LockAttachmentJob :one +SELECT * FROM attachments +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND job_id = sqlc.arg(job_id)::uuid + AND pipeline_version = sqlc.arg(pipeline_version)::int + AND attempts = sqlc.arg(attempt)::int + AND lease_until > now() +FOR UPDATE; + +-- name: LockExpiredAttachmentJobs :many +SELECT * FROM attachments +WHERE status = 'processing' + AND lease_until <= now() +ORDER BY lease_until, id +LIMIT sqlc.arg(batch_size)::int +FOR UPDATE SKIP LOCKED; + +-- name: MarkAttachmentReady :one +UPDATE attachments +SET status = 'ready', updated_at = now() +WHERE id = sqlc.arg(id)::uuid +RETURNING *; + -- name: MarkAttachmentFailedIfReady :execrows UPDATE attachments SET status = 'failed', @@ -84,12 +116,73 @@ SET status = 'failed', updated_at = now() WHERE id = sqlc.arg(id)::uuid AND status = 'ready'; --- name: MarkAttachmentReady :one +-- name: ClaimAttachmentJob :one UPDATE attachments -SET status = 'ready', updated_at = now() -WHERE id = $1::uuid +SET status = 'processing', + attempts = attempts + 1, + lease_until = sqlc.arg(lease_until)::timestamptz, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND job_id = sqlc.arg(job_id)::uuid + AND pipeline_version = sqlc.arg(pipeline_version)::int + AND status = 'queued' + AND attempts + 1 = sqlc.arg(attempt)::int RETURNING *; +-- name: CompleteAttachmentJob :execrows +UPDATE attachments +SET status = 'ready', + error_code = NULL, + lease_until = NULL, + width = sqlc.arg(width)::int, + height = sqlc.arg(height)::int, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND attempts = sqlc.arg(attempt)::int + AND lease_until > now(); + +-- name: RetryAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + error_code = sqlc.arg(error_code)::text, + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND attempts = sqlc.arg(attempt)::int + AND lease_until > now(); + +-- name: FailAttachmentJob :execrows +UPDATE attachments +SET status = 'failed', + error_code = sqlc.arg(error_code)::text, + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND attempts = sqlc.arg(attempt)::int + AND lease_until > now(); + +-- name: RecoverExpiredAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND lease_until <= now(); + +-- name: FailExpiredAttachmentJob :execrows +UPDATE attachments +SET status = 'failed', + error_code = 'retry_exhausted', + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'processing' + AND lease_until <= now(); + -- name: DeleteQueuedAttachment :execrows DELETE FROM attachments WHERE id = sqlc.arg(id)::uuid AND status = 'queued'; diff --git a/db/queries/outbox.sql b/db/queries/outbox.sql new file mode 100644 index 00000000..0aecc5bd --- /dev/null +++ b/db/queries/outbox.sql @@ -0,0 +1,32 @@ +-- name: CreateOutboxEntry :one +INSERT INTO outbox ( + job_id, + attachment_id, + pipeline_version, + attempt, + available_at +) +SELECT + job_id, + id, + pipeline_version, + sqlc.arg(attempt)::int, + sqlc.arg(available_at)::timestamptz +FROM attachments +WHERE id = sqlc.arg(attachment_id)::uuid + AND job_id IS NOT NULL +RETURNING *; + +-- name: LockPendingOutboxEntries :many +SELECT * FROM outbox +WHERE published_at IS NULL + AND available_at <= now() +ORDER BY available_at, id +LIMIT sqlc.arg(batch_size)::int +FOR UPDATE SKIP LOCKED; + +-- name: MarkOutboxPublished :execrows +UPDATE outbox +SET published_at = now() +WHERE id = sqlc.arg(id)::bigint + AND published_at IS NULL; diff --git a/internal/db/attachment_variants.sql.go b/internal/db/attachment_variants.sql.go new file mode 100644 index 00000000..f6270f00 --- /dev/null +++ b/internal/db/attachment_variants.sql.go @@ -0,0 +1,105 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: attachment_variants.sql + +package db + +import ( + "context" + + "github.com/google/uuid" +) + +const createAttachmentVariant = `-- name: CreateAttachmentVariant :exec +INSERT INTO attachment_variants ( + attachment_id, + pipeline_version, + variant, + s3_key, + content_type, + size_bytes, + width, + height, + sha256 +) VALUES ( + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8, + $9 +) +` + +type CreateAttachmentVariantParams struct { + AttachmentID uuid.UUID + PipelineVersion int + Variant AttachmentVariantName + S3Key string + ContentType string + SizeBytes int + Width int + Height int + Sha256 string +} + +func (q *Queries) CreateAttachmentVariant(ctx context.Context, arg CreateAttachmentVariantParams) error { + _, err := q.db.Exec(ctx, createAttachmentVariant, + arg.AttachmentID, + arg.PipelineVersion, + arg.Variant, + arg.S3Key, + arg.ContentType, + arg.SizeBytes, + arg.Width, + arg.Height, + arg.Sha256, + ) + return err +} + +const listAttachmentVariants = `-- name: ListAttachmentVariants :many +SELECT attachment_id, pipeline_version, variant, s3_key, content_type, size_bytes, sha256, width, height FROM attachment_variants +WHERE attachment_id = $1::uuid + AND pipeline_version = $2::int +ORDER BY variant +` + +type ListAttachmentVariantsParams struct { + AttachmentID uuid.UUID + PipelineVersion int +} + +func (q *Queries) ListAttachmentVariants(ctx context.Context, arg ListAttachmentVariantsParams) ([]AttachmentVariant, error) { + rows, err := q.db.Query(ctx, listAttachmentVariants, arg.AttachmentID, arg.PipelineVersion) + if err != nil { + return nil, err + } + defer rows.Close() + items := []AttachmentVariant{} + for rows.Next() { + var i AttachmentVariant + if err := rows.Scan( + &i.AttachmentID, + &i.PipelineVersion, + &i.Variant, + &i.S3Key, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Width, + &i.Height, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index 8103dd3a..00a21832 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -12,16 +12,109 @@ import ( "github.com/google/uuid" ) +const claimAttachmentJob = `-- name: ClaimAttachmentJob :one +UPDATE attachments +SET status = 'processing', + attempts = attempts + 1, + lease_until = $1::timestamptz, + updated_at = now() +WHERE id = $2::uuid + AND job_id = $3::uuid + AND pipeline_version = $4::int + AND status = 'queued' + AND attempts + 1 = $5::int +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until +` + +type ClaimAttachmentJobParams struct { + LeaseUntil time.Time + ID uuid.UUID + JobID uuid.UUID + PipelineVersion int + Attempt int +} + +func (q *Queries) ClaimAttachmentJob(ctx context.Context, arg ClaimAttachmentJobParams) (Attachment, error) { + row := q.db.QueryRow(ctx, claimAttachmentJob, + arg.LeaseUntil, + arg.ID, + arg.JobID, + arg.PipelineVersion, + arg.Attempt, + ) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, + ) + return i, err +} + +const completeAttachmentJob = `-- name: CompleteAttachmentJob :execrows +UPDATE attachments +SET status = 'ready', + error_code = NULL, + lease_until = NULL, + width = $1::int, + height = $2::int, + updated_at = now() +WHERE id = $3::uuid + AND status = 'processing' + AND attempts = $4::int + AND lease_until > now() +` + +type CompleteAttachmentJobParams struct { + Width int + Height int + ID uuid.UUID + Attempt int +} + +func (q *Queries) CompleteAttachmentJob(ctx context.Context, arg CompleteAttachmentJobParams) (int64, error) { + result, err := q.db.Exec(ctx, completeAttachmentJob, + arg.Width, + arg.Height, + arg.ID, + arg.Attempt, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + const createAttachment = `-- name: CreateAttachment :one INSERT INTO attachments ( id, chat_id, owner_id, s3_key, + staging_key, + job_id, filename, content_type, size_bytes, sha256, + width, + height, error_code ) SELECT @@ -30,16 +123,20 @@ SELECT $3::uuid, $4::text, $5::text, - $6::attachment_content_type, - $7::int, - $8::text, - NULLIF($9::text, '') + $6::uuid, + $7::text, + $8::attachment_content_type, + $9::int, + $10::text, + $11::int, + $12::int, + NULLIF($13::text, '') WHERE EXISTS ( SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3 ) -RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until ` type CreateAttachmentParams struct { @@ -47,10 +144,14 @@ type CreateAttachmentParams struct { ChatID uuid.UUID OwnerID uuid.UUID S3Key string + StagingKey *string + JobID *uuid.UUID Filename string ContentType AttachmentContentType SizeBytes int Sha256 string + Width int + Height int ErrorCode string } @@ -60,10 +161,14 @@ func (q *Queries) CreateAttachment(ctx context.Context, arg CreateAttachmentPara arg.ChatID, arg.OwnerID, arg.S3Key, + arg.StagingKey, + arg.JobID, arg.Filename, arg.ContentType, arg.SizeBytes, arg.Sha256, + arg.Width, + arg.Height, arg.ErrorCode, ) var i Attachment @@ -80,6 +185,13 @@ func (q *Queries) CreateAttachment(ctx context.Context, arg CreateAttachmentPara &i.ErrorCode, &i.CreatedAt, &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, ) return i, err } @@ -120,8 +232,53 @@ func (q *Queries) DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int return result.RowsAffected(), nil } +const failAttachmentJob = `-- name: FailAttachmentJob :execrows +UPDATE attachments +SET status = 'failed', + error_code = $1::text, + lease_until = NULL, + updated_at = now() +WHERE id = $2::uuid + AND status = 'processing' + AND attempts = $3::int + AND lease_until > now() +` + +type FailAttachmentJobParams struct { + ErrorCode string + ID uuid.UUID + Attempt int +} + +func (q *Queries) FailAttachmentJob(ctx context.Context, arg FailAttachmentJobParams) (int64, error) { + result, err := q.db.Exec(ctx, failAttachmentJob, arg.ErrorCode, arg.ID, arg.Attempt) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const failExpiredAttachmentJob = `-- name: FailExpiredAttachmentJob :execrows +UPDATE attachments +SET status = 'failed', + error_code = 'retry_exhausted', + lease_until = NULL, + updated_at = now() +WHERE id = $1::uuid + AND status = 'processing' + AND lease_until <= now() +` + +func (q *Queries) FailExpiredAttachmentJob(ctx context.Context, id uuid.UUID) (int64, error) { + result, err := q.db.Exec(ctx, failExpiredAttachmentJob, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + const getAttachmentByID = `-- name: GetAttachmentByID :one -SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at FROM attachments +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments WHERE id = $1::uuid ` @@ -141,6 +298,13 @@ func (q *Queries) GetAttachmentByID(ctx context.Context, dollar_1 uuid.UUID) (At &i.ErrorCode, &i.CreatedAt, &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, ) return i, err } @@ -316,6 +480,105 @@ func (q *Queries) ListStaleAttachmentUploads(ctx context.Context, cutoff time.Ti return items, nil } +const lockAttachmentJob = `-- name: LockAttachmentJob :one +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +WHERE id = $1::uuid + AND status = 'processing' + AND job_id = $2::uuid + AND pipeline_version = $3::int + AND attempts = $4::int + AND lease_until > now() +FOR UPDATE +` + +type LockAttachmentJobParams struct { + ID uuid.UUID + JobID uuid.UUID + PipelineVersion int + Attempt int +} + +func (q *Queries) LockAttachmentJob(ctx context.Context, arg LockAttachmentJobParams) (Attachment, error) { + row := q.db.QueryRow(ctx, lockAttachmentJob, + arg.ID, + arg.JobID, + arg.PipelineVersion, + arg.Attempt, + ) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, + ) + return i, err +} + +const lockExpiredAttachmentJobs = `-- name: LockExpiredAttachmentJobs :many +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +WHERE status = 'processing' + AND lease_until <= now() +ORDER BY lease_until, id +LIMIT $1::int +FOR UPDATE SKIP LOCKED +` + +func (q *Queries) LockExpiredAttachmentJobs(ctx context.Context, batchSize int) ([]Attachment, error) { + rows, err := q.db.Query(ctx, lockExpiredAttachmentJobs, batchSize) + if err != nil { + return nil, err + } + defer rows.Close() + items := []Attachment{} + for rows.Next() { + var i Attachment + if err := rows.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const markAttachmentFailedIfReady = `-- name: MarkAttachmentFailedIfReady :execrows UPDATE attachments SET status = 'failed', @@ -341,11 +604,11 @@ const markAttachmentReady = `-- name: MarkAttachmentReady :one UPDATE attachments SET status = 'ready', updated_at = now() WHERE id = $1::uuid -RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until ` -func (q *Queries) MarkAttachmentReady(ctx context.Context, dollar_1 uuid.UUID) (Attachment, error) { - row := q.db.QueryRow(ctx, markAttachmentReady, dollar_1) +func (q *Queries) MarkAttachmentReady(ctx context.Context, id uuid.UUID) (Attachment, error) { + row := q.db.QueryRow(ctx, markAttachmentReady, id) var i Attachment err := row.Scan( &i.ID, @@ -360,6 +623,57 @@ func (q *Queries) MarkAttachmentReady(ctx context.Context, dollar_1 uuid.UUID) ( &i.ErrorCode, &i.CreatedAt, &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, ) return i, err } + +const recoverExpiredAttachmentJob = `-- name: RecoverExpiredAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + lease_until = NULL, + updated_at = now() +WHERE id = $1::uuid + AND status = 'processing' + AND lease_until <= now() +` + +func (q *Queries) RecoverExpiredAttachmentJob(ctx context.Context, id uuid.UUID) (int64, error) { + result, err := q.db.Exec(ctx, recoverExpiredAttachmentJob, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const retryAttachmentJob = `-- name: RetryAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + error_code = $1::text, + lease_until = NULL, + updated_at = now() +WHERE id = $2::uuid + AND status = 'processing' + AND attempts = $3::int + AND lease_until > now() +` + +type RetryAttachmentJobParams struct { + ErrorCode string + ID uuid.UUID + Attempt int +} + +func (q *Queries) RetryAttachmentJob(ctx context.Context, arg RetryAttachmentJobParams) (int64, error) { + result, err := q.db.Exec(ctx, retryAttachmentJob, arg.ErrorCode, arg.ID, arg.Attempt) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} diff --git a/internal/db/models.go b/internal/db/models.go index 5d69de15..98dbdaf3 100644 --- a/internal/db/models.go +++ b/internal/db/models.go @@ -98,19 +98,81 @@ func (ns NullAttachmentStatus) Value() (driver.Value, error) { return string(ns.AttachmentStatus), nil } +type AttachmentVariantName string + +const ( + AttachmentVariantNameThumbnail AttachmentVariantName = "thumbnail" + AttachmentVariantNameCrop AttachmentVariantName = "crop" + AttachmentVariantNameOptimized AttachmentVariantName = "optimized" +) + +func (e *AttachmentVariantName) Scan(src interface{}) error { + switch s := src.(type) { + case []byte: + *e = AttachmentVariantName(s) + case string: + *e = AttachmentVariantName(s) + default: + return fmt.Errorf("unsupported scan type for AttachmentVariantName: %T", src) + } + return nil +} + +type NullAttachmentVariantName struct { + AttachmentVariantName AttachmentVariantName + Valid bool // Valid is true if AttachmentVariantName is not NULL +} + +// Scan implements the Scanner interface. +func (ns *NullAttachmentVariantName) Scan(value interface{}) error { + if value == nil { + ns.AttachmentVariantName, ns.Valid = "", false + return nil + } + ns.Valid = true + return ns.AttachmentVariantName.Scan(value) +} + +// Value implements the driver Valuer interface. +func (ns NullAttachmentVariantName) Value() (driver.Value, error) { + if !ns.Valid { + return nil, nil + } + return string(ns.AttachmentVariantName), nil +} + type Attachment struct { - ID uuid.UUID - ChatID uuid.UUID - OwnerID uuid.UUID - S3Key string - Filename string - ContentType AttachmentContentType - SizeBytes int - Sha256 string - Status AttachmentStatus - ErrorCode *string - CreatedAt time.Time - UpdatedAt time.Time + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + S3Key string + Filename string + ContentType AttachmentContentType + SizeBytes int + Sha256 string + Status AttachmentStatus + ErrorCode *string + CreatedAt time.Time + UpdatedAt time.Time + StagingKey *string + JobID *uuid.UUID + PipelineVersion int + Attempts int + Width *int32 + Height *int32 + LeaseUntil *time.Time +} + +type AttachmentVariant struct { + AttachmentID uuid.UUID + PipelineVersion int + Variant AttachmentVariantName + S3Key string + ContentType string + SizeBytes int + Sha256 string + Width int + Height int } type Chat struct { @@ -148,6 +210,17 @@ type MessageAttachment struct { Position int } +type Outbox struct { + ID int64 + JobID uuid.UUID + AttachmentID uuid.UUID + PipelineVersion int + Attempt int + CreatedAt time.Time + AvailableAt time.Time + PublishedAt *time.Time +} + type Session struct { TokenHash string UserID uuid.UUID diff --git a/internal/db/outbox.sql.go b/internal/db/outbox.sql.go new file mode 100644 index 00000000..f02c4f28 --- /dev/null +++ b/internal/db/outbox.sql.go @@ -0,0 +1,108 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: outbox.sql + +package db + +import ( + "context" + "time" + + "github.com/google/uuid" +) + +const createOutboxEntry = `-- name: CreateOutboxEntry :one +INSERT INTO outbox ( + job_id, + attachment_id, + pipeline_version, + attempt, + available_at +) +SELECT + job_id, + id, + pipeline_version, + $1::int, + $2::timestamptz +FROM attachments +WHERE id = $3::uuid + AND job_id IS NOT NULL +RETURNING id, job_id, attachment_id, pipeline_version, attempt, created_at, available_at, published_at +` + +type CreateOutboxEntryParams struct { + Attempt int + AvailableAt time.Time + AttachmentID uuid.UUID +} + +func (q *Queries) CreateOutboxEntry(ctx context.Context, arg CreateOutboxEntryParams) (Outbox, error) { + row := q.db.QueryRow(ctx, createOutboxEntry, arg.Attempt, arg.AvailableAt, arg.AttachmentID) + var i Outbox + err := row.Scan( + &i.ID, + &i.JobID, + &i.AttachmentID, + &i.PipelineVersion, + &i.Attempt, + &i.CreatedAt, + &i.AvailableAt, + &i.PublishedAt, + ) + return i, err +} + +const lockPendingOutboxEntries = `-- name: LockPendingOutboxEntries :many +SELECT id, job_id, attachment_id, pipeline_version, attempt, created_at, available_at, published_at FROM outbox +WHERE published_at IS NULL + AND available_at <= now() +ORDER BY available_at, id +LIMIT $1::int +FOR UPDATE SKIP LOCKED +` + +func (q *Queries) LockPendingOutboxEntries(ctx context.Context, batchSize int) ([]Outbox, error) { + rows, err := q.db.Query(ctx, lockPendingOutboxEntries, batchSize) + if err != nil { + return nil, err + } + defer rows.Close() + items := []Outbox{} + for rows.Next() { + var i Outbox + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.AttachmentID, + &i.PipelineVersion, + &i.Attempt, + &i.CreatedAt, + &i.AvailableAt, + &i.PublishedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const markOutboxPublished = `-- name: MarkOutboxPublished :execrows +UPDATE outbox +SET published_at = now() +WHERE id = $1::bigint + AND published_at IS NULL +` + +func (q *Queries) MarkOutboxPublished(ctx context.Context, id int64) (int64, error) { + result, err := q.db.Exec(ctx, markOutboxPublished, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} diff --git a/internal/service/attachment.go b/internal/service/attachment.go index 63112c94..e1e0c395 100644 --- a/internal/service/attachment.go +++ b/internal/service/attachment.go @@ -98,7 +98,7 @@ func (s *AttachmentService) Upload( if _, err := tmp.Seek(0, io.SeekStart); err != nil { return model.Attachment{}, err } - detectedType, err := s.checkImage(ctx, tmp, contentType) + detectedType, width, height, err := s.checkImage(ctx, tmp, contentType) if err != nil { return model.Attachment{}, err } @@ -124,6 +124,8 @@ func (s *AttachmentService) Upload( ContentType: db.AttachmentContentType(detectedType), SizeBytes: int(size), Sha256: hash, + Width: width, + Height: height, ErrorCode: "", }) if postgres.IsNotFound(err) { @@ -222,52 +224,52 @@ func (s *AttachmentService) GetContent( return data, model.ContentType(row.ContentType), nil } -func (s *AttachmentService) checkImage(ctx context.Context, r io.ReadSeeker, contentType string) (model.ContentType, error) { +func (s *AttachmentService) checkImage(ctx context.Context, r io.ReadSeeker, contentType string) (model.ContentType, int, int, error) { cfg, format, err := image.DecodeConfig(r) if err != nil { - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } if cfg.Width <= 0 || cfg.Height <= 0 { - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } if cfg.Width > s.maxPixels/cfg.Height { - return "", ErrInvalidSize + return "", 0, 0, ErrInvalidSize } var detectedType model.ContentType switch format { case "png": if contentType != string(model.ContentTypePNG) { - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } detectedType = model.ContentTypePNG case "jpeg": if contentType != string(model.ContentTypeJPEG) { - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } detectedType = model.ContentTypeJPEG default: - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } select { case s.decodeSlot <- struct{}{}: defer func() { <-s.decodeSlot }() case <-ctx.Done(): - return "", ctx.Err() + return "", 0, 0, ctx.Err() } if err := ctx.Err(); err != nil { - return "", err + return "", 0, 0, err } if _, err := r.Seek(0, io.SeekStart); err != nil { - return "", err + return "", 0, 0, err } if _, _, err := image.Decode(r); err != nil { - return "", ErrInvalidImage + return "", 0, 0, ErrInvalidImage } - return detectedType, nil + return detectedType, cfg.Width, cfg.Height, nil } func (s *AttachmentService) ensureMember(ctx context.Context, userID, chatID uuid.UUID) error { -- 2.54.0 From e889d2e292b2a2e4f2653cce4feb2ce8bf7dce38 Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 15:04:15 +0300 Subject: [PATCH 03/23] feat(infra): add RabbitMQ with persistent storage and secrets --- .env.example | 1 + compose.yaml | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/.env.example b/.env.example index 85589ca5..729d8922 100644 --- a/.env.example +++ b/.env.example @@ -25,6 +25,7 @@ MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 BROKER_URL_FILE=/run/secrets/broker_url +BROKER_PASSWORD_FILE=/run/secrets/broker_password WORKER_CONCURRENCY=2 JOB_MAX_ATTEMPTS=5 JOB_TIMEOUT_SECONDS=60 diff --git a/compose.yaml b/compose.yaml index 1c52a328..2671fe02 100644 --- a/compose.yaml +++ b/compose.yaml @@ -81,6 +81,35 @@ services: memory: 128M restart: unless-stopped + rabbitmq: + image: rabbitmq:4.2.9-alpine + hostname: rabbitmq + environment: + RABBITMQ_DEFAULT_USER: messenger + BROKER_PASSWORD_FILE: ${BROKER_PASSWORD_FILE:-/run/secrets/broker_password} + entrypoint: ["/bin/sh", "-ec"] + command: + - | + RABBITMQ_DEFAULT_PASS="$$(cat "$$BROKER_PASSWORD_FILE")" + export RABBITMQ_DEFAULT_PASS + exec docker-entrypoint.sh rabbitmq-server + secrets: + - broker_password + volumes: + - rabbitmq:/var/lib/rabbitmq + healthcheck: + test: ["CMD", "rabbitmq-diagnostics", "-q", "check_running"] + interval: 10s + timeout: 5s + retries: 10 + start_period: 30s + deploy: + resources: + limits: + cpus: "0.5" + memory: 512M + restart: unless-stopped + s3-config-init: build: context: . @@ -181,6 +210,10 @@ secrets: file: ./secrets/database_url.txt cache_url: file: ./secrets/cache_url.txt + broker_password: + file: ./secrets/broker_password.txt + broker_url: + file: ./secrets/broker_url.txt s3_access_key_id: file: ./secrets/s3_access_key_id.txt s3_secret_access_key: @@ -194,3 +227,4 @@ volumes: pgdata: seaweedfs: s3config: + rabbitmq: -- 2.54.0 From d745395aa0748f127cdac5e6b911b22ac8175cdc Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 17:46:50 +0300 Subject: [PATCH 04/23] feat(rabbitmq): add durable messaging client and broker config --- go.mod | 1 + go.sum | 4 ++ internal/config/config.go | 13 +++++ internal/rabbitmq/client.go | 110 ++++++++++++++++++++++++++++++++++++ 4 files changed, 128 insertions(+) create mode 100644 internal/rabbitmq/client.go diff --git a/go.mod b/go.mod index dbbd6734..6f58293f 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.11.0 github.com/joho/godotenv v1.5.1 + github.com/rabbitmq/amqp091-go v1.10.0 github.com/redis/go-redis/v9 v9.23.0 golang.org/x/crypto v0.58.0 ) diff --git a/go.sum b/go.sum index 4a47d012..a7ad7b9f 100644 --- a/go.sum +++ b/go.sum @@ -58,6 +58,8 @@ github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwA github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw= +github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o= github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -69,6 +71,8 @@ github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= diff --git a/internal/config/config.go b/internal/config/config.go index 9271fe13..68177fc9 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -20,6 +20,7 @@ type Config struct { Logging LoggingConfig Database DatabaseConfig Redis RedisConfig + Broker BrokerConfig S3 S3Config SessionStore string } @@ -57,6 +58,14 @@ func (c RedisConfig) URL() (string, error) { return readSecretFile(c.URLFile) } +type BrokerConfig struct { + URLFile string +} + +func (c BrokerConfig) URL() (string, error) { + return readSecretFile(c.URLFile) +} + type S3Config struct { Endpoint string Region string @@ -108,6 +117,10 @@ func Load() Config { URLFile: getEnv("CACHE_URL_FILE", "/run/secrets/cache_url"), }, + Broker: BrokerConfig{ + URLFile: getEnv("BROKER_URL_FILE", "/run/secrets/broker_url"), + }, + S3: LoadS3(), SessionStore: getEnvSessionStore("SESSION_STORE", SessionStorePostgres), diff --git a/internal/rabbitmq/client.go b/internal/rabbitmq/client.go new file mode 100644 index 00000000..bfa7148c --- /dev/null +++ b/internal/rabbitmq/client.go @@ -0,0 +1,110 @@ +package rabbitmq + +import ( + "context" + "errors" + "sync" + "time" + + amqp "github.com/rabbitmq/amqp091-go" +) + +const QueueName = "attachments.process.v1" + +var ( + ErrConnect = errors.New("connect to rabbitmq") + ErrNotRouted = errors.New("rabbitmq message not routed") + ErrNack = errors.New("rabbitmq publish rejected") + ErrPrefetch = errors.New("rabbitmq prefetch must be positive") +) + +type Client struct { + conn *amqp.Connection + channel *amqp.Channel + returns <-chan amqp.Return + mu sync.Mutex +} + +func New(url string) (*Client, error) { + conn, err := amqp.DialConfig(url, amqp.Config{ + Dial: amqp.DefaultDial(5 * time.Second), + }) + if err != nil { + return nil, ErrConnect + } + + channel, err := conn.Channel() + if err != nil { + _ = conn.CloseDeadline(time.Now().Add(time.Second)) + return nil, err + } + if _, err := channel.QueueDeclare(QueueName, true, false, false, false, nil); err != nil { + _ = conn.CloseDeadline(time.Now().Add(time.Second)) + return nil, err + } + if err := channel.Confirm(false); err != nil { + _ = conn.CloseDeadline(time.Now().Add(time.Second)) + return nil, err + } + + return &Client{ + conn: conn, + channel: channel, + returns: channel.NotifyReturn(make(chan amqp.Return, 1)), + }, nil +} + +func (c *Client) Publish(ctx context.Context, messageID string, body []byte) error { + c.mu.Lock() + defer c.mu.Unlock() + + if err := ctx.Err(); err != nil { + return err + } + + stop := context.AfterFunc(ctx, func() { + _ = c.conn.CloseDeadline(time.Now()) + }) + defer stop() + + confirmation, err := c.channel.PublishWithDeferredConfirm("", QueueName, true, false, amqp.Publishing{ + ContentType: "application/json", + DeliveryMode: amqp.Persistent, + MessageId: messageID, + Body: body, + }) + if err != nil { + return err + } + ack, err := confirmation.WaitContext(ctx) + if err != nil { + return err + } + if !ack { + return ErrNack + } + + select { + case _, ok := <-c.returns: + if !ok { + return amqp.ErrClosed + } + return ErrNotRouted + default: + return nil + } +} + +func (c *Client) Consume(ctx context.Context, prefetch int) (<-chan amqp.Delivery, error) { + if prefetch < 1 { + return nil, ErrPrefetch + } + if err := c.channel.Qos(prefetch, 0, false); err != nil { + return nil, err + } + return c.channel.ConsumeWithContext(ctx, QueueName, "", false, false, false, false, nil) +} + +func (c *Client) Close() error { + return c.conn.CloseDeadline(time.Now().Add(time.Second)) +} -- 2.54.0 From 425ffc6182f9a4c832d5efbeced8bdc9a0768c54 Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 18:16:00 +0300 Subject: [PATCH 05/23] feat(outbox): add publisher with confirms and reconnect --- compose.yaml | 1 + internal/app/app.go | 31 +++++--- internal/model/attachment_job.go | 17 +++++ internal/outbox/publisher.go | 119 +++++++++++++++++++++++++++++++ 4 files changed, 158 insertions(+), 10 deletions(-) create mode 100644 internal/model/attachment_job.go create mode 100644 internal/outbox/publisher.go diff --git a/compose.yaml b/compose.yaml index 2671fe02..ed54f2b3 100644 --- a/compose.yaml +++ b/compose.yaml @@ -9,6 +9,7 @@ services: secrets: - database_url - cache_url + - broker_url - s3_access_key_id - s3_secret_access_key - s3_bootstrap_access_key_id diff --git a/internal/app/app.go b/internal/app/app.go index 80a3c9f2..a9508d8c 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -16,6 +16,7 @@ import ( "mtusi2026-messenger/internal/config" "mtusi2026-messenger/internal/db" "mtusi2026-messenger/internal/logger" + "mtusi2026-messenger/internal/outbox" "mtusi2026-messenger/internal/postgres" "mtusi2026-messenger/internal/redis" s3store "mtusi2026-messenger/internal/s3" @@ -80,17 +81,27 @@ func Run() error { log.Info("s3 storage ready", "endpoint", cfg.S3.Endpoint, "bucket", s3Client.Bucket()) - cleanupCtx, stopCleanup := context.WithCancel(context.Background()) - var cleanupWG sync.WaitGroup - cleanupWG.Go(func() { - runSessionCleanup(cleanupCtx, log, queries, sessionCleanupInterval) + brokerURL, err := cfg.Broker.URL() + if err != nil { + log.Error("read broker url", "error", err) + return err + } + publisher := outbox.NewPublisher(pool, brokerURL, log) + + backgroundCtx, stopBackground := context.WithCancel(context.Background()) + var backgroundWG sync.WaitGroup + backgroundWG.Go(func() { + publisher.Run(backgroundCtx) }) - cleanupWG.Go(func() { - runIdempotencyCleanup(cleanupCtx, log, queries, cfg.Server.IdempotencyTTL, idempotencyCleanupInterval) + backgroundWG.Go(func() { + runSessionCleanup(backgroundCtx, log, queries, sessionCleanupInterval) }) - cleanupWG.Go(func() { + backgroundWG.Go(func() { + runIdempotencyCleanup(backgroundCtx, log, queries, cfg.Server.IdempotencyTTL, idempotencyCleanupInterval) + }) + backgroundWG.Go(func() { runAttachmentCleanup( - cleanupCtx, + backgroundCtx, log, queries, s3Client, @@ -99,8 +110,8 @@ func Run() error { ) }) defer func() { - stopCleanup() - cleanupWG.Wait() + stopBackground() + backgroundWG.Wait() }() authService := service.NewAuthService(queries, rdb, cfg.Server.SessionTTL, log) diff --git a/internal/model/attachment_job.go b/internal/model/attachment_job.go new file mode 100644 index 00000000..d3bffe59 --- /dev/null +++ b/internal/model/attachment_job.go @@ -0,0 +1,17 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type AttachmentJob struct { + SchemaVersion int `json:"schema_version"` + JobID uuid.UUID `json:"job_id"` + Type string `json:"type"` + AttachmentID uuid.UUID `json:"attachment_id"` + PipelineVersion int `json:"pipeline_version"` + Attempt int `json:"attempt"` + CreatedAt time.Time `json:"created_at"` +} diff --git a/internal/outbox/publisher.go b/internal/outbox/publisher.go new file mode 100644 index 00000000..23f17ef4 --- /dev/null +++ b/internal/outbox/publisher.go @@ -0,0 +1,119 @@ +package outbox + +import ( + "context" + "encoding/json" + "log/slog" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/rabbitmq" +) + +const ( + pollInterval = time.Second + retryInterval = 2 * time.Second + publishTimeout = 5 * time.Second +) + +type Publisher struct { + pool *pgxpool.Pool + url string + log *slog.Logger +} + +func NewPublisher(pool *pgxpool.Pool, url string, log *slog.Logger) *Publisher { + return &Publisher{ + pool: pool, + url: url, + log: log, + } +} + +func (p *Publisher) Run(ctx context.Context) { + for ctx.Err() == nil { + client, err := rabbitmq.New(p.url) + if err == nil { + p.log.Info("outbox publisher connected") + err = p.publish(ctx, client) + _ = client.Close() + } + if ctx.Err() != nil { + return + } + p.log.Error("outbox publisher retry", "error", err) + if !wait(ctx, retryInterval) { + return + } + } +} + +func (p *Publisher) publish(ctx context.Context, client *rabbitmq.Client) error { + for ctx.Err() == nil { + published, err := p.publishOne(ctx, client) + if err != nil { + return err + } + if !published && !wait(ctx, pollInterval) { + return ctx.Err() + } + } + return ctx.Err() +} + +func (p *Publisher) publishOne(ctx context.Context, client *rabbitmq.Client) (bool, error) { + ctx, cancel := context.WithTimeout(ctx, publishTimeout) + defer cancel() + + tx, err := p.pool.Begin(ctx) + if err != nil { + return false, err + } + defer tx.Rollback(ctx) + + q := db.New(tx) + rows, err := q.LockPendingOutboxEntries(ctx, 1) + if err != nil { + return false, err + } + if len(rows) == 0 { + return false, nil + } + row := rows[0] + body, err := json.Marshal(model.AttachmentJob{ + SchemaVersion: 1, + JobID: row.JobID, + Type: "attachment.process.v1", + AttachmentID: row.AttachmentID, + PipelineVersion: row.PipelineVersion, + Attempt: row.Attempt, + CreatedAt: row.CreatedAt.UTC(), + }) + if err != nil { + return false, err + } + if err := client.Publish(ctx, row.JobID.String(), body); err != nil { + return false, err + } + if _, err := q.MarkOutboxPublished(ctx, row.ID); err != nil { + return false, err + } + if err := tx.Commit(ctx); err != nil { + return false, err + } + return true, nil +} + +func wait(ctx context.Context, delay time.Duration) bool { + timer := time.NewTimer(delay) + defer timer.Stop() + select { + case <-ctx.Done(): + return false + case <-timer.C: + return true + } +} -- 2.54.0 From 4dbbd65bcfb4a1931b4281dae616793f1c4fc341 Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 18:20:08 +0300 Subject: [PATCH 06/23] refactor(rabbitmq): remove redundant publish mutex --- internal/rabbitmq/client.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/internal/rabbitmq/client.go b/internal/rabbitmq/client.go index bfa7148c..56909db1 100644 --- a/internal/rabbitmq/client.go +++ b/internal/rabbitmq/client.go @@ -3,7 +3,6 @@ package rabbitmq import ( "context" "errors" - "sync" "time" amqp "github.com/rabbitmq/amqp091-go" @@ -22,7 +21,6 @@ type Client struct { conn *amqp.Connection channel *amqp.Channel returns <-chan amqp.Return - mu sync.Mutex } func New(url string) (*Client, error) { @@ -54,10 +52,8 @@ func New(url string) (*Client, error) { }, nil } +// Publish must not be called concurrently on the same client. func (c *Client) Publish(ctx context.Context, messageID string, body []byte) error { - c.mu.Lock() - defer c.mu.Unlock() - if err := ctx.Err(); err != nil { return err } -- 2.54.0 From 8b0ab5440dc85b4132decd48bf544f256ab46dea Mon Sep 17 00:00:00 2001 From: kk10 Date: Sat, 14 Nov 2026 19:52:51 +0300 Subject: [PATCH 07/23] feat(attachments): accept uploads through staging and transactional outbox --- cmd/reconcile/main.go | 12 ++--- db/queries/attachments.sql | 25 ++--------- internal/app/app.go | 13 +----- internal/app/cleanup.go | 77 --------------------------------- internal/db/attachments.sql.go | 72 ++++-------------------------- internal/handler/attachment.go | 2 +- internal/reconcile/reconcile.go | 61 +++----------------------- internal/service/attachment.go | 44 ++++++++++++++++--- internal/service/message.go | 2 +- student-tests/reconcile_test.go | 24 ++++------ 10 files changed, 70 insertions(+), 262 deletions(-) diff --git a/cmd/reconcile/main.go b/cmd/reconcile/main.go index a71f7e76..131741f3 100644 --- a/cmd/reconcile/main.go +++ b/cmd/reconcile/main.go @@ -96,22 +96,19 @@ func printReport(report reconcile.Report) { report.ListPages, ) fmt.Printf( - "found orphan_objects=%d missing_attachments=%d stale_uploads=%d corrupt_objects=%d\n", + "found orphan_objects=%d missing_attachments=%d corrupt_objects=%d\n", len(report.OrphanObjects), len(report.MissingAttachments), - len(report.StaleUploads), len(report.CorruptObjects), ) fmt.Printf( - "skipped fresh=%d referenced=%d inactive=%d\n", + "skipped fresh=%d inactive=%d\n", report.SkippedFresh, - report.SkippedReferenced, report.SkippedInactive, ) fmt.Printf( - "changes deleted_objects=%d deleted_rows=%d marked_failed=%d\n", + "changes deleted_objects=%d marked_failed=%d\n", report.DeletedObjects, - report.DeletedRows, report.MarkedFailed, ) @@ -124,9 +121,6 @@ func printReport(report reconcile.Report) { for _, id := range report.MissingAttachments { fmt.Printf("missing_attachment %s\n", id) } - for _, id := range report.StaleUploads { - fmt.Printf("stale_upload %s\n", id) - } for _, message := range report.Errors { fmt.Printf("error %s\n", message) } diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index 9eecedbf..d1d85ede 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -19,8 +19,8 @@ SELECT sqlc.arg(chat_id)::uuid, sqlc.arg(owner_id)::uuid, sqlc.arg(s3_key)::text, - sqlc.narg(staging_key)::text, - sqlc.narg(job_id)::uuid, + sqlc.arg(staging_key)::text, + sqlc.arg(job_id)::uuid, sqlc.arg(filename)::text, sqlc.arg(content_type)::attachment_content_type, sqlc.arg(size_bytes)::int, @@ -68,22 +68,9 @@ FROM message_attachments WHERE message_id = ANY(sqlc.arg(message_ids)::uuid[]) ORDER BY message_id, position; --- name: ListStaleAttachmentUploads :many -SELECT id, s3_key FROM attachments -WHERE status = 'queued' AND created_at < sqlc.arg(cutoff)::timestamptz; - -- name: ListAttachmentsForReconcile :many -SELECT - a.id, - a.s3_key, - a.status, - a.size_bytes, - a.created_at, - EXISTS ( - SELECT 1 FROM message_attachments ma - WHERE ma.attachment_id = a.id - ) AS referenced -FROM attachments a; +SELECT id, s3_key, status, size_bytes +FROM attachments; -- name: LockAttachmentJob :one SELECT * FROM attachments @@ -182,7 +169,3 @@ SET status = 'failed', WHERE id = sqlc.arg(id)::uuid AND status = 'processing' AND lease_until <= now(); - --- name: DeleteQueuedAttachment :execrows -DELETE FROM attachments -WHERE id = sqlc.arg(id)::uuid AND status = 'queued'; diff --git a/internal/app/app.go b/internal/app/app.go index a9508d8c..2bce831f 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -99,16 +99,7 @@ func Run() error { backgroundWG.Go(func() { runIdempotencyCleanup(backgroundCtx, log, queries, cfg.Server.IdempotencyTTL, idempotencyCleanupInterval) }) - backgroundWG.Go(func() { - runAttachmentCleanup( - backgroundCtx, - log, - queries, - s3Client, - attachmentOrphanGracePeriod, - attachmentCleanupInterval, - ) - }) + defer func() { stopBackground() backgroundWG.Wait() @@ -118,7 +109,7 @@ func Run() error { userService := service.NewUserService(queries) chatService := service.NewChatService(pool, queries) messageService := service.NewMessageService(pool, queries) - attachmentService := service.NewAttachmentService(queries, s3Client, cfg.S3.MaxUploadBytes, cfg.S3.MaxImagePixels) + attachmentService := service.NewAttachmentService(pool, queries, s3Client, cfg.S3.MaxUploadBytes, cfg.S3.MaxImagePixels) router := NewRouter( log, diff --git a/internal/app/cleanup.go b/internal/app/cleanup.go index c27528de..ece69ddf 100644 --- a/internal/app/cleanup.go +++ b/internal/app/cleanup.go @@ -4,18 +4,11 @@ import ( "context" "log/slog" "time" - - "github.com/google/uuid" - - "mtusi2026-messenger/internal/db" ) const ( sessionCleanupInterval = time.Hour idempotencyCleanupInterval = time.Hour - - attachmentCleanupInterval = 10 * time.Minute - attachmentOrphanGracePeriod = time.Hour ) type sessionCleaner interface { @@ -26,15 +19,6 @@ type idempotencyCleaner interface { DeleteExpiredIdempotencyKeys(ctx context.Context, cutoff time.Time) (int64, error) } -type staleUploadLister interface { - ListStaleAttachmentUploads(ctx context.Context, cutoff time.Time) ([]db.ListStaleAttachmentUploadsRow, error) - DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) -} - -type objectDeleter interface { - DeleteAdmin(ctx context.Context, key string) error -} - func runSessionCleanup(ctx context.Context, log *slog.Logger, q sessionCleaner, interval time.Duration) { ticker := time.NewTicker(interval) defer ticker.Stop() @@ -86,64 +70,3 @@ func runIdempotencyCleanup( } } } - -func runAttachmentCleanup( - ctx context.Context, - log *slog.Logger, - q staleUploadLister, - store objectDeleter, - grace time.Duration, - interval time.Duration, -) { - ticker := time.NewTicker(interval) - defer ticker.Stop() - - for { - select { - case <-ctx.Done(): - return - case <-ticker.C: - cleanupStaleUploads(ctx, log, q, store, grace) - } - } -} - -func cleanupStaleUploads( - ctx context.Context, - log *slog.Logger, - q staleUploadLister, - store objectDeleter, - grace time.Duration, -) { - cutoff := time.Now().Add(-grace) - - rows, err := q.ListStaleAttachmentUploads(ctx, cutoff) - if err != nil { - if ctx.Err() == nil { - log.Error("list stale attachment uploads", "error", err) - } - return - } - - deleted := 0 - - for _, row := range rows { - removed, err := q.DeleteQueuedAttachment(ctx, row.ID) - if err != nil { - log.Error("delete stale upload row", "id", row.ID, "error", err) - continue - } - if removed == 0 { - continue - } - if err := store.DeleteAdmin(ctx, row.S3Key); err != nil { - log.Error("delete stale upload object", "key", row.S3Key, "error", err) - continue - } - deleted++ - } - - if deleted > 0 { - log.Info("stale attachment uploads deleted", "count", deleted) - } -} diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index 00a21832..a3f4cb5f 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -144,8 +144,8 @@ type CreateAttachmentParams struct { ChatID uuid.UUID OwnerID uuid.UUID S3Key string - StagingKey *string - JobID *uuid.UUID + StagingKey string + JobID uuid.UUID Filename string ContentType AttachmentContentType SizeBytes int @@ -219,19 +219,6 @@ func (q *Queries) CreateMessageAttachment(ctx context.Context, arg CreateMessage return err } -const deleteQueuedAttachment = `-- name: DeleteQueuedAttachment :execrows -DELETE FROM attachments -WHERE id = $1::uuid AND status = 'queued' -` - -func (q *Queries) DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) { - result, err := q.db.Exec(ctx, deleteQueuedAttachment, id) - if err != nil { - return 0, err - } - return result.RowsAffected(), nil -} - const failAttachmentJob = `-- name: FailAttachmentJob :execrows UPDATE attachments SET status = 'failed', @@ -342,26 +329,15 @@ func (q *Queries) ListAttachmentsByIDs(ctx context.Context, arg ListAttachmentsB } const listAttachmentsForReconcile = `-- name: ListAttachmentsForReconcile :many -SELECT - a.id, - a.s3_key, - a.status, - a.size_bytes, - a.created_at, - EXISTS ( - SELECT 1 FROM message_attachments ma - WHERE ma.attachment_id = a.id - ) AS referenced -FROM attachments a +SELECT id, s3_key, status, size_bytes +FROM attachments ` type ListAttachmentsForReconcileRow struct { - ID uuid.UUID - S3Key string - Status AttachmentStatus - SizeBytes int - CreatedAt time.Time - Referenced bool + ID uuid.UUID + S3Key string + Status AttachmentStatus + SizeBytes int } func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttachmentsForReconcileRow, error) { @@ -378,8 +354,6 @@ func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttach &i.S3Key, &i.Status, &i.SizeBytes, - &i.CreatedAt, - &i.Referenced, ); err != nil { return nil, err } @@ -450,36 +424,6 @@ func (q *Queries) ListMessageAttachmentsByMessageIDs(ctx context.Context, messag return items, nil } -const listStaleAttachmentUploads = `-- name: ListStaleAttachmentUploads :many -SELECT id, s3_key FROM attachments -WHERE status = 'queued' AND created_at < $1::timestamptz -` - -type ListStaleAttachmentUploadsRow struct { - ID uuid.UUID - S3Key string -} - -func (q *Queries) ListStaleAttachmentUploads(ctx context.Context, cutoff time.Time) ([]ListStaleAttachmentUploadsRow, error) { - rows, err := q.db.Query(ctx, listStaleAttachmentUploads, cutoff) - if err != nil { - return nil, err - } - defer rows.Close() - items := []ListStaleAttachmentUploadsRow{} - for rows.Next() { - var i ListStaleAttachmentUploadsRow - if err := rows.Scan(&i.ID, &i.S3Key); err != nil { - return nil, err - } - items = append(items, i) - } - if err := rows.Err(); err != nil { - return nil, err - } - return items, nil -} - const lockAttachmentJob = `-- name: LockAttachmentJob :one SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments WHERE id = $1::uuid diff --git a/internal/handler/attachment.go b/internal/handler/attachment.go index 5470d7bc..f0f35ccd 100644 --- a/internal/handler/attachment.go +++ b/internal/handler/attachment.go @@ -77,7 +77,7 @@ func (h *AttachmentHandler) Upload(w http.ResponseWriter, r *http.Request) { return } - httpx.WriteJSON(w, http.StatusCreated, dto.ToAttachmentResponse(att)) + httpx.WriteJSON(w, http.StatusAccepted, dto.ToAttachmentResponse(att)) } func (h *AttachmentHandler) Get(w http.ResponseWriter, r *http.Request) { diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go index 11bb3279..d66bb560 100644 --- a/internal/reconcile/reconcile.go +++ b/internal/reconcile/reconcile.go @@ -32,13 +32,10 @@ type Report struct { ListPages int `json:"list_pages"` OrphanObjects []string `json:"orphan_objects"` MissingAttachments []uuid.UUID `json:"missing_attachments"` - StaleUploads []uuid.UUID `json:"stale_uploads"` CorruptObjects []string `json:"corrupt_objects"` SkippedFresh int `json:"skipped_fresh"` - SkippedReferenced int `json:"skipped_referenced"` SkippedInactive int `json:"skipped_inactive"` DeletedObjects int `json:"deleted_objects"` - DeletedRows int `json:"deleted_rows"` MarkedFailed int `json:"marked_failed"` DryRun bool `json:"dry_run"` Errors []string `json:"errors"` @@ -52,7 +49,6 @@ type ObjectClient interface { type AttachmentQueries interface { ListAttachmentsForReconcile(ctx context.Context) ([]db.ListAttachmentsForReconcileRow, error) - DeleteQueuedAttachment(ctx context.Context, id uuid.UUID) (int64, error) MarkAttachmentFailedIfReady(ctx context.Context, arg db.MarkAttachmentFailedIfReadyParams) (int64, error) } @@ -64,13 +60,11 @@ type Reconciler struct { } type plan struct { - orphans []s3store.ObjectInfo - staleUploads []db.ListAttachmentsForReconcileRow - missing []db.ListAttachmentsForReconcileRow - corrupt []s3store.ObjectInfo - skippedFresh int - skippedReferenced int - skippedInactive int + orphans []s3store.ObjectInfo + missing []db.ListAttachmentsForReconcileRow + corrupt []s3store.ObjectInfo + skippedFresh int + skippedInactive int } func New(store ObjectClient, queries AttachmentQueries, log *slog.Logger) *Reconciler { @@ -93,7 +87,6 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { report := Report{ OrphanObjects: []string{}, MissingAttachments: []uuid.UUID{}, - StaleUploads: []uuid.UUID{}, CorruptObjects: []string{}, DryRun: opts.DryRun, Errors: []string{}, @@ -121,15 +114,11 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { for _, obj := range p.corrupt { report.CorruptObjects = append(report.CorruptObjects, obj.Key) } - for _, row := range p.staleUploads { - report.StaleUploads = append(report.StaleUploads, row.ID) - } for _, row := range p.missing { report.MissingAttachments = append(report.MissingAttachments, row.ID) } report.SkippedFresh = p.skippedFresh - report.SkippedReferenced = p.skippedReferenced report.SkippedInactive = p.skippedInactive if !opts.DryRun { @@ -146,10 +135,8 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { "list_pages", report.ListPages, "orphan_objects", len(report.OrphanObjects), "missing_attachments", len(report.MissingAttachments), - "stale_uploads", len(report.StaleUploads), "corrupt_objects", len(report.CorruptObjects), "deleted_objects", report.DeletedObjects, - "deleted_rows", report.DeletedRows, "marked_failed", report.MarkedFailed, "errors", len(report.Errors), ) @@ -189,15 +176,7 @@ func buildPlan( switch row.Status { case db.AttachmentStatusQueued: - if now.Sub(row.CreatedAt) < grace { - p.skippedFresh++ - continue - } - if row.Referenced { - p.skippedReferenced++ - continue - } - p.staleUploads = append(p.staleUploads, row) + p.skippedInactive++ case db.AttachmentStatusReady: if !exists { p.missing = append(p.missing, row) @@ -227,9 +206,6 @@ func buildPlan( sort.Slice(p.corrupt, func(i, j int) bool { return p.corrupt[i].Key < p.corrupt[j].Key }) - sort.Slice(p.staleUploads, func(i, j int) bool { - return p.staleUploads[i].ID.String() < p.staleUploads[j].ID.String() - }) sort.Slice(p.missing, func(i, j int) bool { return p.missing[i].ID.String() < p.missing[j].ID.String() }) @@ -240,31 +216,6 @@ func buildPlan( func (r *Reconciler) apply(ctx context.Context, opts Options, p plan, report *Report) { deletes := 0 - for _, row := range p.staleUploads { - if deletes >= opts.MaxDeletes { - report.Errors = append(report.Errors, "max deletes reached") - break - } - - removed, err := r.q.DeleteQueuedAttachment(ctx, row.ID) - if err != nil { - report.Errors = append(report.Errors, fmt.Sprintf("delete row %s: %v", row.ID, err)) - continue - } - if removed == 0 { - continue - } - - deletes++ - report.DeletedRows++ - - if err := r.store.DeleteAdmin(ctx, row.S3Key); err != nil { - report.Errors = append(report.Errors, fmt.Sprintf("delete object %s: %v", row.S3Key, err)) - continue - } - report.DeletedObjects++ - } - for _, obj := range p.orphans { if deletes >= opts.MaxDeletes { report.Errors = append(report.Errors, "max deletes reached") diff --git a/internal/service/attachment.go b/internal/service/attachment.go index e1e0c395..10f8f9bf 100644 --- a/internal/service/attachment.go +++ b/internal/service/attachment.go @@ -14,6 +14,8 @@ import ( "os" "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" "mtusi2026-messenger/internal/db" "mtusi2026-messenger/internal/model" @@ -31,13 +33,15 @@ var ( type attachmentQueries interface { CreateAttachment(ctx context.Context, arg db.CreateAttachmentParams) (db.Attachment, error) + CreateOutboxEntry(ctx context.Context, arg db.CreateOutboxEntryParams) (db.Outbox, error) GetAttachmentByID(ctx context.Context, id uuid.UUID) (db.Attachment, error) IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error) - MarkAttachmentReady(ctx context.Context, id uuid.UUID) (db.Attachment, error) } type AttachmentService struct { + pool txBeginner q attachmentQueries + withTx func(pgx.Tx) attachmentQueries s3 *s3store.Client maxBytes int maxPixels int @@ -45,12 +49,17 @@ type AttachmentService struct { } func NewAttachmentService( - q attachmentQueries, + pool *pgxpool.Pool, + q *db.Queries, s3 *s3store.Client, maxBytes, maxPixels int, ) *AttachmentService { return &AttachmentService{ - q: q, + pool: pool, + q: q, + withTx: func(tx pgx.Tx) attachmentQueries { + return q.WithTx(tx) + }, s3: s3, maxBytes: maxBytes, maxPixels: maxPixels, @@ -107,19 +116,37 @@ func (s *AttachmentService) Upload( if err != nil { return model.Attachment{}, err } + jobID, err := uuid.NewV7() + if err != nil { + return model.Attachment{}, err + } hash := hex.EncodeToString(hasher.Sum(nil)) key := "chats/" + chatID.String() + "/attachments/" + id.String() + stagingKey := "staging/" + id.String() if _, err := tmp.Seek(0, io.SeekStart); err != nil { return model.Attachment{}, err } - _, err = s.q.CreateAttachment(ctx, db.CreateAttachmentParams{ + if err := s.s3.Put(ctx, stagingKey, tmp, size, string(detectedType)); err != nil { + return model.Attachment{}, err + } + + tx, err := s.pool.Begin(ctx) + if err != nil { + return model.Attachment{}, err + } + defer tx.Rollback(ctx) + q := s.withTx(tx) + + row, err := q.CreateAttachment(ctx, db.CreateAttachmentParams{ ID: id, ChatID: chatID, OwnerID: userID, S3Key: key, + StagingKey: stagingKey, + JobID: jobID, Filename: filename, ContentType: db.AttachmentContentType(detectedType), SizeBytes: int(size), @@ -135,12 +162,15 @@ func (s *AttachmentService) Upload( return model.Attachment{}, err } - if err := s.s3.Put(ctx, key, tmp, size, string(detectedType)); err != nil { + if _, err := q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: id, + Attempt: 1, + AvailableAt: row.CreatedAt, + }); err != nil { return model.Attachment{}, err } - row, err := s.q.MarkAttachmentReady(ctx, id) - if err != nil { + if err := tx.Commit(ctx); err != nil { return model.Attachment{}, err } diff --git a/internal/service/message.go b/internal/service/message.go index a6316e35..5e93e1f5 100644 --- a/internal/service/message.go +++ b/internal/service/message.go @@ -77,7 +77,7 @@ func (s *MessageService) Create( return model.Message{}, ErrAttachmentNotFound } for _, status := range statuses { - if status != db.AttachmentStatusReady { + if status == db.AttachmentStatusFailed { return model.Message{}, ErrAttachmentNotReady } } diff --git a/student-tests/reconcile_test.go b/student-tests/reconcile_test.go index a95234c4..d5f3543a 100644 --- a/student-tests/reconcile_test.go +++ b/student-tests/reconcile_test.go @@ -6,7 +6,6 @@ import ( "bytes" "context" "encoding/json" - "io" "net/http" "os" "os/exec" @@ -62,7 +61,7 @@ func runReconcile(t *testing.T, dryRun bool, grace string) reconcile.Report { if err := json.Unmarshal(output, &report); err != nil { t.Fatalf("decode reconcile report: %v\n%s", err, output) } - t.Logf("dry_run=%t objects=%d rows=%d list_pages=%d duration_ms=%d orphan=%d missing=%d stale=%d skipped_fresh=%d skipped_referenced=%d deleted_objects=%d deleted_rows=%d marked_failed=%d errors=%v", report.DryRun, report.ScannedObjects, report.ScannedRows, report.ListPages, report.DurationMS, len(report.OrphanObjects), len(report.MissingAttachments), len(report.StaleUploads), report.SkippedFresh, report.SkippedReferenced, report.DeletedObjects, report.DeletedRows, report.MarkedFailed, report.Errors) + t.Logf("dry_run=%t objects=%d rows=%d list_pages=%d duration_ms=%d orphan=%d missing=%d skipped_fresh=%d skipped_inactive=%d deleted_objects=%d marked_failed=%d errors=%v", report.DryRun, report.ScannedObjects, report.ScannedRows, report.ListPages, report.DurationMS, len(report.OrphanObjects), len(report.MissingAttachments), report.SkippedFresh, report.SkippedInactive, report.DeletedObjects, report.MarkedFailed, report.Errors) if len(report.Errors) != 0 { t.Fatal("reconciler reported errors") } @@ -86,7 +85,7 @@ func TestReconcileRepair(t *testing.T) { if !slices.Contains(dry.OrphanObjects, originalKey) || !slices.Contains(dry.MissingAttachments, att.ID) { t.Fatal("dry-run did not detect both injected inconsistencies") } - if dry.DeletedObjects != 0 || dry.DeletedRows != 0 || dry.MarkedFailed != 0 { + if dry.DeletedObjects != 0 || dry.MarkedFailed != 0 { t.Fatal("dry-run changed data") } var status, code string @@ -110,7 +109,7 @@ func TestReconcileRepair(t *testing.T) { if slices.Contains(again.OrphanObjects, originalKey) || slices.Contains(again.MissingAttachments, att.ID) { t.Fatal("fixture still requires repair on repeat") } - if again.DeletedObjects != 0 || again.DeletedRows != 0 || again.MarkedFailed != 0 { + if again.DeletedObjects != 0 || again.MarkedFailed != 0 { t.Fatal("repeat repair changed data; run on an idle test stand") } t.Log("PASS: dry-run preserved data; orphan deleted; missing marked failed; repeat made no changes") @@ -125,7 +124,7 @@ func TestReconcileSafety(t *testing.T) { resp := postMessage(t, user, chat.ID, "", []uuid.UUID{used.ID}) requireStatus(t, resp, http.StatusCreated) resp.Body.Close() - // Exercise both grace-period protection and protection of referenced queued uploads. + // Queued attachments must be preserved regardless of age or message references. reconcileSQL(t, conn, "UPDATE attachments SET status='queued' WHERE id=$1", fresh.ID) reconcileSQL(t, conn, "UPDATE attachments SET status='queued', created_at=now()-interval '2 hours' WHERE id=$1", used.ID) t.Cleanup(func() { @@ -135,8 +134,8 @@ func TestReconcileSafety(t *testing.T) { }) for _, dryRun := range []bool{true, false} { report := runReconcile(t, dryRun, "1h") - if report.SkippedFresh < 1 || report.SkippedReferenced < 1 { - t.Fatal("fresh/referenced protection was not exercised") + if report.SkippedInactive < 2 { + t.Fatal("queued attachment protection was not exercised") } for _, att := range []uuid.UUID{fresh.ID, used.ID} { var status string @@ -147,18 +146,11 @@ func TestReconcileSafety(t *testing.T) { t.Fatalf("protected fixture changed status: %s", status) } resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.String()+"/content", user.Token, nil) - requireStatus(t, resp, http.StatusOK) - data, err := io.ReadAll(resp.Body) + requireStatus(t, resp, http.StatusConflict) resp.Body.Close() - if err != nil { - t.Fatal(err) - } - if !bytes.Equal(data, makePNG(t, 32, 32)) { - t.Fatal("protected original changed") - } } } - t.Log("PASS: fresh and old referenced uploads preserved, originals unchanged") + t.Log("PASS: queued uploads preserved regardless of age or references; content remains unavailable") } func TestReconcileCost(t *testing.T) { -- 2.54.0 From 19152e7d18a83ade3586c6575d400558cd41fd6d Mon Sep 17 00:00:00 2001 From: kk10 Date: Sun, 15 Nov 2026 16:50:27 +0300 Subject: [PATCH 08/23] feat(worker): process attachments with thumbnails and bounded retries --- Dockerfile.worker | 13 + cmd/worker/main.go | 68 +++++ compose.yaml | 30 ++- db/queries/attachments.sql | 2 - go.mod | 8 +- go.sum | 18 +- internal/config/config.go | 14 + internal/db/attachments.sql.go | 15 +- internal/dto/attachment.go | 63 +++-- internal/handler/attachment.go | 2 +- internal/model/attachment.go | 28 +- internal/service/attachment.go | 44 +++- internal/worker/image.go | 152 +++++++++++ internal/worker/image_test.go | 122 +++++++++ internal/worker/worker.go | 465 +++++++++++++++++++++++++++++++++ 15 files changed, 994 insertions(+), 50 deletions(-) create mode 100644 Dockerfile.worker create mode 100644 cmd/worker/main.go create mode 100644 internal/worker/image.go create mode 100644 internal/worker/image_test.go create mode 100644 internal/worker/worker.go diff --git a/Dockerfile.worker b/Dockerfile.worker new file mode 100644 index 00000000..2e5281f1 --- /dev/null +++ b/Dockerfile.worker @@ -0,0 +1,13 @@ +FROM golang:1.27.1 AS build +WORKDIR /src + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -o /out/worker ./cmd/worker + +FROM gcr.io/distroless/static-debian12:nonroot +WORKDIR /app +COPY --from=build /out/worker . +ENTRYPOINT ["/app/worker"] diff --git a/cmd/worker/main.go b/cmd/worker/main.go new file mode 100644 index 00000000..069cef72 --- /dev/null +++ b/cmd/worker/main.go @@ -0,0 +1,68 @@ +package main + +import ( + "context" + "fmt" + "os" + "os/signal" + "syscall" + + "github.com/joho/godotenv" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/logger" + "mtusi2026-messenger/internal/postgres" + s3store "mtusi2026-messenger/internal/s3" + "mtusi2026-messenger/internal/worker" +) + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, "worker:", err) + os.Exit(1) + } +} + +func run() error { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + return err + } + + cfg := config.Load() + log := logger.New(cfg.Logging.Level) + databaseURL, err := cfg.Database.URL() + if err != nil { + return err + } + + brokerURL, err := cfg.Broker.URL() + if err != nil { + return err + } + + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + + pool, err := postgres.New(ctx, databaseURL) + if err != nil { + return err + } + defer pool.Close() + + storage, err := s3store.New(ctx, cfg.S3, log) + if err != nil { + return err + } + + worker.New( + pool, + storage, + brokerURL, + config.LoadWorker(), + cfg.S3.MaxUploadBytes, + cfg.S3.MaxImagePixels, + log, + ).Run(ctx) + + return nil +} diff --git a/compose.yaml b/compose.yaml index ed54f2b3..253d5890 100644 --- a/compose.yaml +++ b/compose.yaml @@ -3,7 +3,7 @@ services: build: context: . dockerfile: Dockerfile - image: mtusi-messenger:lab4 + image: mtusi-messenger:lab5 env_file: - .env secrets: @@ -27,6 +27,34 @@ services: condition: service_healthy restart: unless-stopped + worker: + build: + context: . + dockerfile: Dockerfile.worker + image: mtusi-messenger-worker:lab5 + env_file: + - .env + secrets: + - database_url + - broker_url + - s3_access_key_id + - s3_secret_access_key + - s3_bootstrap_access_key_id + - s3_bootstrap_secret_access_key + deploy: + resources: + limits: + cpus: "1.0" + memory: 1G + depends_on: + migrate: + condition: service_completed_successfully + s3: + condition: service_healthy + rabbitmq: + condition: service_healthy + restart: unless-stopped + postgres: image: postgres:18.6 ports: diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index d1d85ede..42accee7 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -121,8 +121,6 @@ UPDATE attachments SET status = 'ready', error_code = NULL, lease_until = NULL, - width = sqlc.arg(width)::int, - height = sqlc.arg(height)::int, updated_at = now() WHERE id = sqlc.arg(id)::uuid AND status = 'processing' diff --git a/go.mod b/go.mod index 6f58293f..2ec5a2f6 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( github.com/aws/aws-sdk-go-v2/credentials v1.20.13 github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6 github.com/aws/smithy-go v1.28.7 + github.com/disintegration/imaging v1.6.2 github.com/go-chi/chi/v5 v5.5.0 github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.11.0 @@ -36,7 +37,8 @@ require ( github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect go.uber.org/atomic v1.12.0 // indirect - golang.org/x/sync v0.24.0 // indirect - golang.org/x/sys v0.49.0 // indirect - golang.org/x/text v0.43.0 // indirect + golang.org/x/image v0.48.0 // indirect + golang.org/x/sync v0.25.0 // indirect + golang.org/x/sys v0.50.0 // indirect + golang.org/x/text v0.44.0 // indirect ) diff --git a/go.sum b/go.sum index a7ad7b9f..aa655493 100644 --- a/go.sum +++ b/go.sum @@ -41,6 +41,8 @@ github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0 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/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c= +github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4= github.com/go-chi/chi/v5 v5.5.0 h1:xdKQ1dJmVJsmgahrXSKhUx8NyVPzpwdlyrrQFpMPJgg= github.com/go-chi/chi/v5 v5.5.0/go.mod h1:d1IG7GtKPSjPyBP365PH8sAGVHk3qfB/IhjFNRH1wWM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= @@ -77,11 +79,15 @@ go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= -golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= -golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= -golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= -golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= -golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= -golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.48.0 h1:1AvuPcuoOTJpA7s4VZ5umrb90T3So0rkB/bSGmxkxik= +golang.org/x/image v0.48.0/go.mod h1:mmtg64iqJKGqEgy+r13dfybl85tmxUd2lMnmaiSdWYY= +golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs= +golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs= +golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo= +golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY= 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= diff --git a/internal/config/config.go b/internal/config/config.go index 68177fc9..68dc214c 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -141,6 +141,20 @@ func LoadS3() S3Config { } } +type WorkerConfig struct { + Concurrency int + MaxAttempts int + Timeout time.Duration +} + +func LoadWorker() WorkerConfig { + return WorkerConfig{ + Concurrency: getEnvPositiveInt("WORKER_CONCURRENCY", 2), + MaxAttempts: getEnvPositiveInt("JOB_MAX_ATTEMPTS", 5), + Timeout: time.Duration(getEnvPositiveInt("JOB_TIMEOUT_SECONDS", 60)) * time.Second, + } +} + func getEnv(key, def string) string { value := os.Getenv(key) if value == "" { diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index a3f4cb5f..f22409b7 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -72,29 +72,20 @@ UPDATE attachments SET status = 'ready', error_code = NULL, lease_until = NULL, - width = $1::int, - height = $2::int, updated_at = now() -WHERE id = $3::uuid +WHERE id = $1::uuid AND status = 'processing' - AND attempts = $4::int + AND attempts = $2::int AND lease_until > now() ` type CompleteAttachmentJobParams struct { - Width int - Height int ID uuid.UUID Attempt int } func (q *Queries) CompleteAttachmentJob(ctx context.Context, arg CompleteAttachmentJobParams) (int64, error) { - result, err := q.db.Exec(ctx, completeAttachmentJob, - arg.Width, - arg.Height, - arg.ID, - arg.Attempt, - ) + result, err := q.db.Exec(ctx, completeAttachmentJob, arg.ID, arg.Attempt) if err != nil { return 0, err } diff --git a/internal/dto/attachment.go b/internal/dto/attachment.go index 996835f8..0a1f3692 100644 --- a/internal/dto/attachment.go +++ b/internal/dto/attachment.go @@ -19,27 +19,27 @@ type GetAttachmentContentRequest struct { } type VariantResponse struct { - Name string `json:"name"` - ContentType string `json:"content_type"` - SizeBytes int `json:"size_bytes"` - Width int `json:"width"` - Height int `json:"height"` - Sha256 string `json:"sha256"` + Name model.AttachmentVariantName `json:"name"` + ContentType model.ContentType `json:"content_type"` + SizeBytes int `json:"size_bytes"` + Width int `json:"width"` + Height int `json:"height"` + Sha256 string `json:"sha256"` } type AttachmentResponse struct { - ID uuid.UUID `json:"id"` - ChatID uuid.UUID `json:"chat_id"` - OwnerID uuid.UUID `json:"owner_id"` - Filename string `json:"filename"` - ContentType string `json:"content_type"` - SizeBytes int `json:"size_bytes"` - Sha256 string `json:"sha256"` - Status string `json:"status"` - Variants []VariantResponse `json:"variants"` - ErrorCode *string `json:"error_code"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` + ID uuid.UUID `json:"id"` + ChatID uuid.UUID `json:"chat_id"` + OwnerID uuid.UUID `json:"owner_id"` + Filename string `json:"filename"` + ContentType model.ContentType `json:"content_type"` + SizeBytes int `json:"size_bytes"` + Sha256 string `json:"sha256"` + Status model.AttachmentStatus `json:"status"` + Variants []VariantResponse `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` } func (r CreateAttachmentRequest) Validate() bool { @@ -57,20 +57,39 @@ func (r CreateAttachmentRequest) Validate() bool { } func (r GetAttachmentContentRequest) Validate() bool { - return r.Variant == "" || r.Variant == "original" + switch model.AttachmentVariantName(r.Variant) { + case "", + model.AttachmentContentOriginal, + model.AttachmentVariantNameThumbnail, + model.AttachmentVariantNameCrop, + model.AttachmentVariantNameOptimized: + return true + default: + return false + } } func ToAttachmentResponse(a model.Attachment) AttachmentResponse { - variants := make([]VariantResponse, 0) + variants := make([]VariantResponse, 0, len(a.Variants)) + for _, v := range a.Variants { + variants = append(variants, VariantResponse{ + Name: v.Name, + ContentType: v.ContentType, + SizeBytes: v.SizeBytes, + Width: v.Width, + Height: v.Height, + Sha256: v.Sha256, + }) + } return AttachmentResponse{ ID: a.ID, ChatID: a.ChatID, OwnerID: a.OwnerID, Filename: a.Filename, - ContentType: string(a.ContentType), + ContentType: a.ContentType, SizeBytes: a.SizeBytes, Sha256: a.Sha256, - Status: string(a.Status), + Status: a.Status, Variants: variants, ErrorCode: a.ErrorCode, CreatedAt: a.CreatedAt, diff --git a/internal/handler/attachment.go b/internal/handler/attachment.go index f0f35ccd..d71d759b 100644 --- a/internal/handler/attachment.go +++ b/internal/handler/attachment.go @@ -121,7 +121,7 @@ func (h *AttachmentHandler) GetContent(w http.ResponseWriter, r *http.Request) { return } - data, contentType, err := h.service.GetContent(r.Context(), userID, attachmentID) + data, contentType, err := h.service.GetContent(r.Context(), userID, attachmentID, req.Variant) switch { case errors.Is(err, service.ErrAttachmentNotReady): httpx.WriteError(w, http.StatusConflict, dto.ErrorCodeConflict, "attachment not ready", requestID) diff --git a/internal/model/attachment.go b/internal/model/attachment.go index c3c76ea4..c08fdf87 100644 --- a/internal/model/attachment.go +++ b/internal/model/attachment.go @@ -11,15 +11,39 @@ type ContentType string const ( ContentTypePNG ContentType = "image/png" ContentTypeJPEG ContentType = "image/jpeg" + ContentTypeWebP ContentType = "image/webp" ) type AttachmentStatus string const ( - AttachmentStatusReady AttachmentStatus = "ready" + AttachmentStatusQueued AttachmentStatus = "queued" + AttachmentStatusProcessing AttachmentStatus = "processing" + AttachmentStatusReady AttachmentStatus = "ready" + AttachmentStatusFailed AttachmentStatus = "failed" ) +const AttachmentContentOriginal = "original" + +type AttachmentVariantName string + +const ( + AttachmentVariantNameThumbnail AttachmentVariantName = "thumbnail" + AttachmentVariantNameCrop AttachmentVariantName = "crop" + AttachmentVariantNameOptimized AttachmentVariantName = "optimized" +) + +type AttachmentVariant struct { + Name AttachmentVariantName + ContentType ContentType + SizeBytes int + Width int + Height int + Sha256 string +} + type Attachment struct { + Variants []AttachmentVariant ID uuid.UUID ChatID uuid.UUID OwnerID uuid.UUID @@ -28,6 +52,8 @@ type Attachment struct { SizeBytes int Sha256 string Status AttachmentStatus + Width *int32 + Height *int32 ErrorCode *string CreatedAt time.Time UpdatedAt time.Time diff --git a/internal/service/attachment.go b/internal/service/attachment.go index 10f8f9bf..6fd37d62 100644 --- a/internal/service/attachment.go +++ b/internal/service/attachment.go @@ -35,6 +35,7 @@ type attachmentQueries interface { CreateAttachment(ctx context.Context, arg db.CreateAttachmentParams) (db.Attachment, error) CreateOutboxEntry(ctx context.Context, arg db.CreateOutboxEntryParams) (db.Outbox, error) GetAttachmentByID(ctx context.Context, id uuid.UUID) (db.Attachment, error) + ListAttachmentVariants(ctx context.Context, arg db.ListAttachmentVariantsParams) ([]db.AttachmentVariant, error) IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error) } @@ -183,6 +184,8 @@ func (s *AttachmentService) Upload( SizeBytes: row.SizeBytes, Sha256: row.Sha256, Status: model.AttachmentStatus(row.Status), + Width: row.Width, + Height: row.Height, ErrorCode: row.ErrorCode, CreatedAt: row.CreatedAt, UpdatedAt: row.UpdatedAt, @@ -205,7 +208,24 @@ func (s *AttachmentService) Get( return model.Attachment{}, err } + rows, err := s.q.ListAttachmentVariants(ctx, db.ListAttachmentVariantsParams{AttachmentID: row.ID, PipelineVersion: row.PipelineVersion}) + if err != nil { + return model.Attachment{}, err + } + variants := make([]model.AttachmentVariant, 0, len(rows)) + for _, v := range rows { + variants = append(variants, model.AttachmentVariant{ + Name: model.AttachmentVariantName(v.Variant), + ContentType: model.ContentType(v.ContentType), + SizeBytes: v.SizeBytes, + Width: v.Width, + Height: v.Height, + Sha256: v.Sha256, + }) + } + return model.Attachment{ + Variants: variants, ID: row.ID, ChatID: row.ChatID, OwnerID: row.OwnerID, @@ -214,6 +234,8 @@ func (s *AttachmentService) Get( SizeBytes: row.SizeBytes, Sha256: row.Sha256, Status: model.AttachmentStatus(row.Status), + Width: row.Width, + Height: row.Height, ErrorCode: row.ErrorCode, CreatedAt: row.CreatedAt, UpdatedAt: row.UpdatedAt, @@ -223,6 +245,7 @@ func (s *AttachmentService) Get( func (s *AttachmentService) GetContent( ctx context.Context, userID, attachmentID uuid.UUID, + variant string, ) ([]byte, model.ContentType, error) { row, err := s.q.GetAttachmentByID(ctx, attachmentID) if postgres.IsNotFound(err) { @@ -240,7 +263,24 @@ func (s *AttachmentService) GetContent( return nil, "", ErrAttachmentNotReady } - out, err := s.s3.Get(ctx, row.S3Key) + key, contentType := row.S3Key, model.ContentType(row.ContentType) + if variant != "" && variant != model.AttachmentContentOriginal { + rows, err := s.q.ListAttachmentVariants(ctx, db.ListAttachmentVariantsParams{AttachmentID: row.ID, PipelineVersion: row.PipelineVersion}) + if err != nil { + return nil, "", err + } + found := false + for _, v := range rows { + if string(v.Variant) == variant { + key, contentType, found = v.S3Key, model.ContentType(v.ContentType), true + break + } + } + if !found { + return nil, "", ErrAttachmentNotFound + } + } + out, err := s.s3.Get(ctx, key) if err != nil { return nil, "", err } @@ -251,7 +291,7 @@ func (s *AttachmentService) GetContent( return nil, "", err } - return data, model.ContentType(row.ContentType), nil + return data, contentType, nil } func (s *AttachmentService) checkImage(ctx context.Context, r io.ReadSeeker, contentType string) (model.ContentType, int, int, error) { diff --git a/internal/worker/image.go b/internal/worker/image.go new file mode 100644 index 00000000..2f2bccae --- /dev/null +++ b/internal/worker/image.go @@ -0,0 +1,152 @@ +package worker + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "image" + "image/color" + "image/draw" + "image/jpeg" + _ "image/png" + "io" + "os" + "strconv" + + "github.com/disintegration/imaging" + + "mtusi2026-messenger/internal/db" +) + +var errInvalidSource = errors.New("invalid source image") + +func thumbnail(r io.ReadSeeker, maxPixels int) ([]byte, int, int, error) { + cfg, format, err := image.DecodeConfig(r) + if err != nil || + (format != "png" && format != "jpeg") || + cfg.Width <= 0 || + cfg.Height <= 0 || + cfg.Width > maxPixels/cfg.Height { + return nil, 0, 0, errInvalidSource + } + + if _, err := r.Seek(0, io.SeekStart); err != nil { + return nil, 0, 0, err + } + + src, err := imaging.Decode(r, imaging.AutoOrientation(true)) + if err != nil { + return nil, 0, 0, errInvalidSource + } + + width, height := src.Bounds().Dx(), src.Bounds().Dy() + if width > 256 || height > 256 { + if width >= height { + height = max(1, height*256/width) + width = 256 + } else { + width = max(1, width*256/height) + height = 256 + } + + src = imaging.Resize(src, width, height, imaging.Lanczos) + } + + dst := image.NewRGBA(image.Rect(0, 0, width, height)) + draw.Draw(dst, dst.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src) + draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over) + + var out bytes.Buffer + if err := jpeg.Encode(&out, dst, &jpeg.Options{Quality: 85}); err != nil { + return nil, 0, 0, err + } + + return out.Bytes(), width, height, nil +} + +func (w *Worker) process(ctx context.Context, row db.Attachment) (db.CreateAttachmentVariantParams, error) { + if row.StagingKey == nil { + return db.CreateAttachmentVariantParams{}, errInvalidSource + } + + source, err := w.s3.Get(ctx, *row.StagingKey) + if err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + defer source.Body.Close() + + tmp, err := os.CreateTemp("", "attachment-job-*") + if err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + defer func() { + _ = tmp.Close() + _ = os.Remove(tmp.Name()) + }() + + hash := sha256.New() + size, err := io.Copy(io.MultiWriter(tmp, hash), io.LimitReader(source.Body, int64(w.maxBytes)+1)) + if err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + if size != int64(row.SizeBytes) || + hex.EncodeToString(hash.Sum(nil)) != row.Sha256 { + return db.CreateAttachmentVariantParams{}, errInvalidSource + } + + if _, err := tmp.Seek(0, io.SeekStart); err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + select { + case w.decodeSlot <- struct{}{}: + case <-ctx.Done(): + return db.CreateAttachmentVariantParams{}, ctx.Err() + } + + if err := ctx.Err(); err != nil { + <-w.decodeSlot + return db.CreateAttachmentVariantParams{}, err + } + + data, width, height, err := thumbnail(tmp, w.maxPixels) + <-w.decodeSlot + if err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + if err := ctx.Err(); err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + if _, err := tmp.Seek(0, io.SeekStart); err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + if err := w.s3.Put(ctx, row.S3Key, tmp, size, string(row.ContentType)); err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/thumbnail" + if err := w.s3.Put(ctx, key, bytes.NewReader(data), int64(len(data)), "image/jpeg"); err != nil { + return db.CreateAttachmentVariantParams{}, err + } + + sum := sha256.Sum256(data) + return db.CreateAttachmentVariantParams{ + AttachmentID: row.ID, + PipelineVersion: row.PipelineVersion, + Variant: db.AttachmentVariantNameThumbnail, + S3Key: key, + ContentType: "image/jpeg", + SizeBytes: len(data), + Width: width, + Height: height, + Sha256: hex.EncodeToString(sum[:]), + }, nil +} diff --git a/internal/worker/image_test.go b/internal/worker/image_test.go new file mode 100644 index 00000000..5292733d --- /dev/null +++ b/internal/worker/image_test.go @@ -0,0 +1,122 @@ +package worker + +import ( + "bytes" + "encoding/binary" + "image" + "image/color" + "image/jpeg" + "image/png" + "testing" +) + +func TestThumbnail(t *testing.T) { + for _, tc := range []struct { + name string + width, height, wantWidth, wantHeight int + }{ + {"landscape", 320, 200, 256, 160}, {"portrait", 201, 321, 160, 256}, + {"small", 12, 7, 12, 7}, {"thin", 1, 1000, 1, 256}, + } { + t.Run(tc.name, func(t *testing.T) { + var source bytes.Buffer + if err := png.Encode(&source, image.NewNRGBA(image.Rect(0, 0, tc.width, tc.height))); err != nil { + t.Fatal(err) + } + + data, width, height, err := thumbnail(bytes.NewReader(source.Bytes()), 40000000) + if err != nil { + t.Fatal(err) + } + + if width != tc.wantWidth || height != tc.wantHeight { + t.Fatalf("got %dx%d", width, height) + } + + decoded, err := jpeg.Decode(bytes.NewReader(data)) + if err != nil { + t.Fatal(err) + } + + if decoded.Bounds().Dx() != width || decoded.Bounds().Dy() != height { + t.Fatal("JPEG dimensions disagree") + } + + r, g, b, _ := decoded.At(0, 0).RGBA() + if r < 65000 || g < 65000 || b < 65000 { + t.Fatal("transparent source was not composited on white") + } + }) + } +} + +func TestThumbnailEXIF(t *testing.T) { + src := image.NewRGBA(image.Rect(0, 0, 40, 20)) + + for y := 0; y < 20; y++ { + for x := 0; x < 40; x++ { + c := color.RGBA{255, 0, 0, 255} + if x >= 20 { + c = color.RGBA{0, 0, 255, 255} + } + + src.Set(x, y, c) + } + } + + var original bytes.Buffer + if err := jpeg.Encode(&original, src, nil); err != nil { + t.Fatal(err) + } + + // Little-endian TIFF, orientation=6 (90 degrees clockwise). + exif := []byte{ + 'E', 'x', 'i', 'f', 0, 0, 'I', 'I', + 42, 0, 8, 0, 0, 0, 1, 0, + 0x12, 1, 3, 0, 1, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + } + segment := []byte{0xff, 0xe1, 0, 0} + binary.BigEndian.PutUint16(segment[2:], uint16(len(exif)+2)) + data := append([]byte{}, original.Bytes()[:2]...) + data = append(data, segment...) + data = append(data, exif...) + data = append(data, original.Bytes()[2:]...) + result, width, height, err := thumbnail(bytes.NewReader(data), 40000000) + if err != nil { + t.Fatal(err) + } + + if width != 20 || height != 40 { + t.Fatalf("orientation ignored: %dx%d", width, height) + } + + decoded, err := jpeg.Decode(bytes.NewReader(result)) + if err != nil { + t.Fatal(err) + } + + r, _, b, _ := decoded.At(10, 5).RGBA() + if r <= b { + t.Fatal("incorrect EXIF rotation") + } + + if bytes.Contains(result, []byte("Exif")) { + t.Fatal("EXIF retained") + } +} + +func TestThumbnailRejectsInvalidSource(t *testing.T) { + var source bytes.Buffer + if err := png.Encode(&source, image.NewNRGBA(image.Rect(0, 0, 100, 100))); err != nil { + t.Fatal(err) + } + + if _, _, _, err := thumbnail(bytes.NewReader(source.Bytes()), 9999); err == nil { + t.Fatal("pixel limit ignored") + } + + if _, _, _, err := thumbnail(bytes.NewReader(source.Bytes()[:20]), 40000000); err == nil { + t.Fatal("truncated image accepted") + } +} diff --git a/internal/worker/worker.go b/internal/worker/worker.go new file mode 100644 index 00000000..9a14ad41 --- /dev/null +++ b/internal/worker/worker.go @@ -0,0 +1,465 @@ +package worker + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "io" + "log/slog" + "math/rand/v2" + "sync" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + amqp "github.com/rabbitmq/amqp091-go" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/rabbitmq" + s3store "mtusi2026-messenger/internal/s3" +) + +var ( + errLeaseExpired = errors.New("attachment lease expired") + errMissingThumbnail = errors.New("ready attachment has no thumbnail") + errAttemptProcessing = errors.New("attachment attempt is still processing") + errAttemptUnavailable = errors.New("attachment attempt is not yet available") + errEffectChecksumMismatch = errors.New("attachment effect checksum mismatch") +) + +type Worker struct { + pool *pgxpool.Pool + q *db.Queries + s3 *s3store.Client + brokerURL string + cfg config.WorkerConfig + maxBytes, maxPixels int + decodeSlot chan struct{} + log *slog.Logger +} + +func New( + pool *pgxpool.Pool, + s3 *s3store.Client, + brokerURL string, + cfg config.WorkerConfig, + maxBytes, maxPixels int, + log *slog.Logger, +) *Worker { + return &Worker{ + pool: pool, + q: db.New(pool), + s3: s3, + brokerURL: brokerURL, + cfg: cfg, + maxBytes: maxBytes, + maxPixels: maxPixels, + decodeSlot: make(chan struct{}, 1), + log: log, + } +} + +func (w *Worker) Run(ctx context.Context) { + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer wg.Done() + + w.recoverLoop(ctx) + }() + + for range w.cfg.Concurrency { + wg.Add(1) + go func() { + defer wg.Done() + + w.consumeLoop(ctx) + }() + } + + wg.Wait() +} + +func (w *Worker) consumeLoop(ctx context.Context) { + for ctx.Err() == nil { + client, err := rabbitmq.New(w.brokerURL) + if err == nil { + err = w.consume(ctx, client) + _ = client.Close() + } + + if ctx.Err() != nil { + return + } + + w.log.Warn("worker consumer reconnect", "error", err) + if !wait(ctx, 2*time.Second) { + return + } + } +} + +func (w *Worker) consume(ctx context.Context, client *rabbitmq.Client) error { + stop := context.AfterFunc(ctx, func() { + _ = client.Close() + }) + defer stop() + + deliveries, err := client.Consume(ctx, 1) + if err != nil { + return err + } + + for { + select { + case <-ctx.Done(): + return ctx.Err() + case delivery, ok := <-deliveries: + if !ok { + return amqp.ErrClosed + } + + var job model.AttachmentJob + if json.Unmarshal(delivery.Body, &job) != nil || + job.SchemaVersion != 1 || + job.Type != "attachment.process.v1" || + job.JobID == uuid.Nil || + job.AttachmentID == uuid.Nil || + job.PipelineVersion != 1 || + job.Attempt < 1 || + job.CreatedAt.IsZero() { + if err := delivery.Reject(false); err != nil { + return err + } + + w.log.Warn("invalid attachment job rejected") + continue + } + + err := w.handle(ctx, job) + if err == nil { + if err := delivery.Ack(false); err != nil { + return err + } + } else { + if ctx.Err() != nil { + return ctx.Err() + } + + w.log.Warn( + "attachment job not acknowledged", + "job_id", + job.JobID, + "attempt", + job.Attempt, + "error", + err, + ) + if !wait(ctx, time.Second) { + return ctx.Err() + } + + if err := delivery.Nack(false, true); err != nil { + return err + } + } + } + } +} + +func (w *Worker) handle(ctx context.Context, job model.AttachmentJob) error { + jobCtx, cancel := context.WithTimeout(ctx, w.cfg.Timeout) + defer cancel() + + row, err := w.q.ClaimAttachmentJob(jobCtx, db.ClaimAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + LeaseUntil: time.Now().Add(w.cfg.Timeout), + }) + if errors.Is(err, pgx.ErrNoRows) { + return w.duplicate(jobCtx, job) + } + + if err != nil { + return err + } + + w.log.Info("attachment processing", "job_id", job.JobID, "attachment_id", row.ID, "attempt", job.Attempt) + variant, processErr := w.process(jobCtx, row) + if processErr != nil { + resultCtx, resultCancel := context.WithTimeout(ctx, 5*time.Second) + defer resultCancel() + + return w.finishFailure(resultCtx, job, processErr) + } + + tx, err := w.pool.Begin(jobCtx) + if err != nil { + return err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + _, err = q.LockAttachmentJob(jobCtx, db.LockAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + if err := q.CreateAttachmentVariant(jobCtx, variant); err != nil { + return err + } + + n, err := q.CompleteAttachmentJob(jobCtx, db.CompleteAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + if n != 1 { + return errLeaseExpired + } + + if err := tx.Commit(jobCtx); err != nil { + return err + } + + w.log.Info("attachment ready", "job_id", job.JobID, "attachment_id", row.ID, "attempt", job.Attempt) + return nil +} + +func (w *Worker) duplicate(ctx context.Context, job model.AttachmentJob) error { + row, err := w.q.GetAttachmentByID(ctx, job.AttachmentID) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + + if err != nil { + return err + } + + if row.JobID == nil || *row.JobID != job.JobID || row.PipelineVersion != job.PipelineVersion { + return nil + } + + if row.Status == db.AttachmentStatusFailed { + return nil + } + + if row.Status == db.AttachmentStatusReady { + variants, err := w.q.ListAttachmentVariants(ctx, db.ListAttachmentVariantsParams{ + AttachmentID: row.ID, + PipelineVersion: row.PipelineVersion, + }) + if err != nil { + return err + } + + if err := w.verify(ctx, row.S3Key, row.SizeBytes, row.Sha256); err != nil { + return err + } + + for _, variant := range variants { + if variant.Variant == db.AttachmentVariantNameThumbnail { + return w.verify(ctx, variant.S3Key, variant.SizeBytes, variant.Sha256) + } + } + + return errMissingThumbnail + } + + if row.Status == db.AttachmentStatusProcessing && row.Attempts == job.Attempt { + return errAttemptProcessing + } + + if row.Attempts >= job.Attempt { + return nil + } + + return errAttemptUnavailable +} + +func (w *Worker) verify(ctx context.Context, key string, size int, checksum string) error { + object, err := w.s3.Get(ctx, key) + if err != nil { + return err + } + + defer object.Body.Close() + + hash := sha256.New() + n, err := io.Copy(hash, io.LimitReader(object.Body, int64(size)+1)) + if err != nil { + return err + } + + if n != int64(size) || hex.EncodeToString(hash.Sum(nil)) != checksum { + return errEffectChecksumMismatch + } + + return nil +} + +func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cause error) error { + tx, err := w.pool.Begin(ctx) + if err != nil { + return err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + row, err := q.LockAttachmentJob(ctx, db.LockAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + code := "processing_failed" + permanent := errors.Is(cause, errInvalidSource) || errors.Is(cause, s3store.ErrObjectNotFound) + if permanent { + code = "invalid_source" + } else if errors.Is(cause, context.DeadlineExceeded) { + code = "job_timeout" + } + + var n int64 + if permanent || row.Attempts >= w.cfg.MaxAttempts { + if !permanent { + code = "retry_exhausted" + } + + n, err = q.FailAttachmentJob(ctx, db.FailAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + ErrorCode: code, + }) + } else { + n, err = q.RetryAttachmentJob(ctx, db.RetryAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + ErrorCode: code, + }) + if err == nil && n == 1 { + _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: row.ID, + Attempt: row.Attempts + 1, + AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + }) + } + } + + if err != nil { + return err + } + + if n != 1 { + return errLeaseExpired + } + + if err := tx.Commit(ctx); err != nil { + return err + } + + w.log.Warn( + "attachment processing failed", + "job_id", + job.JobID, + "attempt", + job.Attempt, + "error_code", + code, + ) + return nil +} + +func (w *Worker) recoverLoop(ctx context.Context) { + for ctx.Err() == nil { + recovered, err := w.recoverOne(ctx) + if err != nil && ctx.Err() == nil { + w.log.Warn("recover attachment lease", "error", err) + } + + if (err != nil || !recovered) && !wait(ctx, time.Second) { + return + } + } +} + +func (w *Worker) recoverOne(ctx context.Context) (bool, error) { + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + tx, err := w.pool.Begin(ctx) + if err != nil { + return false, err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + rows, err := q.LockExpiredAttachmentJobs(ctx, 1) + if err != nil || len(rows) == 0 { + return false, err + } + + row := rows[0] + if row.Attempts >= w.cfg.MaxAttempts { + _, err = q.FailExpiredAttachmentJob(ctx, row.ID) + } else { + _, err = q.RecoverExpiredAttachmentJob(ctx, row.ID) + if err == nil { + _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: row.ID, + Attempt: row.Attempts + 1, + AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + }) + } + } + + if err != nil { + return false, err + } + + if err := tx.Commit(ctx); err != nil { + return false, err + } + + w.log.Info("attachment lease recovered", "attachment_id", row.ID, "attempt", row.Attempts) + return true, nil +} + +func wait(ctx context.Context, duration time.Duration) bool { + timer := time.NewTimer(duration) + defer timer.Stop() + + select { + case <-ctx.Done(): + return false + case <-timer.C: + return true + } +} + +func retryDelay(attempt int) time.Duration { + ceiling := time.Second * time.Duration(1< Date: Mon, 16 Nov 2026 11:48:30 +0300 Subject: [PATCH 09/23] feat: clean up staging objects after processing and during reconciliation --- cmd/reconcile/main.go | 15 +++-- db/queries/attachments.sql | 14 ++-- internal/config/config.go | 2 + internal/db/attachments.sql.go | 92 +++++++++++++++----------- internal/reconcile/reconcile.go | 111 +++++++++++++++++++++++++++----- internal/reconcile/staging.go | 60 +++++++++++++++++ internal/worker/worker.go | 42 ++++++++++++ 7 files changed, 270 insertions(+), 66 deletions(-) create mode 100644 internal/reconcile/staging.go diff --git a/cmd/reconcile/main.go b/cmd/reconcile/main.go index 131741f3..79db14c9 100644 --- a/cmd/reconcile/main.go +++ b/cmd/reconcile/main.go @@ -59,12 +59,13 @@ func run() error { return err } - reconciler := reconcile.New(s3Client, db.New(pool), log) + reconciler := reconcile.New(pool, s3Client, db.New(pool), log) report, err := reconciler.Run(ctx, reconcile.Options{ - DryRun: *dryRun, - Grace: *grace, - MaxDeletes: *maxDeletes, + DryRun: *dryRun, + Grace: *grace, + MaxDeletes: *maxDeletes, + StagingRetention: cfg.S3.StagingRetention, }) if err != nil { return err @@ -96,7 +97,8 @@ func printReport(report reconcile.Report) { report.ListPages, ) fmt.Printf( - "found orphan_objects=%d missing_attachments=%d corrupt_objects=%d\n", + "found staging_objects=%d orphan_objects=%d missing_attachments=%d corrupt_objects=%d\n", + len(report.StagingObjects), len(report.OrphanObjects), len(report.MissingAttachments), len(report.CorruptObjects), @@ -112,6 +114,9 @@ func printReport(report reconcile.Report) { report.MarkedFailed, ) + for _, key := range report.StagingObjects { + fmt.Printf("staging_object %s\n", key) + } for _, key := range report.OrphanObjects { fmt.Printf("orphan_object %s\n", key) } diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index 42accee7..8a26c771 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -50,6 +50,11 @@ INSERT INTO message_attachments ( SELECT * FROM attachments WHERE id = $1::uuid; +-- name: LockAttachmentByStagingKey :one +SELECT * FROM attachments +WHERE staging_key = sqlc.arg(staging_key)::text +FOR UPDATE; + -- name: ListAttachmentsByIDs :many SELECT status FROM attachments @@ -69,7 +74,7 @@ WHERE message_id = ANY(sqlc.arg(message_ids)::uuid[]) ORDER BY message_id, position; -- name: ListAttachmentsForReconcile :many -SELECT id, s3_key, status, size_bytes +SELECT id, s3_key, staging_key, status, size_bytes, updated_at FROM attachments; -- name: LockAttachmentJob :one @@ -90,11 +95,10 @@ ORDER BY lease_until, id LIMIT sqlc.arg(batch_size)::int FOR UPDATE SKIP LOCKED; --- name: MarkAttachmentReady :one +-- name: ClearAttachmentStagingKey :exec UPDATE attachments -SET status = 'ready', updated_at = now() -WHERE id = sqlc.arg(id)::uuid -RETURNING *; +SET staging_key = NULL +WHERE id = sqlc.arg(id)::uuid; -- name: MarkAttachmentFailedIfReady :execrows UPDATE attachments diff --git a/internal/config/config.go b/internal/config/config.go index 68dc214c..437d0db6 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -76,6 +76,7 @@ type S3Config struct { BootstrapSecretKeyFile string MaxUploadBytes int MaxImagePixels int + StagingRetention time.Duration } func (c S3Config) APIAccessKey() (string, error) { @@ -138,6 +139,7 @@ func LoadS3() S3Config { BootstrapSecretKeyFile: getEnv("S3_BOOTSTRAP_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_bootstrap_secret_access_key"), MaxUploadBytes: getEnvPositiveInt("MAX_UPLOAD_BYTES", 10485760), MaxImagePixels: getEnvPositiveInt("MAX_IMAGE_PIXELS", 40000000), + StagingRetention: time.Duration(getEnvPositiveInt("STAGING_RETENTION_SECONDS", 86400)) * time.Second, } } diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index f22409b7..9e2f8da4 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -67,6 +67,17 @@ func (q *Queries) ClaimAttachmentJob(ctx context.Context, arg ClaimAttachmentJob return i, err } +const clearAttachmentStagingKey = `-- name: ClearAttachmentStagingKey :exec +UPDATE attachments +SET staging_key = NULL +WHERE id = $1::uuid +` + +func (q *Queries) ClearAttachmentStagingKey(ctx context.Context, id uuid.UUID) error { + _, err := q.db.Exec(ctx, clearAttachmentStagingKey, id) + return err +} + const completeAttachmentJob = `-- name: CompleteAttachmentJob :execrows UPDATE attachments SET status = 'ready', @@ -320,15 +331,17 @@ func (q *Queries) ListAttachmentsByIDs(ctx context.Context, arg ListAttachmentsB } const listAttachmentsForReconcile = `-- name: ListAttachmentsForReconcile :many -SELECT id, s3_key, status, size_bytes +SELECT id, s3_key, staging_key, status, size_bytes, updated_at FROM attachments ` type ListAttachmentsForReconcileRow struct { - ID uuid.UUID - S3Key string - Status AttachmentStatus - SizeBytes int + ID uuid.UUID + S3Key string + StagingKey *string + Status AttachmentStatus + SizeBytes int + UpdatedAt time.Time } func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttachmentsForReconcileRow, error) { @@ -343,8 +356,10 @@ func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttach if err := rows.Scan( &i.ID, &i.S3Key, + &i.StagingKey, &i.Status, &i.SizeBytes, + &i.UpdatedAt, ); err != nil { return nil, err } @@ -415,6 +430,39 @@ func (q *Queries) ListMessageAttachmentsByMessageIDs(ctx context.Context, messag return items, nil } +const lockAttachmentByStagingKey = `-- name: LockAttachmentByStagingKey :one +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +WHERE staging_key = $1::text +FOR UPDATE +` + +func (q *Queries) LockAttachmentByStagingKey(ctx context.Context, stagingKey string) (Attachment, error) { + row := q.db.QueryRow(ctx, lockAttachmentByStagingKey, stagingKey) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.Width, + &i.Height, + &i.LeaseUntil, + ) + return i, err +} + const lockAttachmentJob = `-- name: LockAttachmentJob :one SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments WHERE id = $1::uuid @@ -535,40 +583,6 @@ func (q *Queries) MarkAttachmentFailedIfReady(ctx context.Context, arg MarkAttac return result.RowsAffected(), nil } -const markAttachmentReady = `-- name: MarkAttachmentReady :one -UPDATE attachments -SET status = 'ready', updated_at = now() -WHERE id = $1::uuid -RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until -` - -func (q *Queries) MarkAttachmentReady(ctx context.Context, id uuid.UUID) (Attachment, error) { - row := q.db.QueryRow(ctx, markAttachmentReady, id) - var i Attachment - err := row.Scan( - &i.ID, - &i.ChatID, - &i.OwnerID, - &i.S3Key, - &i.Filename, - &i.ContentType, - &i.SizeBytes, - &i.Sha256, - &i.Status, - &i.ErrorCode, - &i.CreatedAt, - &i.UpdatedAt, - &i.StagingKey, - &i.JobID, - &i.PipelineVersion, - &i.Attempts, - &i.Width, - &i.Height, - &i.LeaseUntil, - ) - return i, err -} - const recoverExpiredAttachmentJob = `-- name: RecoverExpiredAttachmentJob :execrows UPDATE attachments SET status = 'queued', diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go index d66bb560..2ab00006 100644 --- a/internal/reconcile/reconcile.go +++ b/internal/reconcile/reconcile.go @@ -8,28 +8,34 @@ import ( "time" "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" "mtusi2026-messenger/internal/db" s3store "mtusi2026-messenger/internal/s3" ) const ( - Prefix = "chats/" - DefaultGrace = time.Hour - DefaultMaxDeletes = 100 - ErrorCodeObjectMissing = "object_missing" + Prefix = "chats/" + StagingPrefix = "staging/" + DefaultStagingRetention = 24 * time.Hour + DefaultGrace = time.Hour + DefaultMaxDeletes = 100 + ErrorCodeObjectMissing = "object_missing" ) type Options struct { - DryRun bool - Grace time.Duration - MaxDeletes int + DryRun bool + Grace time.Duration + MaxDeletes int + StagingRetention time.Duration } type Report struct { ScannedObjects int `json:"scanned_objects"` ScannedRows int `json:"scanned_rows"` ListPages int `json:"list_pages"` + StagingObjects []string `json:"staging_objects"` OrphanObjects []string `json:"orphan_objects"` MissingAttachments []uuid.UUID `json:"missing_attachments"` CorruptObjects []string `json:"corrupt_objects"` @@ -47,32 +53,50 @@ type ObjectClient interface { DeleteAdmin(ctx context.Context, key string) error } +type txBeginner interface { + Begin(ctx context.Context) (pgx.Tx, error) +} + type AttachmentQueries interface { + LockAttachmentByStagingKey(ctx context.Context, stagingKey string) (db.Attachment, error) + ClearAttachmentStagingKey(ctx context.Context, id uuid.UUID) error ListAttachmentsForReconcile(ctx context.Context) ([]db.ListAttachmentsForReconcileRow, error) MarkAttachmentFailedIfReady(ctx context.Context, arg db.MarkAttachmentFailedIfReadyParams) (int64, error) } type Reconciler struct { - q AttachmentQueries - store ObjectClient - log *slog.Logger - now func() time.Time + pool txBeginner + q AttachmentQueries + withTx func(pgx.Tx) AttachmentQueries + store ObjectClient + log *slog.Logger + now func() time.Time } type plan struct { orphans []s3store.ObjectInfo + staging []s3store.ObjectInfo missing []db.ListAttachmentsForReconcileRow corrupt []s3store.ObjectInfo skippedFresh int skippedInactive int } -func New(store ObjectClient, queries AttachmentQueries, log *slog.Logger) *Reconciler { +func New( + pool *pgxpool.Pool, + store ObjectClient, + queries *db.Queries, + log *slog.Logger, +) *Reconciler { if log == nil { log = slog.Default() } return &Reconciler{ + pool: pool, + withTx: func(tx pgx.Tx) AttachmentQueries { + return queries.WithTx(tx) + }, store: store, q: queries, log: log, @@ -86,6 +110,7 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { report := Report{ OrphanObjects: []string{}, + StagingObjects: []string{}, MissingAttachments: []uuid.UUID{}, CorruptObjects: []string{}, DryRun: opts.DryRun, @@ -97,20 +122,28 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { return report, err } + staging, err := r.store.ListAll(ctx, StagingPrefix) + if err != nil { + return report, err + } + rows, err := r.q.ListAttachmentsForReconcile(ctx) if err != nil { return report, err } - report.ScannedObjects = len(listed.Objects) + report.ScannedObjects = len(listed.Objects) + len(staging.Objects) report.ScannedRows = len(rows) - report.ListPages = listed.Pages + report.ListPages = listed.Pages + staging.Pages - p := buildPlan(listed.Objects, rows, started, opts.Grace) + p := buildPlan(listed.Objects, staging.Objects, rows, started, opts) for _, obj := range p.orphans { report.OrphanObjects = append(report.OrphanObjects, obj.Key) } + for _, obj := range p.staging { + report.StagingObjects = append(report.StagingObjects, obj.Key) + } for _, obj := range p.corrupt { report.CorruptObjects = append(report.CorruptObjects, obj.Key) } @@ -134,6 +167,7 @@ func (r *Reconciler) Run(ctx context.Context, opts Options) (Report, error) { "scanned_rows", report.ScannedRows, "list_pages", report.ListPages, "orphan_objects", len(report.OrphanObjects), + "staging_objects", len(report.StagingObjects), "missing_attachments", len(report.MissingAttachments), "corrupt_objects", len(report.CorruptObjects), "deleted_objects", report.DeletedObjects, @@ -152,14 +186,19 @@ func (o Options) withDefaults() Options { o.MaxDeletes = DefaultMaxDeletes } + if o.StagingRetention <= 0 { + o.StagingRetention = DefaultStagingRetention + } + return o } func buildPlan( objects []s3store.ObjectInfo, + staging []s3store.ObjectInfo, rows []db.ListAttachmentsForReconcileRow, now time.Time, - grace time.Duration, + opts Options, ) plan { var p plan @@ -168,7 +207,12 @@ func buildPlan( byKey[obj.Key] = obj } + byStagingKey := make(map[string]db.ListAttachmentsForReconcileRow, len(rows)) for _, row := range rows { + if row.StagingKey != nil { + byStagingKey[*row.StagingKey] = row + } + obj, exists := byKey[row.S3Key] if exists { delete(byKey, row.S3Key) @@ -193,13 +237,35 @@ func buildPlan( } for _, obj := range byKey { - if now.Sub(obj.LastModified) < grace { + if now.Sub(obj.LastModified) < opts.Grace { p.skippedFresh++ continue } p.orphans = append(p.orphans, obj) } + for _, obj := range staging { + retainedSince := obj.LastModified + if row, exists := byStagingKey[obj.Key]; exists { + if row.Status != db.AttachmentStatusReady && row.Status != db.AttachmentStatusFailed { + p.skippedInactive++ + continue + } + + retainedSince = row.UpdatedAt + } + + if now.Sub(retainedSince) < opts.StagingRetention { + p.skippedFresh++ + continue + } + + p.staging = append(p.staging, obj) + } + + sort.Slice(p.staging, func(i, j int) bool { + return p.staging[i].Key < p.staging[j].Key + }) sort.Slice(p.orphans, func(i, j int) bool { return p.orphans[i].Key < p.orphans[j].Key }) @@ -243,4 +309,15 @@ func (r *Reconciler) apply(ctx context.Context, opts Options, p plan, report *Re report.MarkedFailed += int(marked) } + + for _, obj := range p.staging { + if report.DeletedObjects >= opts.MaxDeletes { + report.Errors = append(report.Errors, "max deletes reached") + break + } + + if err := r.cleanupStagingObject(ctx, obj, opts, report); err != nil { + report.Errors = append(report.Errors, fmt.Sprintf("cleanup staging %s: %v", obj.Key, err)) + } + } } diff --git a/internal/reconcile/staging.go b/internal/reconcile/staging.go new file mode 100644 index 00000000..63cafd29 --- /dev/null +++ b/internal/reconcile/staging.go @@ -0,0 +1,60 @@ +package reconcile + +import ( + "context" + "errors" + "time" + + "github.com/jackc/pgx/v5" + + "mtusi2026-messenger/internal/db" + s3store "mtusi2026-messenger/internal/s3" +) + +func (r *Reconciler) cleanupStagingObject( + ctx context.Context, + obj s3store.ObjectInfo, + opts Options, + report *Report, +) error { + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + tx, err := r.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(context.Background()) + + q := r.withTx(tx) + row, err := q.LockAttachmentByStagingKey(ctx, obj.Key) + orphan := errors.Is(err, pgx.ErrNoRows) + if err != nil && !orphan { + return err + } + + if !orphan { + if row.Status != db.AttachmentStatusReady && row.Status != db.AttachmentStatusFailed { + report.SkippedInactive++ + return nil + } + + if r.now().Sub(row.UpdatedAt) < opts.StagingRetention { + report.SkippedFresh++ + return nil + } + } + + if err := r.store.DeleteAdmin(ctx, obj.Key); err != nil { + return err + } + report.DeletedObjects++ + + if !orphan { + if err := q.ClearAttachmentStagingKey(ctx, row.ID); err != nil { + return err + } + } + + return tx.Commit(ctx) +} diff --git a/internal/worker/worker.go b/internal/worker/worker.go index 9a14ad41..4fbf6fd3 100644 --- a/internal/worker/worker.go +++ b/internal/worker/worker.go @@ -238,6 +238,13 @@ func (w *Worker) handle(ctx context.Context, job model.AttachmentJob) error { return err } + if row.StagingKey != nil { + err := w.deleteStagingObject(ctx, *row.StagingKey) + if err != nil && ctx.Err() == nil { + w.log.Warn("delete ready attachment staging", "attachment_id", row.ID, "error", err) + } + } + w.log.Info("attachment ready", "job_id", job.JobID, "attachment_id", row.ID, "attempt", job.Attempt) return nil } @@ -391,6 +398,41 @@ func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cau return nil } +func (w *Worker) deleteStagingObject(ctx context.Context, key string) error { + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + tx, err := w.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + row, err := q.LockAttachmentByStagingKey(ctx, key) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + + if err != nil { + return err + } + + if row.Status != db.AttachmentStatusReady { + return nil + } + + if err := w.s3.DeleteAdmin(ctx, key); err != nil { + return err + } + + if err := q.ClearAttachmentStagingKey(ctx, row.ID); err != nil { + return err + } + + return tx.Commit(ctx) +} + func (w *Worker) recoverLoop(ctx context.Context) { for ctx.Err() == nil { recovered, err := w.recoverOne(ctx) -- 2.54.0 From 4a6176fe817e3db3b4cbd15568c3102763c3d976 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 11:58:32 +0300 Subject: [PATCH 10/23] fix(worker): remove dependency on S3 bootstrap credentials --- cmd/worker/main.go | 2 +- compose.yaml | 2 -- internal/s3/client.go | 46 ++++++++++++++++++++++++++------------- internal/worker/worker.go | 2 +- 4 files changed, 33 insertions(+), 19 deletions(-) diff --git a/cmd/worker/main.go b/cmd/worker/main.go index 069cef72..9254e32a 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -49,7 +49,7 @@ func run() error { } defer pool.Close() - storage, err := s3store.New(ctx, cfg.S3, log) + storage, err := s3store.NewAPI(ctx, cfg.S3, log) if err != nil { return err } diff --git a/compose.yaml b/compose.yaml index 253d5890..1e160378 100644 --- a/compose.yaml +++ b/compose.yaml @@ -39,8 +39,6 @@ services: - broker_url - s3_access_key_id - s3_secret_access_key - - s3_bootstrap_access_key_id - - s3_bootstrap_secret_access_key deploy: resources: limits: diff --git a/internal/s3/client.go b/internal/s3/client.go index c51188c4..75c2adc5 100644 --- a/internal/s3/client.go +++ b/internal/s3/client.go @@ -50,15 +50,8 @@ type ListResult struct { } func New(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client, error) { - apiAccessKey, err := cfg.APIAccessKey() + c, err := NewAPI(ctx, cfg, log) if err != nil { - log.Error("read s3 api access key", "error", err) - return nil, err - } - - apiSecretKey, err := cfg.APISecretKey() - if err != nil { - log.Error("read s3 api secret key", "error", err) return nil, err } @@ -74,21 +67,36 @@ func New(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client return nil, err } - bootstrap, err := newS3Client(ctx, log, cfg.Endpoint, cfg.Region, bootstrapAccessKey, bootstrapSecretKey) + c.bootstrap, err = newS3Client(ctx, log, cfg.Endpoint, cfg.Region, bootstrapAccessKey, bootstrapSecretKey) if err != nil { return nil, err } + return c, nil +} + +func NewAPI(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client, error) { + apiAccessKey, err := cfg.APIAccessKey() + if err != nil { + log.Error("read s3 api access key", "error", err) + return nil, err + } + + apiSecretKey, err := cfg.APISecretKey() + if err != nil { + log.Error("read s3 api secret key", "error", err) + return nil, err + } + api, err := newS3Client(ctx, log, cfg.Endpoint, cfg.Region, apiAccessKey, apiSecretKey) if err != nil { return nil, err } return &Client{ - bucket: cfg.Bucket, - bootstrap: bootstrap, - api: api, - log: log, + bucket: cfg.Bucket, + api: api, + log: log, }, nil } @@ -198,7 +206,15 @@ func (c *Client) ListAll(ctx context.Context, prefix string) (ListResult, error) } func (c *Client) DeleteAdmin(ctx context.Context, key string) error { - _, err := c.bootstrap.DeleteObject(ctx, &awss3.DeleteObjectInput{ + return c.deleteObject(ctx, c.bootstrap, key) +} + +func (c *Client) Delete(ctx context.Context, key string) error { + return c.deleteObject(ctx, c.api, key) +} + +func (c *Client) deleteObject(ctx context.Context, client *awss3.Client, key string) error { + _, err := client.DeleteObject(ctx, &awss3.DeleteObjectInput{ Bucket: aws.String(c.bucket), Key: aws.String(key), }) @@ -206,7 +222,7 @@ func (c *Client) DeleteAdmin(ctx context.Context, key string) error { return nil } if err != nil { - c.log.Error("delete admin object", "bucket", c.bucket, "key", key, "error", err) + c.log.Error("delete object", "bucket", c.bucket, "key", key, "error", err) return ErrDeleteObject } diff --git a/internal/worker/worker.go b/internal/worker/worker.go index 4fbf6fd3..a0ec7d65 100644 --- a/internal/worker/worker.go +++ b/internal/worker/worker.go @@ -422,7 +422,7 @@ func (w *Worker) deleteStagingObject(ctx context.Context, key string) error { return nil } - if err := w.s3.DeleteAdmin(ctx, key); err != nil { + if err := w.s3.Delete(ctx, key); err != nil { return err } -- 2.54.0 From eafc43793313c831573baea6f647c4663be1ca60 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 12:41:11 +0300 Subject: [PATCH 11/23] test(worker): add retry and persistence checks and adapt attachment tests for async processing --- student-tests/attachment_failover_test.go | 4 +- student-tests/attachment_helpers_test.go | 34 ++- student-tests/attachment_load_test.go | 4 +- student-tests/attachment_test.go | 9 +- student-tests/compose_helpers_test.go | 47 ++++ student-tests/dependency_failure_test.go | 40 +--- .../thumbnail_test.go | 53 +++-- student-tests/worker_test.go | 218 ++++++++++++++++++ student.mk | 6 +- 9 files changed, 345 insertions(+), 70 deletions(-) create mode 100644 student-tests/compose_helpers_test.go rename internal/worker/image_test.go => student-tests/thumbnail_test.go (67%) create mode 100644 student-tests/worker_test.go diff --git a/student-tests/attachment_failover_test.go b/student-tests/attachment_failover_test.go index e37e1440..a6da30d5 100644 --- a/student-tests/attachment_failover_test.go +++ b/student-tests/attachment_failover_test.go @@ -20,7 +20,7 @@ func TestAttachmentUploaderFailover(t *testing.T) { chat := createChat(t, user, user.ID) original := makePNG(t, 32, 32) resp := uploadAttachment(t, user, chat.ID, "failover.png", "image/png", original) - requireStatus(t, resp, http.StatusCreated) + requireStatus(t, resp, http.StatusAccepted) uploader := resp.Header.Get("X-Instance-Id") var att dto.AttachmentResponse mustDecode(t, resp, &att) @@ -82,7 +82,7 @@ func TestAttachmentUploaderFailover(t *testing.T) { } return } - if response.StatusCode != http.StatusBadGateway && response.StatusCode != http.StatusServiceUnavailable && response.StatusCode != http.StatusGatewayTimeout { + if response.StatusCode != http.StatusConflict && response.StatusCode != http.StatusBadGateway && response.StatusCode != http.StatusServiceUnavailable && response.StatusCode != http.StatusGatewayTimeout { t.Fatalf("unexpected download status: %d", response.StatusCode) } } diff --git a/student-tests/attachment_helpers_test.go b/student-tests/attachment_helpers_test.go index 3da7613c..dd87cb9c 100644 --- a/student-tests/attachment_helpers_test.go +++ b/student-tests/attachment_helpers_test.go @@ -1,4 +1,4 @@ -//go:build contract || reconcile || failure +//go:build contract || reconcile || failure || worker package studenttests_test @@ -8,6 +8,7 @@ import ( "net/http" "net/url" "testing" + "time" "github.com/google/uuid" @@ -49,12 +50,12 @@ func uploadPNG(t *testing.T, actor testUser, chatID uuid.UUID) dto.AttachmentRes t.Helper() resp := uploadAttachment(t, actor, chatID, "sample.png", "image/png", makePNG(t, 32, 32)) - requireStatus(t, resp, http.StatusCreated) + requireStatus(t, resp, http.StatusAccepted) var att dto.AttachmentResponse mustDecode(t, resp, &att) - return att + return waitAttachment(t, actor, att.ID, "ready", time.Minute) } func postMessage( @@ -104,3 +105,30 @@ func requireErrorCode(t *testing.T, resp *http.Response, code dto.ErrorCode) { t.Errorf("expected error code %q, got %q", code, apiErr.Error.Code) } } + +func waitAttachment( + t *testing.T, + actor testUser, + id uuid.UUID, + status string, + timeout time.Duration, +) dto.AttachmentResponse { + t.Helper() + + deadline := time.Now().Add(timeout) + for time.Now().Before(deadline) { + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+id.String(), actor.Token, nil) + requireStatus(t, resp, http.StatusOK) + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + if string(att.Status) == status { + return att + } + if att.Status == "failed" { + t.Fatalf("attachment failed: %v", att.ErrorCode) + } + time.Sleep(200 * time.Millisecond) + } + t.Fatalf("attachment did not reach %s within %s", status, timeout) + return dto.AttachmentResponse{} +} diff --git a/student-tests/attachment_load_test.go b/student-tests/attachment_load_test.go index 2d8a8549..903c5060 100644 --- a/student-tests/attachment_load_test.go +++ b/student-tests/attachment_load_test.go @@ -118,7 +118,7 @@ func TestConcurrentUploads(t *testing.T) { mu.Lock() statuses[resp.StatusCode]++ - if resp.StatusCode == http.StatusCreated { + if resp.StatusCode == http.StatusAccepted { latencies = append(latencies, latency) } mu.Unlock() @@ -144,7 +144,7 @@ func TestConcurrentUploads(t *testing.T) { t.Logf("HTTP %d: %d", status, n) } - successful := statuses[http.StatusCreated] + successful := statuses[http.StatusAccepted] t.Logf("successful RPS: %.2f", float64(successful)/elapsed.Seconds()) if len(latencies) > 0 { diff --git a/student-tests/attachment_test.go b/student-tests/attachment_test.go index 0cdd0ad2..31fb9e2a 100644 --- a/student-tests/attachment_test.go +++ b/student-tests/attachment_test.go @@ -9,6 +9,7 @@ import ( "io" "net/http" "testing" + "time" "github.com/google/uuid" @@ -29,14 +30,16 @@ func TestAttachmentJPEG(t *testing.T) { } resp := uploadAttachment(t, user, chat.ID, "sample.jpg", "image/jpeg", body.Bytes()) - requireStatus(t, resp, http.StatusCreated) + requireStatus(t, resp, http.StatusAccepted) var att dto.AttachmentResponse mustDecode(t, resp, &att) - if att.Status != "ready" { - t.Fatalf("expected ready attachment, got %q", att.Status) + if att.Status != "queued" { + t.Fatalf("expected queued attachment, got %q", att.Status) } + waitAttachment(t, user, att.ID, "ready", time.Minute) + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content", user.Token, nil) requireStatus(t, resp, http.StatusOK) defer resp.Body.Close() diff --git a/student-tests/compose_helpers_test.go b/student-tests/compose_helpers_test.go new file mode 100644 index 00000000..a5d176da --- /dev/null +++ b/student-tests/compose_helpers_test.go @@ -0,0 +1,47 @@ +//go:build failure || worker + +package studenttests_test + +import ( + "net/http" + "os/exec" + "testing" + "time" +) + +func compose(t *testing.T, args ...string) { + t.Helper() + + cmd := exec.Command("docker", append([]string{"compose"}, args...)...) + cmd.Dir = ".." + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("docker compose %v: %v\n%s", args, err, out) + } +} + +func stopService(t *testing.T, name string) { + t.Helper() + + compose(t, "stop", name) + t.Cleanup(func() { + compose(t, "start", name) + waitReady(t) + }) +} + +func waitReady(t *testing.T) { + t.Helper() + + deadline := time.Now().Add(60 * time.Second) + for time.Now().Before(deadline) { + resp, err := httpClient.Get(*baseURL + "/health/ready") + if err == nil { + resp.Body.Close() + if resp.StatusCode == http.StatusOK { + return + } + } + time.Sleep(500 * time.Millisecond) + } + t.Fatal("service did not become ready in 60s") +} diff --git a/student-tests/dependency_failure_test.go b/student-tests/dependency_failure_test.go index 59d7ba1c..ce570f90 100644 --- a/student-tests/dependency_failure_test.go +++ b/student-tests/dependency_failure_test.go @@ -6,50 +6,12 @@ import ( "bytes" "io" "net/http" - "os/exec" "testing" "time" "mtusi2026-messenger/internal/dto" ) -func compose(t *testing.T, args ...string) { - t.Helper() - - cmd := exec.Command("docker", append([]string{"compose"}, args...)...) - cmd.Dir = ".." - if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("docker compose %v: %v\n%s", args, err, out) - } -} - -func stopService(t *testing.T, name string) { - t.Helper() - - compose(t, "stop", name) - t.Cleanup(func() { - compose(t, "start", name) - waitReady(t) - }) -} - -func waitReady(t *testing.T) { - t.Helper() - - deadline := time.Now().Add(60 * time.Second) - for time.Now().Before(deadline) { - resp, err := httpClient.Get(*baseURL + "/health/ready") - if err == nil { - resp.Body.Close() - if resp.StatusCode == http.StatusOK { - return - } - } - time.Sleep(500 * time.Millisecond) - } - t.Fatal("service did not become ready in 60s") -} - func TestRedisDown(t *testing.T) { user := createUser(t) @@ -140,7 +102,7 @@ func TestS3Down(t *testing.T) { response := uploadAttachment(t, user, chat.ID, "recovery.png", "image/png", original) status := response.StatusCode response.Body.Close() - if status == http.StatusCreated { + if status == http.StatusAccepted { uploaded = true } else if status != http.StatusServiceUnavailable { t.Fatalf("unexpected upload recovery status: %d", status) diff --git a/internal/worker/image_test.go b/student-tests/thumbnail_test.go similarity index 67% rename from internal/worker/image_test.go rename to student-tests/thumbnail_test.go index 5292733d..5d5e4df4 100644 --- a/internal/worker/image_test.go +++ b/student-tests/thumbnail_test.go @@ -1,4 +1,6 @@ -package worker +//go:build contract + +package studenttests_test import ( "bytes" @@ -7,7 +9,12 @@ import ( "image/color" "image/jpeg" "image/png" + "io" + "net/http" "testing" + "time" + + "mtusi2026-messenger/internal/dto" ) func TestThumbnail(t *testing.T) { @@ -24,10 +31,7 @@ func TestThumbnail(t *testing.T) { t.Fatal(err) } - data, width, height, err := thumbnail(bytes.NewReader(source.Bytes()), 40000000) - if err != nil { - t.Fatal(err) - } + data, width, height := processedThumbnail(t, source.Bytes(), "image/png") if width != tc.wantWidth || height != tc.wantHeight { t.Fatalf("got %dx%d", width, height) @@ -82,10 +86,7 @@ func TestThumbnailEXIF(t *testing.T) { data = append(data, segment...) data = append(data, exif...) data = append(data, original.Bytes()[2:]...) - result, width, height, err := thumbnail(bytes.NewReader(data), 40000000) - if err != nil { - t.Fatal(err) - } + result, width, height := processedThumbnail(t, data, "image/jpeg") if width != 20 || height != 40 { t.Fatalf("orientation ignored: %dx%d", width, height) @@ -106,17 +107,29 @@ func TestThumbnailEXIF(t *testing.T) { } } -func TestThumbnailRejectsInvalidSource(t *testing.T) { - var source bytes.Buffer - if err := png.Encode(&source, image.NewNRGBA(image.Rect(0, 0, 100, 100))); err != nil { - t.Fatal(err) - } +func processedThumbnail(t *testing.T, source []byte, contentType string) ([]byte, int, int) { + t.Helper() + user := createUser(t) + chat := createChat(t, user, user.ID) + resp := uploadAttachment(t, user, chat.ID, "image", contentType, source) + requireStatus(t, resp, http.StatusAccepted) + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + att = waitAttachment(t, user, att.ID, "ready", time.Minute) + for _, v := range att.Variants { + if v.Name != "thumbnail" { + continue + } + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content?variant=thumbnail", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + defer resp.Body.Close() + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } - if _, _, _, err := thumbnail(bytes.NewReader(source.Bytes()), 9999); err == nil { - t.Fatal("pixel limit ignored") - } - - if _, _, _, err := thumbnail(bytes.NewReader(source.Bytes()[:20]), 40000000); err == nil { - t.Fatal("truncated image accepted") + return data, v.Width, v.Height } + t.Fatal("ready attachment has no thumbnail") + return nil, 0, 0 } diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go new file mode 100644 index 00000000..a1d32200 --- /dev/null +++ b/student-tests/worker_test.go @@ -0,0 +1,218 @@ +//go:build worker + +package studenttests_test + +import ( + "bytes" + "context" + "encoding/json" + "image/jpeg" + "io" + "net/http" + "os/exec" + "reflect" + "strconv" + "strings" + "testing" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +func workerCommand(t *testing.T, args ...string) string { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, "docker", args...) + cmd.Dir = ".." + out, err := cmd.Output() + if err != nil { + t.Fatalf("Docker command failed: %v", err) + } + return strings.TrimSpace(string(out)) +} + +func workerSQL(t *testing.T, query string) string { + t.Helper() + return workerCommand(t, "compose", "exec", "-T", "postgres", "psql", + "-U", "messenger", "-d", "messenger", "-Atqc", query) +} + +func workerWait(t *testing.T, description string, timeout time.Duration, condition func() bool) { + t.Helper() + deadline := time.Now().Add(timeout) + for time.Now().Before(deadline) { + if condition() { + return + } + time.Sleep(300 * time.Millisecond) + } + t.Fatalf("timeout waiting for %s", description) +} + +func workerQueue(t *testing.T) string { + t.Helper() + out := workerCommand(t, "compose", "exec", "-T", "rabbitmq", "rabbitmqctl", + "list_queues", "name", "messages_ready", "messages_unacknowledged", "--silent") + for _, line := range strings.Split(out, "\n") { + fields := strings.Fields(line) + if len(fields) == 3 && fields[0] == "attachments.process.v1" { + return fields[1] + ":" + fields[2] + } + } + t.Fatal("attachment queue missing") + return "" +} + +func workerUpload(t *testing.T, user testUser, chatID uuid.UUID) (dto.AttachmentResponse, []byte) { + t.Helper() + source := makePNG(t, 320, 200) + resp := uploadAttachment(t, user, chatID, "worker.png", "image/png", source) + requireStatus(t, resp, http.StatusAccepted) + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + if att.Status != "queued" { + t.Fatalf("expected queued, got %s", att.Status) + } + return att, source +} + +func workerContent(t *testing.T, user testUser, id uuid.UUID, variant string) []byte { + t.Helper() + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+id.String()+"/content?variant="+variant, user.Token, nil) + requireStatus(t, resp, http.StatusOK) + defer resp.Body.Close() + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + return data +} + +func TestWorkerPersistenceAndDuplicate(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + att, source := workerUpload(t, user, chat.ID) + where := "attachment_id='" + att.ID.String() + "'" + resp := postMessage(t, user, chat.ID, "", []uuid.UUID{att.ID}) + requireStatus(t, resp, http.StatusCreated) + var message dto.MessageResponse + mustDecode(t, resp, &message) + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content", user.Token, nil) + requireStatus(t, resp, http.StatusConflict) + resp.Body.Close() + resp = sendMessage(t, user, chat.ID, "worker is stopped") + requireStatus(t, resp, http.StatusCreated) + resp.Body.Close() + workerWait(t, "confirmed publication", 15*time.Second, func() bool { + return workerSQL(t, "SELECT published_at IS NOT NULL FROM outbox WHERE "+where) == "t" + }) + stopService(t, "api") + if workerQueue(t) != "1:0" { + t.Fatal("accepted job is not pending in broker") + } + before := workerCommand(t, "compose", "ps", "-q", "rabbitmq") + compose(t, "up", "-d", "--no-deps", "--force-recreate", "rabbitmq") + after := workerCommand(t, "compose", "ps", "-q", "rabbitmq") + if before == after { + t.Fatal("broker was not recreated") + } + workerWait(t, "broker health", 30*time.Second, func() bool { + return workerCommand(t, "inspect", "--format", "{{.State.Health.Status}}", after) == "healthy" + }) + if workerQueue(t) != "1:0" { + t.Fatal("job lost after broker recreation with existing volume") + } + compose(t, "start", "api") + waitReady(t) + att = waitAttachment(t, user, att.ID, "queued", 15*time.Second) + resp = doRequest(t, http.MethodGet, "/api/v1/chats/"+chat.ID.String()+"/messages", user.Token, nil) + requireStatus(t, resp, http.StatusOK) + var page dto.MessagePageResponse + mustDecode(t, resp, &page) + found := false + for _, item := range page.Items { + if item.ID == message.ID && reflect.DeepEqual(item.AttachmentIDs, message.AttachmentIDs) { + found = true + } + } + if !found { + t.Fatal("message with attachment lost after API restart") + } + compose(t, "start", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 30*time.Second) + if !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { + t.Fatal("original changed") + } + thumb := workerContent(t, user, att.ID, "thumbnail") + cfg, err := jpeg.DecodeConfig(bytes.NewReader(thumb)) + if err != nil || cfg.Width != 256 || cfg.Height != 160 { + t.Fatal("invalid JPEG thumbnail") + } + // Re-publish the same intent, modeling duplicate delivery after a lost publisher confirmation. + workerSQL(t, "UPDATE outbox SET published_at=NULL WHERE "+where) + workerWait(t, "duplicate publication", 15*time.Second, func() bool { + return workerSQL(t, "SELECT published_at IS NOT NULL FROM outbox WHERE "+where) == "t" + }) + workerWait(t, "duplicate acknowledgement", 15*time.Second, func() bool { return workerQueue(t) == "0:0" }) + duplicate := waitAttachment(t, user, att.ID, "ready", 30*time.Second) + if !reflect.DeepEqual(ready, duplicate) || workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "1" { + t.Fatal("duplicate job changed metadata or duplicated variants") + } + if !bytes.Equal(workerContent(t, user, att.ID, "thumbnail"), thumb) || + !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { + t.Fatal("duplicate changed content") + } + t.Logf("PASS attachment=%s: queued survives API/broker restart; ready; duplicate acknowledged with unchanged result", att.ID) +} + +func TestWorkerRetryExhausted(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + att, _ := workerUpload(t, user, chat.ID) + workerID := workerCommand(t, "compose", "ps", "-a", "-q", "worker") + var env []string + if err := json.Unmarshal([]byte(workerCommand(t, "inspect", "--format", "{{json .Config.Env}}", workerID)), &env); err != nil { + t.Fatal(err) + } + maxAttempts := 5 + for _, entry := range env { + if value, ok := strings.CutPrefix(entry, "JOB_MAX_ATTEMPTS="); ok { + n, err := strconv.Atoi(value) + if err != nil || n < 1 { + t.Fatal("invalid JOB_MAX_ATTEMPTS") + } + maxAttempts = n + } + } + // A separate worker gets an unreachable S3 endpoint and a short attempt timeout. + // Keep the configured attempt count and normal backoff; leave the shared S3 running. + testWorker := "worker-retry-" + uuid.NewString() + t.Cleanup(func() { + workerCommand(t, "rm", "-f", testWorker) + }) + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", testWorker, + "-e", "JOB_TIMEOUT_SECONDS=3", "-e", "S3_ENDPOINT=http://127.0.0.1:1", "worker") + failed := waitAttachment(t, user, att.ID, "failed", 90*time.Second) + if failed.ErrorCode == nil || *failed.ErrorCode != "retry_exhausted" { + t.Fatal("expected safe retry_exhausted error") + } + attempts := workerSQL(t, "SELECT attempts FROM attachments WHERE id='"+att.ID.String()+"'") + if attempts != strconv.Itoa(maxAttempts) { + t.Fatalf("expected %d attempts, got %s", maxAttempts, attempts) + } + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content", user.Token, nil) + requireStatus(t, resp, http.StatusConflict) + resp.Body.Close() + resp = postMessage(t, user, chat.ID, "", []uuid.UUID{att.ID}) + requireStatus(t, resp, http.StatusConflict) + resp.Body.Close() + t.Logf("PASS attachment=%s: %d attempts, failed/retry_exhausted, content/link rejected", att.ID, maxAttempts) +} diff --git a/student.mk b/student.mk index 6b2f745d..c5c51fa9 100644 --- a/student.mk +++ b/student.mk @@ -8,10 +8,11 @@ ACTION ?= stop-one.sh ACTION_AT ?= 10s DRY_RUN ?= true -.PHONY: help-go contract-go race-go load-go failure-go load-action-go reconcile reconcile-test-go +.PHONY: help-go contract-go race-go load-go failure-go load-action-go reconcile reconcile-test-go worker-go help-go: @echo "contract-go: contract tests" + @echo "worker-go: worker persistence, duplicate and bounded retry (stops shared services)" @echo "race-go: concurrency tests (-race)" @echo "load-go: load test" @echo "failure-go: dependency failure tests (stops redis/postgres/s3 containers)" @@ -42,3 +43,6 @@ reconcile: reconcile-test-go: docker compose --env-file .env build reconcile go test -count=1 -tags=reconcile ./student-tests/... -v -args -base-url=$(BASE_URL) + +worker-go: + go test -count=1 -tags=worker ./student-tests/... -v -args -base-url=$(BASE_URL) -- 2.54.0 From 9149dddf110c0d34ce0156f720f892cc554fcfcb Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 12:59:20 +0300 Subject: [PATCH 12/23] refactor(worker): split job handling and retries, prepare variant collection --- internal/worker/image.go | 32 ++-- internal/worker/job.go | 218 +++++++++++++++++++++++++ internal/worker/retry.go | 150 +++++++++++++++++ internal/worker/worker.go | 336 -------------------------------------- 4 files changed, 384 insertions(+), 352 deletions(-) create mode 100644 internal/worker/job.go create mode 100644 internal/worker/retry.go diff --git a/internal/worker/image.go b/internal/worker/image.go index 2f2bccae..e7fac0bd 100644 --- a/internal/worker/image.go +++ b/internal/worker/image.go @@ -66,21 +66,21 @@ func thumbnail(r io.ReadSeeker, maxPixels int) ([]byte, int, int, error) { return out.Bytes(), width, height, nil } -func (w *Worker) process(ctx context.Context, row db.Attachment) (db.CreateAttachmentVariantParams, error) { +func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAttachmentVariantParams, error) { if row.StagingKey == nil { - return db.CreateAttachmentVariantParams{}, errInvalidSource + return nil, errInvalidSource } source, err := w.s3.Get(ctx, *row.StagingKey) if err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } defer source.Body.Close() tmp, err := os.CreateTemp("", "attachment-job-*") if err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } defer func() { @@ -91,54 +91,54 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) (db.CreateAttac hash := sha256.New() size, err := io.Copy(io.MultiWriter(tmp, hash), io.LimitReader(source.Body, int64(w.maxBytes)+1)) if err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } if size != int64(row.SizeBytes) || hex.EncodeToString(hash.Sum(nil)) != row.Sha256 { - return db.CreateAttachmentVariantParams{}, errInvalidSource + return nil, errInvalidSource } if _, err := tmp.Seek(0, io.SeekStart); err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } select { case w.decodeSlot <- struct{}{}: case <-ctx.Done(): - return db.CreateAttachmentVariantParams{}, ctx.Err() + return nil, ctx.Err() } if err := ctx.Err(); err != nil { <-w.decodeSlot - return db.CreateAttachmentVariantParams{}, err + return nil, err } data, width, height, err := thumbnail(tmp, w.maxPixels) <-w.decodeSlot if err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } if err := ctx.Err(); err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } if _, err := tmp.Seek(0, io.SeekStart); err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } if err := w.s3.Put(ctx, row.S3Key, tmp, size, string(row.ContentType)); err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/thumbnail" if err := w.s3.Put(ctx, key, bytes.NewReader(data), int64(len(data)), "image/jpeg"); err != nil { - return db.CreateAttachmentVariantParams{}, err + return nil, err } sum := sha256.Sum256(data) - return db.CreateAttachmentVariantParams{ + return []db.CreateAttachmentVariantParams{{ AttachmentID: row.ID, PipelineVersion: row.PipelineVersion, Variant: db.AttachmentVariantNameThumbnail, @@ -148,5 +148,5 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) (db.CreateAttac Width: width, Height: height, Sha256: hex.EncodeToString(sum[:]), - }, nil + }}, nil } diff --git a/internal/worker/job.go b/internal/worker/job.go new file mode 100644 index 00000000..66b7775b --- /dev/null +++ b/internal/worker/job.go @@ -0,0 +1,218 @@ +package worker + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "io" + "time" + + "github.com/jackc/pgx/v5" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" +) + +var ( + errLeaseExpired = errors.New("attachment lease expired") + errMissingThumbnail = errors.New("ready attachment has no thumbnail") + errAttemptProcessing = errors.New("attachment attempt is still processing") + errAttemptUnavailable = errors.New("attachment attempt is not yet available") + errEffectChecksumMismatch = errors.New("attachment effect checksum mismatch") +) + +func (w *Worker) handle(ctx context.Context, job model.AttachmentJob) error { + jobCtx, cancel := context.WithTimeout(ctx, w.cfg.Timeout) + defer cancel() + + row, err := w.q.ClaimAttachmentJob(jobCtx, db.ClaimAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + LeaseUntil: time.Now().Add(w.cfg.Timeout), + }) + if errors.Is(err, pgx.ErrNoRows) { + return w.duplicate(jobCtx, job) + } + + if err != nil { + return err + } + + w.log.Info("attachment processing", "job_id", job.JobID, "attachment_id", row.ID, "attempt", job.Attempt) + variants, processErr := w.process(jobCtx, row) + if processErr != nil { + resultCtx, resultCancel := context.WithTimeout(ctx, 5*time.Second) + defer resultCancel() + + return w.finishFailure(resultCtx, job, processErr) + } + + tx, err := w.pool.Begin(jobCtx) + if err != nil { + return err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + _, err = q.LockAttachmentJob(jobCtx, db.LockAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + for _, variant := range variants { + if err := q.CreateAttachmentVariant(jobCtx, variant); err != nil { + return err + } + } + + n, err := q.CompleteAttachmentJob(jobCtx, db.CompleteAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + if n != 1 { + return errLeaseExpired + } + + if err := tx.Commit(jobCtx); err != nil { + return err + } + + if row.StagingKey != nil { + err := w.deleteStagingObject(ctx, *row.StagingKey) + if err != nil && ctx.Err() == nil { + w.log.Warn("delete ready attachment staging", "attachment_id", row.ID, "error", err) + } + } + + w.log.Info("attachment ready", "job_id", job.JobID, "attachment_id", row.ID, "attempt", job.Attempt) + return nil +} + +func (w *Worker) duplicate(ctx context.Context, job model.AttachmentJob) error { + row, err := w.q.GetAttachmentByID(ctx, job.AttachmentID) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + + if err != nil { + return err + } + + if row.JobID == nil || *row.JobID != job.JobID || row.PipelineVersion != job.PipelineVersion { + return nil + } + + if row.Status == db.AttachmentStatusFailed { + return nil + } + + if row.Status == db.AttachmentStatusReady { + variants, err := w.q.ListAttachmentVariants(ctx, db.ListAttachmentVariantsParams{ + AttachmentID: row.ID, + PipelineVersion: row.PipelineVersion, + }) + if err != nil { + return err + } + + if err := w.verify(ctx, row.S3Key, row.SizeBytes, row.Sha256); err != nil { + return err + } + + hasThumbnail := false + for _, variant := range variants { + if err := w.verify(ctx, variant.S3Key, variant.SizeBytes, variant.Sha256); err != nil { + return err + } + + if variant.Variant == db.AttachmentVariantNameThumbnail { + hasThumbnail = true + } + } + + if !hasThumbnail { + return errMissingThumbnail + } + + return nil + } + + if row.Status == db.AttachmentStatusProcessing && row.Attempts == job.Attempt { + return errAttemptProcessing + } + + if row.Attempts >= job.Attempt { + return nil + } + + return errAttemptUnavailable +} + +func (w *Worker) verify(ctx context.Context, key string, size int, checksum string) error { + object, err := w.s3.Get(ctx, key) + if err != nil { + return err + } + + defer object.Body.Close() + + hash := sha256.New() + n, err := io.Copy(hash, io.LimitReader(object.Body, int64(size)+1)) + if err != nil { + return err + } + + if n != int64(size) || hex.EncodeToString(hash.Sum(nil)) != checksum { + return errEffectChecksumMismatch + } + + return nil +} + +func (w *Worker) deleteStagingObject(ctx context.Context, key string) error { + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + tx, err := w.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + row, err := q.LockAttachmentByStagingKey(ctx, key) + if errors.Is(err, pgx.ErrNoRows) { + return nil + } + + if err != nil { + return err + } + + if row.Status != db.AttachmentStatusReady { + return nil + } + + if err := w.s3.Delete(ctx, key); err != nil { + return err + } + + if err := q.ClearAttachmentStagingKey(ctx, row.ID); err != nil { + return err + } + + return tx.Commit(ctx) +} diff --git a/internal/worker/retry.go b/internal/worker/retry.go new file mode 100644 index 00000000..52359624 --- /dev/null +++ b/internal/worker/retry.go @@ -0,0 +1,150 @@ +package worker + +import ( + "context" + "errors" + "math/rand/v2" + "time" + + "mtusi2026-messenger/internal/db" + "mtusi2026-messenger/internal/model" + s3store "mtusi2026-messenger/internal/s3" +) + +func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cause error) error { + tx, err := w.pool.Begin(ctx) + if err != nil { + return err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + row, err := q.LockAttachmentJob(ctx, db.LockAttachmentJobParams{ + ID: job.AttachmentID, + JobID: job.JobID, + PipelineVersion: job.PipelineVersion, + Attempt: job.Attempt, + }) + if err != nil { + return err + } + + code := "processing_failed" + permanent := errors.Is(cause, errInvalidSource) || errors.Is(cause, s3store.ErrObjectNotFound) + if permanent { + code = "invalid_source" + } else if errors.Is(cause, context.DeadlineExceeded) { + code = "job_timeout" + } + + var n int64 + if permanent || row.Attempts >= w.cfg.MaxAttempts { + if !permanent { + code = "retry_exhausted" + } + + n, err = q.FailAttachmentJob(ctx, db.FailAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + ErrorCode: code, + }) + } else { + n, err = q.RetryAttachmentJob(ctx, db.RetryAttachmentJobParams{ + ID: row.ID, + Attempt: job.Attempt, + ErrorCode: code, + }) + if err == nil && n == 1 { + _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: row.ID, + Attempt: row.Attempts + 1, + AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + }) + } + } + + if err != nil { + return err + } + + if n != 1 { + return errLeaseExpired + } + + if err := tx.Commit(ctx); err != nil { + return err + } + + w.log.Warn( + "attachment processing failed", + "job_id", + job.JobID, + "attempt", + job.Attempt, + "error_code", + code, + ) + return nil +} + +func (w *Worker) recoverLoop(ctx context.Context) { + for ctx.Err() == nil { + recovered, err := w.recoverOne(ctx) + if err != nil && ctx.Err() == nil { + w.log.Warn("recover attachment lease", "error", err) + } + + if (err != nil || !recovered) && !wait(ctx, time.Second) { + return + } + } +} + +func (w *Worker) recoverOne(ctx context.Context) (bool, error) { + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + tx, err := w.pool.Begin(ctx) + if err != nil { + return false, err + } + + defer tx.Rollback(context.Background()) + + q := w.q.WithTx(tx) + rows, err := q.LockExpiredAttachmentJobs(ctx, 1) + if err != nil || len(rows) == 0 { + return false, err + } + + row := rows[0] + if row.Attempts >= w.cfg.MaxAttempts { + _, err = q.FailExpiredAttachmentJob(ctx, row.ID) + } else { + _, err = q.RecoverExpiredAttachmentJob(ctx, row.ID) + if err == nil { + _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: row.ID, + Attempt: row.Attempts + 1, + AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + }) + } + } + + if err != nil { + return false, err + } + + if err := tx.Commit(ctx); err != nil { + return false, err + } + + w.log.Info("attachment lease recovered", "attachment_id", row.ID, "attempt", row.Attempts) + return true, nil +} + +func retryDelay(attempt int) time.Duration { + ceiling := time.Second * time.Duration(1<= job.Attempt { - return nil - } - - return errAttemptUnavailable -} - -func (w *Worker) verify(ctx context.Context, key string, size int, checksum string) error { - object, err := w.s3.Get(ctx, key) - if err != nil { - return err - } - - defer object.Body.Close() - - hash := sha256.New() - n, err := io.Copy(hash, io.LimitReader(object.Body, int64(size)+1)) - if err != nil { - return err - } - - if n != int64(size) || hex.EncodeToString(hash.Sum(nil)) != checksum { - return errEffectChecksumMismatch - } - - return nil -} - -func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cause error) error { - tx, err := w.pool.Begin(ctx) - if err != nil { - return err - } - - defer tx.Rollback(context.Background()) - - q := w.q.WithTx(tx) - row, err := q.LockAttachmentJob(ctx, db.LockAttachmentJobParams{ - ID: job.AttachmentID, - JobID: job.JobID, - PipelineVersion: job.PipelineVersion, - Attempt: job.Attempt, - }) - if err != nil { - return err - } - - code := "processing_failed" - permanent := errors.Is(cause, errInvalidSource) || errors.Is(cause, s3store.ErrObjectNotFound) - if permanent { - code = "invalid_source" - } else if errors.Is(cause, context.DeadlineExceeded) { - code = "job_timeout" - } - - var n int64 - if permanent || row.Attempts >= w.cfg.MaxAttempts { - if !permanent { - code = "retry_exhausted" - } - - n, err = q.FailAttachmentJob(ctx, db.FailAttachmentJobParams{ - ID: row.ID, - Attempt: job.Attempt, - ErrorCode: code, - }) - } else { - n, err = q.RetryAttachmentJob(ctx, db.RetryAttachmentJobParams{ - ID: row.ID, - Attempt: job.Attempt, - ErrorCode: code, - }) - if err == nil && n == 1 { - _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ - AttachmentID: row.ID, - Attempt: row.Attempts + 1, - AvailableAt: time.Now().Add(retryDelay(row.Attempts)), - }) - } - } - - if err != nil { - return err - } - - if n != 1 { - return errLeaseExpired - } - - if err := tx.Commit(ctx); err != nil { - return err - } - - w.log.Warn( - "attachment processing failed", - "job_id", - job.JobID, - "attempt", - job.Attempt, - "error_code", - code, - ) - return nil -} - -func (w *Worker) deleteStagingObject(ctx context.Context, key string) error { - ctx, cancel := context.WithTimeout(ctx, 5*time.Second) - defer cancel() - - tx, err := w.pool.Begin(ctx) - if err != nil { - return err - } - defer tx.Rollback(context.Background()) - - q := w.q.WithTx(tx) - row, err := q.LockAttachmentByStagingKey(ctx, key) - if errors.Is(err, pgx.ErrNoRows) { - return nil - } - - if err != nil { - return err - } - - if row.Status != db.AttachmentStatusReady { - return nil - } - - if err := w.s3.Delete(ctx, key); err != nil { - return err - } - - if err := q.ClearAttachmentStagingKey(ctx, row.ID); err != nil { - return err - } - - return tx.Commit(ctx) -} - -func (w *Worker) recoverLoop(ctx context.Context) { - for ctx.Err() == nil { - recovered, err := w.recoverOne(ctx) - if err != nil && ctx.Err() == nil { - w.log.Warn("recover attachment lease", "error", err) - } - - if (err != nil || !recovered) && !wait(ctx, time.Second) { - return - } - } -} - -func (w *Worker) recoverOne(ctx context.Context) (bool, error) { - ctx, cancel := context.WithTimeout(ctx, 5*time.Second) - defer cancel() - - tx, err := w.pool.Begin(ctx) - if err != nil { - return false, err - } - - defer tx.Rollback(context.Background()) - - q := w.q.WithTx(tx) - rows, err := q.LockExpiredAttachmentJobs(ctx, 1) - if err != nil || len(rows) == 0 { - return false, err - } - - row := rows[0] - if row.Attempts >= w.cfg.MaxAttempts { - _, err = q.FailExpiredAttachmentJob(ctx, row.ID) - } else { - _, err = q.RecoverExpiredAttachmentJob(ctx, row.ID) - if err == nil { - _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ - AttachmentID: row.ID, - Attempt: row.Attempts + 1, - AvailableAt: time.Now().Add(retryDelay(row.Attempts)), - }) - } - } - - if err != nil { - return false, err - } - - if err := tx.Commit(ctx); err != nil { - return false, err - } - - w.log.Info("attachment lease recovered", "attachment_id", row.ID, "attempt", row.Attempts) - return true, nil -} - func wait(ctx context.Context, duration time.Duration) bool { timer := time.NewTimer(duration) defer timer.Stop() @@ -500,8 +169,3 @@ func wait(ctx context.Context, duration time.Duration) bool { return true } } - -func retryDelay(attempt int) time.Duration { - ceiling := time.Second * time.Duration(1< Date: Mon, 16 Nov 2026 13:12:04 +0300 Subject: [PATCH 13/23] feat(worker): add centered 128x128 JPEG crop --- internal/worker/image.go | 156 ++++++++++++++++++++------------ student-tests/thumbnail_test.go | 59 ++++++++++-- student-tests/worker_test.go | 10 +- 3 files changed, 160 insertions(+), 65 deletions(-) diff --git a/internal/worker/image.go b/internal/worker/image.go index e7fac0bd..a2a9ee38 100644 --- a/internal/worker/image.go +++ b/internal/worker/image.go @@ -22,48 +22,10 @@ import ( var errInvalidSource = errors.New("invalid source image") -func thumbnail(r io.ReadSeeker, maxPixels int) ([]byte, int, int, error) { - cfg, format, err := image.DecodeConfig(r) - if err != nil || - (format != "png" && format != "jpeg") || - cfg.Width <= 0 || - cfg.Height <= 0 || - cfg.Width > maxPixels/cfg.Height { - return nil, 0, 0, errInvalidSource - } - - if _, err := r.Seek(0, io.SeekStart); err != nil { - return nil, 0, 0, err - } - - src, err := imaging.Decode(r, imaging.AutoOrientation(true)) - if err != nil { - return nil, 0, 0, errInvalidSource - } - - width, height := src.Bounds().Dx(), src.Bounds().Dy() - if width > 256 || height > 256 { - if width >= height { - height = max(1, height*256/width) - width = 256 - } else { - width = max(1, width*256/height) - height = 256 - } - - src = imaging.Resize(src, width, height, imaging.Lanczos) - } - - dst := image.NewRGBA(image.Rect(0, 0, width, height)) - draw.Draw(dst, dst.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src) - draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over) - - var out bytes.Buffer - if err := jpeg.Encode(&out, dst, &jpeg.Options{Quality: 85}); err != nil { - return nil, 0, 0, err - } - - return out.Bytes(), width, height, nil +type imageVariant struct { + name db.AttachmentVariantName + data []byte + width, height int } func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAttachmentVariantParams, error) { @@ -114,7 +76,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt return nil, err } - data, width, height, err := thumbnail(tmp, w.maxPixels) + images, err := imageVariants(tmp, w.maxPixels) <-w.decodeSlot if err != nil { return nil, err @@ -132,21 +94,101 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt return nil, err } - key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/thumbnail" - if err := w.s3.Put(ctx, key, bytes.NewReader(data), int64(len(data)), "image/jpeg"); err != nil { + variants := make([]db.CreateAttachmentVariantParams, 0, len(images)) + for _, img := range images { + key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/" + string(img.name) + if err := w.s3.Put(ctx, key, bytes.NewReader(img.data), int64(len(img.data)), "image/jpeg"); err != nil { + return nil, err + } + + sum := sha256.Sum256(img.data) + variants = append(variants, db.CreateAttachmentVariantParams{ + AttachmentID: row.ID, + PipelineVersion: row.PipelineVersion, + Variant: img.name, + S3Key: key, + ContentType: "image/jpeg", + SizeBytes: len(img.data), + Width: img.width, + Height: img.height, + Sha256: hex.EncodeToString(sum[:]), + }) + } + + return variants, nil +} + +func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { + cfg, format, err := image.DecodeConfig(r) + if err != nil || + (format != "png" && format != "jpeg") || + cfg.Width <= 0 || + cfg.Height <= 0 || + cfg.Width > maxPixels/cfg.Height { + return nil, errInvalidSource + } + + if _, err := r.Seek(0, io.SeekStart); err != nil { return nil, err } - sum := sha256.Sum256(data) - return []db.CreateAttachmentVariantParams{{ - AttachmentID: row.ID, - PipelineVersion: row.PipelineVersion, - Variant: db.AttachmentVariantNameThumbnail, - S3Key: key, - ContentType: "image/jpeg", - SizeBytes: len(data), - Width: width, - Height: height, - Sha256: hex.EncodeToString(sum[:]), - }}, nil + src, err := imaging.Decode(r, imaging.AutoOrientation(true)) + if err != nil { + return nil, errInvalidSource + } + + thumb := thumbnail(src) + crop := imaging.Fill(src, 128, 128, imaging.Center, imaging.Lanczos) + variants := make([]imageVariant, 0, 2) + for _, item := range []struct { + name db.AttachmentVariantName + image image.Image + }{ + {db.AttachmentVariantNameThumbnail, thumb}, + {db.AttachmentVariantNameCrop, crop}, + } { + data, err := encodeJPEG(item.image) + if err != nil { + return nil, err + } + + variants = append(variants, imageVariant{ + name: item.name, + data: data, + width: item.image.Bounds().Dx(), + height: item.image.Bounds().Dy(), + }) + } + + return variants, nil +} + +func thumbnail(src image.Image) image.Image { + width, height := src.Bounds().Dx(), src.Bounds().Dy() + if width > 256 || height > 256 { + if width >= height { + height = max(1, height*256/width) + width = 256 + } else { + width = max(1, width*256/height) + height = 256 + } + + return imaging.Resize(src, width, height, imaging.Lanczos) + } + + return src +} + +func encodeJPEG(src image.Image) ([]byte, error) { + dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Dx(), src.Bounds().Dy())) + draw.Draw(dst, dst.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src) + draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over) + + var out bytes.Buffer + if err := jpeg.Encode(&out, dst, &jpeg.Options{Quality: 85}); err != nil { + return nil, err + } + + return out.Bytes(), nil } diff --git a/student-tests/thumbnail_test.go b/student-tests/thumbnail_test.go index 5d5e4df4..03582e44 100644 --- a/student-tests/thumbnail_test.go +++ b/student-tests/thumbnail_test.go @@ -31,7 +31,7 @@ func TestThumbnail(t *testing.T) { t.Fatal(err) } - data, width, height := processedThumbnail(t, source.Bytes(), "image/png") + data, width, height := processedVariant(t, source.Bytes(), "image/png", "thumbnail") if width != tc.wantWidth || height != tc.wantHeight { t.Fatalf("got %dx%d", width, height) @@ -86,7 +86,7 @@ func TestThumbnailEXIF(t *testing.T) { data = append(data, segment...) data = append(data, exif...) data = append(data, original.Bytes()[2:]...) - result, width, height := processedThumbnail(t, data, "image/jpeg") + result, width, height := processedVariant(t, data, "image/jpeg", "thumbnail") if width != 20 || height != 40 { t.Fatalf("orientation ignored: %dx%d", width, height) @@ -107,7 +107,7 @@ func TestThumbnailEXIF(t *testing.T) { } } -func processedThumbnail(t *testing.T, source []byte, contentType string) ([]byte, int, int) { +func processedVariant(t *testing.T, source []byte, contentType, variant string) ([]byte, int, int) { t.Helper() user := createUser(t) chat := createChat(t, user, user.ID) @@ -117,10 +117,10 @@ func processedThumbnail(t *testing.T, source []byte, contentType string) ([]byte mustDecode(t, resp, &att) att = waitAttachment(t, user, att.ID, "ready", time.Minute) for _, v := range att.Variants { - if v.Name != "thumbnail" { + if string(v.Name) != variant { continue } - resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content?variant=thumbnail", user.Token, nil) + resp = doRequest(t, http.MethodGet, "/api/v1/attachments/"+att.ID.String()+"/content?variant="+variant, user.Token, nil) requireStatus(t, resp, http.StatusOK) defer resp.Body.Close() data, err := io.ReadAll(resp.Body) @@ -130,6 +130,53 @@ func processedThumbnail(t *testing.T, source []byte, contentType string) ([]byte return data, v.Width, v.Height } - t.Fatal("ready attachment has no thumbnail") + t.Fatalf("ready attachment has no %s", variant) return nil, 0, 0 } + +func TestCrop(t *testing.T) { + for _, tc := range []struct { + name string + width, height int + }{ + {"landscape", 384, 128}, + {"portrait", 128, 384}, + {"small", 24, 8}, + } { + t.Run(tc.name, func(t *testing.T) { + src := image.NewNRGBA(image.Rect(0, 0, tc.width, tc.height)) + // Only the central square is green; a stretched full image retains red edges. + side := min(tc.width, tc.height) + left, top := (tc.width-side)/2, (tc.height-side)/2 + for y := 0; y < tc.height; y++ { + for x := 0; x < tc.width; x++ { + c := color.NRGBA{R: 255, A: 255} + if x >= left && x < left+side && y >= top && y < top+side { + c = color.NRGBA{G: 255, A: 255} + } + src.SetNRGBA(x, y, c) + } + } + + var source bytes.Buffer + if err := png.Encode(&source, src); err != nil { + t.Fatal(err) + } + + data, width, height := processedVariant(t, source.Bytes(), "image/png", "crop") + decoded, err := jpeg.Decode(bytes.NewReader(data)) + if err != nil { + t.Fatal(err) + } + if width != 128 || height != 128 || decoded.Bounds() != image.Rect(0, 0, 128, 128) { + t.Fatalf("expected crop 128x128, metadata=%dx%d, JPEG=%v", width, height, decoded.Bounds()) + } + for _, point := range []image.Point{{8, 8}, {64, 64}, {119, 119}} { + r, g, b, _ := decoded.At(point.X, point.Y).RGBA() + if g < 50000 || r > 15000 || b > 15000 { + t.Fatalf("crop is not centered at %v", point) + } + } + }) + } +} diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index a1d32200..9bca17ca 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -155,6 +155,11 @@ func TestWorkerPersistenceAndDuplicate(t *testing.T) { if err != nil || cfg.Width != 256 || cfg.Height != 160 { t.Fatal("invalid JPEG thumbnail") } + crop := workerContent(t, user, att.ID, "crop") + cfg, err = jpeg.DecodeConfig(bytes.NewReader(crop)) + if err != nil || cfg.Width != 128 || cfg.Height != 128 { + t.Fatal("invalid JPEG crop") + } // Re-publish the same intent, modeling duplicate delivery after a lost publisher confirmation. workerSQL(t, "UPDATE outbox SET published_at=NULL WHERE "+where) workerWait(t, "duplicate publication", 15*time.Second, func() bool { @@ -162,10 +167,11 @@ func TestWorkerPersistenceAndDuplicate(t *testing.T) { }) workerWait(t, "duplicate acknowledgement", 15*time.Second, func() bool { return workerQueue(t) == "0:0" }) duplicate := waitAttachment(t, user, att.ID, "ready", 30*time.Second) - if !reflect.DeepEqual(ready, duplicate) || workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "1" { + if !reflect.DeepEqual(ready, duplicate) || workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "2" { t.Fatal("duplicate job changed metadata or duplicated variants") } - if !bytes.Equal(workerContent(t, user, att.ID, "thumbnail"), thumb) || + if !bytes.Equal(workerContent(t, user, att.ID, "crop"), crop) || + !bytes.Equal(workerContent(t, user, att.ID, "thumbnail"), thumb) || !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { t.Fatal("duplicate changed content") } -- 2.54.0 From be101199107367fbc1b38a8909dbb5a38e30b109 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 13:29:09 +0300 Subject: [PATCH 14/23] feat(worker): add optimized WebP variant --- Dockerfile.worker | 2 +- go.mod | 4 +- go.sum | 4 + internal/worker/image.go | 55 +++++++++----- ...umbnail_test.go => image_variants_test.go} | 76 +++++++++++++++---- student-tests/worker_test.go | 13 +++- 6 files changed, 115 insertions(+), 39 deletions(-) rename student-tests/{thumbnail_test.go => image_variants_test.go} (69%) diff --git a/Dockerfile.worker b/Dockerfile.worker index 2e5281f1..78bd5435 100644 --- a/Dockerfile.worker +++ b/Dockerfile.worker @@ -5,7 +5,7 @@ COPY go.mod go.sum ./ RUN go mod download COPY . . -RUN CGO_ENABLED=0 GOOS=linux go build -o /out/worker ./cmd/worker +RUN CGO_ENABLED=0 GOOS=linux go build -tags=nodynamic -o /out/worker ./cmd/worker FROM gcr.io/distroless/static-debian12:nonroot WORKDIR /app diff --git a/go.mod b/go.mod index 2ec5a2f6..cb7cfa65 100644 --- a/go.mod +++ b/go.mod @@ -9,6 +9,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6 github.com/aws/smithy-go v1.28.7 github.com/disintegration/imaging v1.6.2 + github.com/gen2brain/webp v0.6.4 github.com/go-chi/chi/v5 v5.5.0 github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.11.0 @@ -16,6 +17,7 @@ require ( github.com/rabbitmq/amqp091-go v1.10.0 github.com/redis/go-redis/v9 v9.23.0 golang.org/x/crypto v0.58.0 + golang.org/x/image v0.48.0 ) require ( @@ -33,11 +35,11 @@ require ( github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.51.6 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/ebitengine/purego v0.10.1 // 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 go.uber.org/atomic v1.12.0 // indirect - golang.org/x/image v0.48.0 // indirect golang.org/x/sync v0.25.0 // indirect golang.org/x/sys v0.50.0 // indirect golang.org/x/text v0.44.0 // indirect diff --git a/go.sum b/go.sum index aa655493..d287c91f 100644 --- a/go.sum +++ b/go.sum @@ -43,6 +43,10 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c= github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4= +github.com/ebitengine/purego v0.10.1 h1:dewVBCBT2GaMu1SrNTYxQhgQBethzfhiwvZiLGP/qyY= +github.com/ebitengine/purego v0.10.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/gen2brain/webp v0.6.4 h1:SUDdmxADOAiPQ+5ylNmuHhuYf2dOi0KgKZHL5vpVCNU= +github.com/gen2brain/webp v0.6.4/go.mod h1:iGWMaCSw7t3I/Cv9llzEKmpnR36S8lS8VL/ZVjxU0JE= github.com/go-chi/chi/v5 v5.5.0 h1:xdKQ1dJmVJsmgahrXSKhUx8NyVPzpwdlyrrQFpMPJgg= github.com/go-chi/chi/v5 v5.5.0/go.mod h1:d1IG7GtKPSjPyBP365PH8sAGVHk3qfB/IhjFNRH1wWM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= diff --git a/internal/worker/image.go b/internal/worker/image.go index a2a9ee38..b337da59 100644 --- a/internal/worker/image.go +++ b/internal/worker/image.go @@ -16,6 +16,7 @@ import ( "strconv" "github.com/disintegration/imaging" + "github.com/gen2brain/webp" "mtusi2026-messenger/internal/db" ) @@ -25,6 +26,7 @@ var errInvalidSource = errors.New("invalid source image") type imageVariant struct { name db.AttachmentVariantName data []byte + contentType string width, height int } @@ -97,7 +99,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt variants := make([]db.CreateAttachmentVariantParams, 0, len(images)) for _, img := range images { key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/" + string(img.name) - if err := w.s3.Put(ctx, key, bytes.NewReader(img.data), int64(len(img.data)), "image/jpeg"); err != nil { + if err := w.s3.Put(ctx, key, bytes.NewReader(img.data), int64(len(img.data)), img.contentType); err != nil { return nil, err } @@ -107,7 +109,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt PipelineVersion: row.PipelineVersion, Variant: img.name, S3Key: key, - ContentType: "image/jpeg", + ContentType: img.contentType, SizeBytes: len(img.data), Width: img.width, Height: img.height, @@ -137,41 +139,49 @@ func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { return nil, errInvalidSource } - thumb := thumbnail(src) - crop := imaging.Fill(src, 128, 128, imaging.Center, imaging.Lanczos) - variants := make([]imageVariant, 0, 2) + variants := make([]imageVariant, 0, 3) for _, item := range []struct { name db.AttachmentVariantName image image.Image }{ - {db.AttachmentVariantNameThumbnail, thumb}, - {db.AttachmentVariantNameCrop, crop}, + {db.AttachmentVariantNameThumbnail, fitImage(src, 256)}, + {db.AttachmentVariantNameCrop, imaging.Fill(src, 128, 128, imaging.Center, imaging.Lanczos)}, + {db.AttachmentVariantNameOptimized, fitImage(src, 1280)}, } { - data, err := encodeJPEG(item.image) + var data []byte + contentType := "image/jpeg" + if item.name == db.AttachmentVariantNameOptimized { + contentType = "image/webp" + data, err = encodeWebP(item.image) + } else { + data, err = encodeJPEG(item.image) + } + if err != nil { return nil, err } variants = append(variants, imageVariant{ - name: item.name, - data: data, - width: item.image.Bounds().Dx(), - height: item.image.Bounds().Dy(), + name: item.name, + contentType: contentType, + data: data, + width: item.image.Bounds().Dx(), + height: item.image.Bounds().Dy(), }) } return variants, nil } -func thumbnail(src image.Image) image.Image { +func fitImage(src image.Image, maxSize int) image.Image { width, height := src.Bounds().Dx(), src.Bounds().Dy() - if width > 256 || height > 256 { + if width > maxSize || height > maxSize { if width >= height { - height = max(1, height*256/width) - width = 256 + height = max(1, height*maxSize/width) + width = maxSize } else { - width = max(1, width*256/height) - height = 256 + width = max(1, width*maxSize/height) + height = maxSize } return imaging.Resize(src, width, height, imaging.Lanczos) @@ -192,3 +202,12 @@ func encodeJPEG(src image.Image) ([]byte, error) { return out.Bytes(), nil } + +func encodeWebP(src image.Image) ([]byte, error) { + var out bytes.Buffer + if err := webp.Encode(&out, src, webp.Options{Quality: 80, Method: 4}); err != nil { + return nil, err + } + + return out.Bytes(), nil +} diff --git a/student-tests/thumbnail_test.go b/student-tests/image_variants_test.go similarity index 69% rename from student-tests/thumbnail_test.go rename to student-tests/image_variants_test.go index 03582e44..0a31d362 100644 --- a/student-tests/thumbnail_test.go +++ b/student-tests/image_variants_test.go @@ -4,7 +4,9 @@ package studenttests_test import ( "bytes" + "crypto/sha256" "encoding/binary" + "encoding/hex" "image" "image/color" "image/jpeg" @@ -14,6 +16,8 @@ import ( "testing" "time" + "golang.org/x/image/webp" + "mtusi2026-messenger/internal/dto" ) @@ -54,7 +58,7 @@ func TestThumbnail(t *testing.T) { } } -func TestThumbnailEXIF(t *testing.T) { +func TestVariantsEXIF(t *testing.T) { src := image.NewRGBA(image.Rect(0, 0, 40, 20)) for y := 0; y < 20; y++ { @@ -86,24 +90,27 @@ func TestThumbnailEXIF(t *testing.T) { data = append(data, segment...) data = append(data, exif...) data = append(data, original.Bytes()[2:]...) - result, width, height := processedVariant(t, data, "image/jpeg", "thumbnail") + for _, variant := range []string{"thumbnail", "optimized"} { + t.Run(variant, func(t *testing.T) { + result, width, height := processedVariant(t, data, "image/jpeg", variant) + if width != 20 || height != 40 { + t.Fatalf("orientation ignored: %dx%d", width, height) + } - if width != 20 || height != 40 { - t.Fatalf("orientation ignored: %dx%d", width, height) - } + decoded, _, err := image.Decode(bytes.NewReader(result)) + if err != nil { + t.Fatal(err) + } - decoded, err := jpeg.Decode(bytes.NewReader(result)) - if err != nil { - t.Fatal(err) - } + r, _, b, _ := decoded.At(10, 5).RGBA() + if r <= b { + t.Fatal("incorrect EXIF rotation") + } - r, _, b, _ := decoded.At(10, 5).RGBA() - if r <= b { - t.Fatal("incorrect EXIF rotation") - } - - if bytes.Contains(result, []byte("Exif")) { - t.Fatal("EXIF retained") + if bytes.Contains(result, []byte("Exif")) || bytes.Contains(result, []byte("EXIF")) { + t.Fatal("EXIF retained") + } + }) } } @@ -128,6 +135,12 @@ func processedVariant(t *testing.T, source []byte, contentType, variant string) t.Fatal(err) } + sum := sha256.Sum256(data) + if len(data) != v.SizeBytes || hex.EncodeToString(sum[:]) != v.Sha256 || + resp.Header.Get("Content-Type") != string(v.ContentType) { + t.Fatal("variant content disagrees with metadata") + } + return data, v.Width, v.Height } t.Fatalf("ready attachment has no %s", variant) @@ -180,3 +193,34 @@ func TestCrop(t *testing.T) { }) } } + +func TestOptimized(t *testing.T) { + for _, tc := range []struct { + name string + width, height, wantWidth, wantHeight int + }{ + {"landscape", 1600, 1000, 1280, 800}, + {"portrait", 1000, 1600, 800, 1280}, + {"small", 12, 7, 12, 7}, + } { + t.Run(tc.name, func(t *testing.T) { + var source bytes.Buffer + if err := png.Encode(&source, image.NewNRGBA(image.Rect(0, 0, tc.width, tc.height))); err != nil { + t.Fatal(err) + } + data, width, height := processedVariant(t, source.Bytes(), "image/png", "optimized") + decoded, err := webp.Decode(bytes.NewReader(data)) + if err != nil { + t.Fatal(err) + } + if width != tc.wantWidth || height != tc.wantHeight || + decoded.Bounds().Dx() != width || decoded.Bounds().Dy() != height { + t.Fatalf("unexpected optimized dimensions: metadata=%dx%d, WebP=%v", width, height, decoded.Bounds()) + } + _, _, _, alpha := decoded.At(0, 0).RGBA() + if alpha != 0 { + t.Fatal("optimized image lost transparency") + } + }) + } +} diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index 9bca17ca..ef46d588 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -17,6 +17,7 @@ import ( "time" "github.com/google/uuid" + "golang.org/x/image/webp" "mtusi2026-messenger/internal/dto" ) @@ -160,17 +161,23 @@ func TestWorkerPersistenceAndDuplicate(t *testing.T) { if err != nil || cfg.Width != 128 || cfg.Height != 128 { t.Fatal("invalid JPEG crop") } - // Re-publish the same intent, modeling duplicate delivery after a lost publisher confirmation. + optimized := workerContent(t, user, att.ID, "optimized") + cfg, err = webp.DecodeConfig(bytes.NewReader(optimized)) + if err != nil || cfg.Width != 320 || cfg.Height != 200 { + t.Fatal("invalid optimized WebP") + } + workerSQL(t, "UPDATE outbox SET published_at=NULL WHERE "+where) workerWait(t, "duplicate publication", 15*time.Second, func() bool { return workerSQL(t, "SELECT published_at IS NOT NULL FROM outbox WHERE "+where) == "t" }) workerWait(t, "duplicate acknowledgement", 15*time.Second, func() bool { return workerQueue(t) == "0:0" }) duplicate := waitAttachment(t, user, att.ID, "ready", 30*time.Second) - if !reflect.DeepEqual(ready, duplicate) || workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "2" { + if !reflect.DeepEqual(ready, duplicate) || workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "3" { t.Fatal("duplicate job changed metadata or duplicated variants") } - if !bytes.Equal(workerContent(t, user, att.ID, "crop"), crop) || + if !bytes.Equal(workerContent(t, user, att.ID, "optimized"), optimized) || + !bytes.Equal(workerContent(t, user, att.ID, "crop"), crop) || !bytes.Equal(workerContent(t, user, att.ID, "thumbnail"), thumb) || !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { t.Fatal("duplicate changed content") -- 2.54.0 From 97b43a9c98f4dfb573e7ce222efb55e0e4c5c591 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 15:52:49 +0300 Subject: [PATCH 15/23] feat(worker): enforce image processing timeout with child process --- cmd/worker/main.go | 18 ++++++++++++ internal/worker/image.go | 46 ++++++++++++++--------------- internal/worker/image_process.go | 50 ++++++++++++++++++++++++++++++++ internal/worker/retry.go | 2 +- student-tests/worker_test.go | 43 +++++++++++++++++++++++++++ 5 files changed, 135 insertions(+), 24 deletions(-) create mode 100644 internal/worker/image_process.go diff --git a/cmd/worker/main.go b/cmd/worker/main.go index 9254e32a..cbcbd49b 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -2,6 +2,8 @@ package main import ( "context" + "errors" + "flag" "fmt" "os" "os/signal" @@ -17,6 +19,22 @@ import ( ) func main() { + maxPixels := flag.Int("process-image", 0, "process an image from stdin with the given pixel limit") + flag.Parse() + + if *maxPixels > 0 { + if err := worker.ProcessImage(*maxPixels); err != nil { + if errors.Is(err, worker.ErrInvalidSource) { + os.Exit(2) + } + + fmt.Fprintln(os.Stderr, "process image:", err) + os.Exit(1) + } + + return + } + if err := run(); err != nil { fmt.Fprintln(os.Stderr, "worker:", err) os.Exit(1) diff --git a/internal/worker/image.go b/internal/worker/image.go index b337da59..ae1e7a42 100644 --- a/internal/worker/image.go +++ b/internal/worker/image.go @@ -21,18 +21,18 @@ import ( "mtusi2026-messenger/internal/db" ) -var errInvalidSource = errors.New("invalid source image") +var ErrInvalidSource = errors.New("invalid source image") type imageVariant struct { - name db.AttachmentVariantName - data []byte - contentType string - width, height int + Name db.AttachmentVariantName + Data []byte + ContentType string + Width, Height int } func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAttachmentVariantParams, error) { if row.StagingKey == nil { - return nil, errInvalidSource + return nil, ErrInvalidSource } source, err := w.s3.Get(ctx, *row.StagingKey) @@ -60,7 +60,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt if size != int64(row.SizeBytes) || hex.EncodeToString(hash.Sum(nil)) != row.Sha256 { - return nil, errInvalidSource + return nil, ErrInvalidSource } if _, err := tmp.Seek(0, io.SeekStart); err != nil { @@ -78,7 +78,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt return nil, err } - images, err := imageVariants(tmp, w.maxPixels) + images, err := runImageProcess(ctx, tmp, w.maxPixels) <-w.decodeSlot if err != nil { return nil, err @@ -98,21 +98,21 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt variants := make([]db.CreateAttachmentVariantParams, 0, len(images)) for _, img := range images { - key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/" + string(img.name) - if err := w.s3.Put(ctx, key, bytes.NewReader(img.data), int64(len(img.data)), img.contentType); err != nil { + key := "variants/" + row.ID.String() + "/v" + strconv.Itoa(row.PipelineVersion) + "/" + string(img.Name) + if err := w.s3.Put(ctx, key, bytes.NewReader(img.Data), int64(len(img.Data)), img.ContentType); err != nil { return nil, err } - sum := sha256.Sum256(img.data) + sum := sha256.Sum256(img.Data) variants = append(variants, db.CreateAttachmentVariantParams{ AttachmentID: row.ID, PipelineVersion: row.PipelineVersion, - Variant: img.name, + Variant: img.Name, S3Key: key, - ContentType: img.contentType, - SizeBytes: len(img.data), - Width: img.width, - Height: img.height, + ContentType: img.ContentType, + SizeBytes: len(img.Data), + Width: img.Width, + Height: img.Height, Sha256: hex.EncodeToString(sum[:]), }) } @@ -127,7 +127,7 @@ func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { cfg.Width <= 0 || cfg.Height <= 0 || cfg.Width > maxPixels/cfg.Height { - return nil, errInvalidSource + return nil, ErrInvalidSource } if _, err := r.Seek(0, io.SeekStart); err != nil { @@ -136,7 +136,7 @@ func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { src, err := imaging.Decode(r, imaging.AutoOrientation(true)) if err != nil { - return nil, errInvalidSource + return nil, ErrInvalidSource } variants := make([]imageVariant, 0, 3) @@ -162,11 +162,11 @@ func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { } variants = append(variants, imageVariant{ - name: item.name, - contentType: contentType, - data: data, - width: item.image.Bounds().Dx(), - height: item.image.Bounds().Dy(), + Name: item.name, + ContentType: contentType, + Data: data, + Width: item.image.Bounds().Dx(), + Height: item.image.Bounds().Dy(), }) } diff --git a/internal/worker/image_process.go b/internal/worker/image_process.go new file mode 100644 index 00000000..4811d5a8 --- /dev/null +++ b/internal/worker/image_process.go @@ -0,0 +1,50 @@ +package worker + +import ( + "bytes" + "context" + "encoding/gob" + "errors" + "os" + "os/exec" + "strconv" +) + +func ProcessImage(maxPixels int) error { + variants, err := imageVariants(os.Stdin, maxPixels) + if err != nil { + return err + } + + return gob.NewEncoder(os.Stdout).Encode(variants) +} + +func runImageProcess(ctx context.Context, source *os.File, maxPixels int) ([]imageVariant, error) { + executable, err := os.Executable() + if err != nil { + return nil, err + } + + cmd := exec.CommandContext(ctx, executable, "-process-image", strconv.Itoa(maxPixels)) + cmd.Stdin = source + data, err := cmd.Output() + if ctx.Err() != nil { + return nil, ctx.Err() + } + + if err != nil { + var exitErr *exec.ExitError + if errors.As(err, &exitErr) && exitErr.ExitCode() == 2 { + return nil, ErrInvalidSource + } + + return nil, err + } + + var variants []imageVariant + if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&variants); err != nil { + return nil, err + } + + return variants, nil +} diff --git a/internal/worker/retry.go b/internal/worker/retry.go index 52359624..b684fa4b 100644 --- a/internal/worker/retry.go +++ b/internal/worker/retry.go @@ -31,7 +31,7 @@ func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cau } code := "processing_failed" - permanent := errors.Is(cause, errInvalidSource) || errors.Is(cause, s3store.ErrObjectNotFound) + permanent := errors.Is(cause, ErrInvalidSource) || errors.Is(cause, s3store.ErrObjectNotFound) if permanent { code = "invalid_source" } else if errors.Is(cause, context.DeadlineExceeded) { diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index ef46d588..fd50e0c6 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -229,3 +229,46 @@ func TestWorkerRetryExhausted(t *testing.T) { resp.Body.Close() t.Logf("PASS attachment=%s: %d attempts, failed/retry_exhausted, content/link rejected", att.ID, maxAttempts) } + +func TestWorkerProcessingTimeout(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + + // Decode and resize of 36 million pixels must be interrupted by the short deadline. + resp := uploadAttachment(t, user, chat.ID, "large.png", "image/png", makePNG(t, 6000, 6000)) + requireStatus(t, resp, http.StatusAccepted) + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + + testWorker := "worker-timeout-" + uuid.NewString() + t.Cleanup(func() { + workerCommand(t, "rm", "-f", testWorker) + }) + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", testWorker, + "-e", "JOB_TIMEOUT_SECONDS=1", "-e", "JOB_MAX_ATTEMPTS=1", "worker") + parentPID := workerCommand(t, "inspect", "--format", "{{.State.Pid}}", testWorker) + workerWait(t, "image child process", 5*time.Second, func() bool { + return strings.Contains(workerCommand(t, "top", testWorker, "-eo", "pid,args"), "-process-image") + }) + failed := waitAttachment(t, user, att.ID, "failed", 5*time.Second) + if failed.ErrorCode == nil || *failed.ErrorCode != "retry_exhausted" { + t.Fatal("expected retry_exhausted after processing deadline") + } + if strings.Contains(workerCommand(t, "top", testWorker, "-eo", "pid,args"), "-process-image") { + t.Fatal("image process survived its deadline") + } + if workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE attachment_id='"+att.ID.String()+"'") != "0" { + t.Fatal("timed-out processing published variants") + } + + // The same parent process must remain usable after terminating the image child. + uploadPNG(t, user, chat.ID) + after := workerCommand(t, "inspect", "--format", "{{.State.Pid}}", testWorker) + if parentPID != after || parentPID == "0" { + t.Fatal("parent worker restarted after the image timeout") + } +} -- 2.54.0 From f2000a788305d614afa1c4ab18701216be3263b2 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 16:18:54 +0300 Subject: [PATCH 16/23] feat(worker): prepare replay queries and audit schema --- db/migrations/00004_attachment_pipeline.sql | 13 ++ db/queries/attachment_replays.sql | 14 +++ db/queries/attachments.sql | 33 ++++++ internal/db/attachment_replays.sql.go | 47 ++++++++ internal/db/attachments.sql.go | 124 +++++++++++++++++++- internal/db/models.go | 10 ++ internal/worker/retry.go | 8 +- 7 files changed, 239 insertions(+), 10 deletions(-) create mode 100644 db/queries/attachment_replays.sql create mode 100644 internal/db/attachment_replays.sql.go diff --git a/db/migrations/00004_attachment_pipeline.sql b/db/migrations/00004_attachment_pipeline.sql index 6ed6ec50..9bd17b93 100644 --- a/db/migrations/00004_attachment_pipeline.sql +++ b/db/migrations/00004_attachment_pipeline.sql @@ -6,6 +6,7 @@ ALTER TABLE attachments ADD COLUMN job_id uuid UNIQUE, ADD COLUMN pipeline_version int NOT NULL DEFAULT 1 CHECK (pipeline_version > 0), ADD COLUMN attempts int NOT NULL DEFAULT 0 CHECK (attempts >= 0), + ADD COLUMN retry_base int NOT NULL DEFAULT 0 CHECK (retry_base >= 0 AND retry_base <= attempts), ADD COLUMN width int CHECK (width > 0), ADD COLUMN height int CHECK (height > 0), ADD COLUMN lease_until timestamptz; @@ -39,7 +40,18 @@ CREATE TABLE outbox ( CREATE INDEX idx_outbox_pending ON outbox (available_at, id) WHERE published_at IS NULL; +CREATE TABLE attachment_replays ( + attachment_id uuid NOT NULL REFERENCES attachments (id) ON DELETE CASCADE, + attempt int NOT NULL CHECK (attempt > 0), + previous_error_code text, + operator text NOT NULL, + reason text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (attachment_id, attempt) +); + -- +goose Down +DROP TABLE attachment_replays; DROP TABLE outbox; DROP TABLE attachment_variants; DROP TYPE attachment_variant_name; @@ -48,6 +60,7 @@ ALTER TABLE attachments DROP COLUMN height, DROP COLUMN width, DROP COLUMN lease_until, + DROP COLUMN retry_base, DROP COLUMN attempts, DROP COLUMN pipeline_version, DROP COLUMN job_id, diff --git a/db/queries/attachment_replays.sql b/db/queries/attachment_replays.sql new file mode 100644 index 00000000..60044d17 --- /dev/null +++ b/db/queries/attachment_replays.sql @@ -0,0 +1,14 @@ +-- name: CreateAttachmentReplay :exec +INSERT INTO attachment_replays ( + attachment_id, + attempt, + previous_error_code, + operator, + reason +) VALUES ( + sqlc.arg(attachment_id), + sqlc.arg(attempt), + sqlc.narg(previous_error_code), + sqlc.arg(operator), + sqlc.arg(reason) +); diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index 8a26c771..94060500 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -77,6 +77,13 @@ ORDER BY message_id, position; SELECT id, s3_key, staging_key, status, size_bytes, updated_at FROM attachments; +-- name: ListFailedAttachments :many +SELECT id, job_id, error_code, attempts, updated_at +FROM attachments +WHERE status = 'failed' +ORDER BY updated_at, id +LIMIT sqlc.arg(batch_size)::int; + -- name: LockAttachmentJob :one SELECT * FROM attachments WHERE id = sqlc.arg(id)::uuid @@ -95,6 +102,17 @@ ORDER BY lease_until, id LIMIT sqlc.arg(batch_size)::int FOR UPDATE SKIP LOCKED; +-- name: LockFailedAttachmentForReplay :one +SELECT * FROM attachments +WHERE id = sqlc.arg(id)::uuid + AND status = 'failed' + AND staging_key IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM attachment_variants + WHERE attachment_id = attachments.id + ) +FOR UPDATE; + -- name: ClearAttachmentStagingKey :exec UPDATE attachments SET staging_key = NULL @@ -142,6 +160,21 @@ WHERE id = sqlc.arg(id)::uuid AND attempts = sqlc.arg(attempt)::int AND lease_until > now(); +-- name: ReplayAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + retry_base = attempts, + error_code = NULL, + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND status = 'failed' + AND staging_key IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM attachment_variants + WHERE attachment_id = attachments.id + ); + -- name: FailAttachmentJob :execrows UPDATE attachments SET status = 'failed', diff --git a/internal/db/attachment_replays.sql.go b/internal/db/attachment_replays.sql.go new file mode 100644 index 00000000..7e584479 --- /dev/null +++ b/internal/db/attachment_replays.sql.go @@ -0,0 +1,47 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: attachment_replays.sql + +package db + +import ( + "context" + + "github.com/google/uuid" +) + +const createAttachmentReplay = `-- name: CreateAttachmentReplay :exec +INSERT INTO attachment_replays ( + attachment_id, + attempt, + previous_error_code, + operator, + reason +) VALUES ( + $1, + $2, + $3, + $4, + $5 +) +` + +type CreateAttachmentReplayParams struct { + AttachmentID uuid.UUID + Attempt int + PreviousErrorCode *string + Operator string + Reason string +} + +func (q *Queries) CreateAttachmentReplay(ctx context.Context, arg CreateAttachmentReplayParams) error { + _, err := q.db.Exec(ctx, createAttachmentReplay, + arg.AttachmentID, + arg.Attempt, + arg.PreviousErrorCode, + arg.Operator, + arg.Reason, + ) + return err +} diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index 9e2f8da4..b367fe26 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -23,7 +23,7 @@ WHERE id = $2::uuid AND pipeline_version = $4::int AND status = 'queued' AND attempts + 1 = $5::int -RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until ` type ClaimAttachmentJobParams struct { @@ -60,6 +60,7 @@ func (q *Queries) ClaimAttachmentJob(ctx context.Context, arg ClaimAttachmentJob &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -138,7 +139,7 @@ WHERE EXISTS ( WHERE chat_id = $2 AND user_id = $3 ) -RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until +RETURNING id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until ` type CreateAttachmentParams struct { @@ -191,6 +192,7 @@ func (q *Queries) CreateAttachment(ctx context.Context, arg CreateAttachmentPara &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -267,7 +269,7 @@ func (q *Queries) FailExpiredAttachmentJob(ctx context.Context, id uuid.UUID) (i } const getAttachmentByID = `-- name: GetAttachmentByID :one -SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments WHERE id = $1::uuid ` @@ -291,6 +293,7 @@ func (q *Queries) GetAttachmentByID(ctx context.Context, dollar_1 uuid.UUID) (At &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -371,6 +374,48 @@ func (q *Queries) ListAttachmentsForReconcile(ctx context.Context) ([]ListAttach return items, nil } +const listFailedAttachments = `-- name: ListFailedAttachments :many +SELECT id, job_id, error_code, attempts, updated_at +FROM attachments +WHERE status = 'failed' +ORDER BY updated_at, id +LIMIT $1::int +` + +type ListFailedAttachmentsRow struct { + ID uuid.UUID + JobID *uuid.UUID + ErrorCode *string + Attempts int + UpdatedAt time.Time +} + +func (q *Queries) ListFailedAttachments(ctx context.Context, batchSize int) ([]ListFailedAttachmentsRow, error) { + rows, err := q.db.Query(ctx, listFailedAttachments, batchSize) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListFailedAttachmentsRow{} + for rows.Next() { + var i ListFailedAttachmentsRow + if err := rows.Scan( + &i.ID, + &i.JobID, + &i.ErrorCode, + &i.Attempts, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const listMessageAttachmentIDs = `-- name: ListMessageAttachmentIDs :many SELECT attachment_id FROM message_attachments @@ -431,7 +476,7 @@ func (q *Queries) ListMessageAttachmentsByMessageIDs(ctx context.Context, messag } const lockAttachmentByStagingKey = `-- name: LockAttachmentByStagingKey :one -SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments WHERE staging_key = $1::text FOR UPDATE ` @@ -456,6 +501,7 @@ func (q *Queries) LockAttachmentByStagingKey(ctx context.Context, stagingKey str &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -464,7 +510,7 @@ func (q *Queries) LockAttachmentByStagingKey(ctx context.Context, stagingKey str } const lockAttachmentJob = `-- name: LockAttachmentJob :one -SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments WHERE id = $1::uuid AND status = 'processing' AND job_id = $2::uuid @@ -506,6 +552,7 @@ func (q *Queries) LockAttachmentJob(ctx context.Context, arg LockAttachmentJobPa &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -514,7 +561,7 @@ func (q *Queries) LockAttachmentJob(ctx context.Context, arg LockAttachmentJobPa } const lockExpiredAttachmentJobs = `-- name: LockExpiredAttachmentJobs :many -SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, width, height, lease_until FROM attachments +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments WHERE status = 'processing' AND lease_until <= now() ORDER BY lease_until, id @@ -548,6 +595,7 @@ func (q *Queries) LockExpiredAttachmentJobs(ctx context.Context, batchSize int) &i.JobID, &i.PipelineVersion, &i.Attempts, + &i.RetryBase, &i.Width, &i.Height, &i.LeaseUntil, @@ -562,6 +610,46 @@ func (q *Queries) LockExpiredAttachmentJobs(ctx context.Context, batchSize int) return items, nil } +const lockFailedAttachmentForReplay = `-- name: LockFailedAttachmentForReplay :one +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments +WHERE id = $1::uuid + AND status = 'failed' + AND staging_key IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM attachment_variants + WHERE attachment_id = attachments.id + ) +FOR UPDATE +` + +func (q *Queries) LockFailedAttachmentForReplay(ctx context.Context, id uuid.UUID) (Attachment, error) { + row := q.db.QueryRow(ctx, lockFailedAttachmentForReplay, id) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.RetryBase, + &i.Width, + &i.Height, + &i.LeaseUntil, + ) + return i, err +} + const markAttachmentFailedIfReady = `-- name: MarkAttachmentFailedIfReady :execrows UPDATE attachments SET status = 'failed', @@ -601,6 +689,30 @@ func (q *Queries) RecoverExpiredAttachmentJob(ctx context.Context, id uuid.UUID) return result.RowsAffected(), nil } +const replayAttachmentJob = `-- name: ReplayAttachmentJob :execrows +UPDATE attachments +SET status = 'queued', + retry_base = attempts, + error_code = NULL, + lease_until = NULL, + updated_at = now() +WHERE id = $1::uuid + AND status = 'failed' + AND staging_key IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM attachment_variants + WHERE attachment_id = attachments.id + ) +` + +func (q *Queries) ReplayAttachmentJob(ctx context.Context, id uuid.UUID) (int64, error) { + result, err := q.db.Exec(ctx, replayAttachmentJob, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + const retryAttachmentJob = `-- name: RetryAttachmentJob :execrows UPDATE attachments SET status = 'queued', diff --git a/internal/db/models.go b/internal/db/models.go index 98dbdaf3..9a74b410 100644 --- a/internal/db/models.go +++ b/internal/db/models.go @@ -158,11 +158,21 @@ type Attachment struct { JobID *uuid.UUID PipelineVersion int Attempts int + RetryBase int Width *int32 Height *int32 LeaseUntil *time.Time } +type AttachmentReplay struct { + AttachmentID uuid.UUID + Attempt int + PreviousErrorCode *string + Operator string + Reason string + CreatedAt time.Time +} + type AttachmentVariant struct { AttachmentID uuid.UUID PipelineVersion int diff --git a/internal/worker/retry.go b/internal/worker/retry.go index b684fa4b..836f188b 100644 --- a/internal/worker/retry.go +++ b/internal/worker/retry.go @@ -39,7 +39,7 @@ func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cau } var n int64 - if permanent || row.Attempts >= w.cfg.MaxAttempts { + if permanent || row.Attempts-row.RetryBase >= w.cfg.MaxAttempts { if !permanent { code = "retry_exhausted" } @@ -59,7 +59,7 @@ func (w *Worker) finishFailure(ctx context.Context, job model.AttachmentJob, cau _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ AttachmentID: row.ID, Attempt: row.Attempts + 1, - AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + AvailableAt: time.Now().Add(retryDelay(row.Attempts - row.RetryBase)), }) } } @@ -119,7 +119,7 @@ func (w *Worker) recoverOne(ctx context.Context) (bool, error) { } row := rows[0] - if row.Attempts >= w.cfg.MaxAttempts { + if row.Attempts-row.RetryBase >= w.cfg.MaxAttempts { _, err = q.FailExpiredAttachmentJob(ctx, row.ID) } else { _, err = q.RecoverExpiredAttachmentJob(ctx, row.ID) @@ -127,7 +127,7 @@ func (w *Worker) recoverOne(ctx context.Context) (bool, error) { _, err = q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ AttachmentID: row.ID, Attempt: row.Attempts + 1, - AvailableAt: time.Now().Add(retryDelay(row.Attempts)), + AvailableAt: time.Now().Add(retryDelay(row.Attempts - row.RetryBase)), }) } } -- 2.54.0 From 6e09da0b463fec58a339dd00afa100f4ee934a3d Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 20:35:48 +0300 Subject: [PATCH 17/23] feat(worker): add safe failed attachment replay CLI --- cmd/worker/main.go | 136 ++++++++++++++++++++++++++++++----- internal/worker/job.go | 9 +-- internal/worker/replay.go | 86 ++++++++++++++++++++++ student-tests/worker_test.go | 84 ++++++++++++++++++++++ 4 files changed, 292 insertions(+), 23 deletions(-) create mode 100644 internal/worker/replay.go diff --git a/cmd/worker/main.go b/cmd/worker/main.go index cbcbd49b..08bccc29 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -7,19 +7,34 @@ import ( "fmt" "os" "os/signal" + "strings" "syscall" + "time" + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgxpool" "github.com/joho/godotenv" "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/db" "mtusi2026-messenger/internal/logger" "mtusi2026-messenger/internal/postgres" s3store "mtusi2026-messenger/internal/s3" "mtusi2026-messenger/internal/worker" ) +var ( + errConflictingReplayFlags = errors.New("replay and list-failed cannot be combined") + errInvalidReplayID = errors.New("replay must be an attachment UUID") + errMissingReplayAudit = errors.New("replay requires nonempty operator and reason") +) + func main() { maxPixels := flag.Int("process-image", 0, "process an image from stdin with the given pixel limit") + replay := flag.String("replay", "", "replay a failed attachment by UUID; requires retained staging and no existing variants") + operator := flag.String("operator", "", "operator requesting replay") + reason := flag.String("reason", "", "reason for replay") + listFailed := flag.Bool("list-failed", false, "list up to 100 failed attachments") flag.Parse() if *maxPixels > 0 { @@ -35,44 +50,107 @@ func main() { return } - if err := run(); err != nil { + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + + var err error + switch { + case *listFailed && *replay != "": + err = errConflictingReplayFlags + case *listFailed: + err = runListFailed(ctx) + case *replay != "": + err = runReplay(ctx, *replay, *operator, *reason) + default: + err = runWorker(ctx) + } + + if err != nil { fmt.Fprintln(os.Stderr, "worker:", err) os.Exit(1) } } -func run() error { - if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { - return err - } +func runListFailed(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, 30*time.Second) + defer cancel() - cfg := config.Load() - log := logger.New(cfg.Logging.Level) - databaseURL, err := cfg.Database.URL() + _, pool, err := loadDatabase(ctx) if err != nil { return err } + defer pool.Close() + + rows, err := db.New(pool).ListFailedAttachments(ctx, 100) + if err != nil { + return err + } + + for _, row := range rows { + code := "-" + if row.ErrorCode != nil { + code = *row.ErrorCode + } + + fmt.Printf("%s attempts=%d error_code=%s\n", row.ID, row.Attempts, code) + } + + return nil +} + +func runReplay(ctx context.Context, replay, operator, reason string) error { + replayID, err := uuid.Parse(replay) + if err != nil { + return errInvalidReplayID + } + + operator, reason = strings.TrimSpace(operator), strings.TrimSpace(reason) + if operator == "" || reason == "" { + return errMissingReplayAudit + } + + ctx, cancel := context.WithTimeout(ctx, 30*time.Second) + defer cancel() + + cfg, pool, err := loadDatabase(ctx) + if err != nil { + return err + } + defer pool.Close() + + log := logger.New(cfg.Logging.Level) + storage, err := s3store.NewAPI(ctx, cfg.S3, log) + if err != nil { + return err + } + + if err := worker.Replay(ctx, pool, storage, replayID, operator, reason); err != nil { + return err + } + + log.Info("attachment replay queued", "attachment_id", replayID, "operator", operator) + return nil +} + +func runWorker(ctx context.Context) error { + cfg, pool, err := loadDatabase(ctx) + if err != nil { + return err + } + defer pool.Close() brokerURL, err := cfg.Broker.URL() if err != nil { return err } - ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) - defer stop() - - pool, err := postgres.New(ctx, databaseURL) - if err != nil { - return err - } - defer pool.Close() - + log := logger.New(cfg.Logging.Level) storage, err := s3store.NewAPI(ctx, cfg.S3, log) if err != nil { return err } - worker.New( + w := worker.New( pool, storage, brokerURL, @@ -80,7 +158,27 @@ func run() error { cfg.S3.MaxUploadBytes, cfg.S3.MaxImagePixels, log, - ).Run(ctx) + ) + w.Run(ctx) return nil } + +func loadDatabase(ctx context.Context) (config.Config, *pgxpool.Pool, error) { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + return config.Config{}, nil, err + } + + cfg := config.Load() + databaseURL, err := cfg.Database.URL() + if err != nil { + return config.Config{}, nil, err + } + + pool, err := postgres.New(ctx, databaseURL) + if err != nil { + return config.Config{}, nil, err + } + + return cfg, pool, nil +} diff --git a/internal/worker/job.go b/internal/worker/job.go index 66b7775b..7a2bfe78 100644 --- a/internal/worker/job.go +++ b/internal/worker/job.go @@ -12,6 +12,7 @@ import ( "mtusi2026-messenger/internal/db" "mtusi2026-messenger/internal/model" + s3store "mtusi2026-messenger/internal/s3" ) var ( @@ -128,13 +129,13 @@ func (w *Worker) duplicate(ctx context.Context, job model.AttachmentJob) error { return err } - if err := w.verify(ctx, row.S3Key, row.SizeBytes, row.Sha256); err != nil { + if err := verify(ctx, w.s3, row.S3Key, row.SizeBytes, row.Sha256); err != nil { return err } hasThumbnail := false for _, variant := range variants { - if err := w.verify(ctx, variant.S3Key, variant.SizeBytes, variant.Sha256); err != nil { + if err := verify(ctx, w.s3, variant.S3Key, variant.SizeBytes, variant.Sha256); err != nil { return err } @@ -161,8 +162,8 @@ func (w *Worker) duplicate(ctx context.Context, job model.AttachmentJob) error { return errAttemptUnavailable } -func (w *Worker) verify(ctx context.Context, key string, size int, checksum string) error { - object, err := w.s3.Get(ctx, key) +func verify(ctx context.Context, storage *s3store.Client, key string, size int, checksum string) error { + object, err := storage.Get(ctx, key) if err != nil { return err } diff --git a/internal/worker/replay.go b/internal/worker/replay.go new file mode 100644 index 00000000..daccce4b --- /dev/null +++ b/internal/worker/replay.go @@ -0,0 +1,86 @@ +package worker + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + + "mtusi2026-messenger/internal/db" + s3store "mtusi2026-messenger/internal/s3" +) + +var ( + errAttachmentNotReplayable = errors.New("attachment is not replayable: expected failed with staging and no existing variants") + errMissingPipelineJob = errors.New("attachment has no pipeline job") + errReplayNotUpdated = errors.New("attachment replay did not update one row") +) + +type txBeginner interface { + Begin(ctx context.Context) (pgx.Tx, error) +} + +func Replay( + ctx context.Context, + pool txBeginner, + storage *s3store.Client, + id uuid.UUID, + operator, reason string, +) error { + tx, err := pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(context.Background()) + + q := db.New(tx) + row, err := q.LockFailedAttachmentForReplay(ctx, id) + if errors.Is(err, pgx.ErrNoRows) { + return errAttachmentNotReplayable + } + if err != nil { + return err + } + if row.JobID == nil { + return errMissingPipelineJob + } + + if err := verify(ctx, storage, *row.StagingKey, row.SizeBytes, row.Sha256); err != nil { + return fmt.Errorf("verify replay source: %w", err) + } + + n, err := q.ReplayAttachmentJob(ctx, id) + if err != nil { + return err + } + if n != 1 { + return errReplayNotUpdated + } + + if err := q.CreateAttachmentReplay(ctx, db.CreateAttachmentReplayParams{ + AttachmentID: id, + Attempt: row.Attempts + 1, + PreviousErrorCode: row.ErrorCode, + Operator: operator, + Reason: reason, + }); err != nil { + return err + } + + if _, err := q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: id, + Attempt: row.Attempts + 1, + AvailableAt: time.Now(), + }); err != nil { + return err + } + + if err := tx.Commit(ctx); err != nil { + return err + } + + return nil +} diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index fd50e0c6..4faad7c3 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -272,3 +272,87 @@ func TestWorkerProcessingTimeout(t *testing.T) { t.Fatal("parent worker restarted after the image timeout") } } + +func TestWorkerReplay(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + + testWorker := "worker-replay-" + uuid.NewString() + t.Cleanup(func() { + if testWorker != "" { + workerCommand(t, "rm", "-f", testWorker) + } + }) + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", testWorker, + "-e", "JOB_TIMEOUT_SECONDS=3", "-e", "JOB_MAX_ATTEMPTS=1", + "-e", "S3_ENDPOINT=http://127.0.0.1:1", "worker") + waitAttachment(t, user, att.ID, "failed", 15*time.Second) + workerCommand(t, "rm", "-f", testWorker) + testWorker = "" + + runCLI := func(args ...string) (string, error) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, "docker", append([]string{ + "compose", "run", "--rm", "--no-deps", "worker", + }, args...)...) + cmd.Dir = ".." + out, err := cmd.CombinedOutput() + return string(out), err + } + replayArgs := []string{"-replay", id, "-operator", "synthetic-operator", "-reason", "S3 restored"} + if out, err := runCLI("-list-failed"); err != nil || !strings.Contains(out, id) { + t.Fatalf("failed registry did not list attachment: %v\n%s", err, out) + } + if out, err := runCLI("-replay", id); err == nil || !strings.Contains(out, "nonempty operator and reason") { + t.Fatalf("replay without audit details was accepted: %v\n%s", err, out) + } + + // A stale DB key must not make a missing S3 source replayable. + key := workerSQL(t, "SELECT staging_key FROM attachments WHERE id='"+id+"'") + workerSQL(t, "UPDATE attachments SET staging_key='staging/"+uuid.NewString()+"' WHERE id='"+id+"'") + out, err := runCLI(replayArgs...) + workerSQL(t, "UPDATE attachments SET staging_key='"+key+"' WHERE id='"+id+"'") + if err == nil || !strings.Contains(out, "verify replay source") { + t.Fatalf("missing S3 source was accepted: %v\n%s", err, out) + } + if workerSQL(t, "SELECT status||':'||attempts||':'||retry_base FROM attachments WHERE id='"+id+"'") != "failed:1:0" || + workerSQL(t, "SELECT count(*) FROM attachment_replays WHERE "+where) != "0" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where) != "1" { + t.Fatal("rejected replay changed attachment, audit or outbox") + } + + if out, err := runCLI(replayArgs...); err != nil { + t.Fatalf("replay failed: %v\n%s", err, out) + } + if workerSQL(t, "SELECT status||':'||attempts||':'||retry_base FROM attachments WHERE id='"+id+"'") != "queued:1:1" || + workerSQL(t, "SELECT attempt||':'||operator||':'||reason||':'||previous_error_code FROM attachment_replays WHERE "+where) != + "2:synthetic-operator:S3 restored:retry_exhausted" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where) != "2" { + t.Fatal("replay did not atomically queue the next attempt with audit and outbox") + } + if out, err := runCLI(replayArgs...); err == nil || !strings.Contains(out, "not replayable") { + t.Fatalf("queued replay was accepted twice: %v\n%s", err, out) + } + + compose(t, "start", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 30*time.Second) + if len(ready.Variants) != 3 || !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { + t.Fatal("replay did not complete the same attachment with unchanged original") + } + if out, err := runCLI(replayArgs...); err == nil || !strings.Contains(out, "not replayable") { + t.Fatalf("ready replay was accepted: %v\n%s", err, out) + } + if workerSQL(t, "SELECT count(*) FROM attachment_replays WHERE "+where) != "1" || + workerSQL(t, "SELECT attempts FROM attachments WHERE id='"+id+"'") != "2" { + t.Fatal("duplicate replay changed audit or attempt counter") + } +} -- 2.54.0 From 6ba7db4b7d198ae9a7b695101f8515d25e37b5b5 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 21:13:30 +0300 Subject: [PATCH 18/23] test(worker): verify crash recovery and lease expiration --- compose.yaml | 1 + student-tests/worker_test.go | 139 +++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+) diff --git a/compose.yaml b/compose.yaml index 1e160378..33c1e3c5 100644 --- a/compose.yaml +++ b/compose.yaml @@ -165,6 +165,7 @@ services: command: - "server" - "-dir=/data" + - "-volume.max=10" - "-s3" - "-s3.port=9000" - "-s3.iam=false" diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index 4faad7c3..5e41431d 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -9,6 +9,7 @@ import ( "image/jpeg" "io" "net/http" + "os" "os/exec" "reflect" "strconv" @@ -17,6 +18,7 @@ import ( "time" "github.com/google/uuid" + "github.com/jackc/pgx/v5" "golang.org/x/image/webp" "mtusi2026-messenger/internal/dto" @@ -356,3 +358,140 @@ func TestWorkerReplay(t *testing.T) { t.Fatal("duplicate replay changed audit or attempt counter") } } + +func TestWorkerOutboxRecovery(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + + stopService(t, "rabbitmq") + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + jobID := workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") + if workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND attempt=1 AND published_at IS NULL") != "1" { + t.Fatal("upload 202 did not persist an unpublished intent") + } + + t.Cleanup(func() { + compose(t, "start", "api") + waitReady(t) + }) + compose(t, "kill", "-s", "SIGKILL", "api") + if workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND attempt=1 AND published_at IS NULL") != "1" { + t.Fatal("committed intent lost after API crash") + } + + compose(t, "start", "api") + waitReady(t) + waitAttachment(t, user, att.ID, "queued", 15*time.Second) + compose(t, "up", "-d", "--no-deps", "--wait", "--wait-timeout", "30", "rabbitmq") + workerWait(t, "outbox publication after API crash", 15*time.Second, func() bool { + return workerSQL(t, "SELECT published_at IS NOT NULL FROM outbox WHERE "+where) == "t" + }) + if workerQueue(t) != "1:0" { + t.Fatal("recovered intent was not delivered to broker") + } + + compose(t, "start", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 30*time.Second) + if len(ready.Variants) != 3 || !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { + t.Fatal("recovered attachment has incomplete variants or changed original") + } + workerWait(t, "recovered job acknowledgement", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + if workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") != jobID || + workerSQL(t, "SELECT attempts FROM attachments WHERE id='"+id+"'") != "1" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where) != "1" { + t.Fatal("recovery replaced the job or created another attempt") + } + + t.Logf("PASS attachment=%s: commit, API SIGKILL before publication, automatic outbox recovery, same job ready", id) +} + +func TestWorkerLeaseRecovery(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + secret, err := os.ReadFile("../secrets/test_database_url.txt") + if err != nil { + t.Fatal("read test database URL") + } + conn, err := pgx.Connect(ctx, strings.TrimSpace(string(secret))) + if err != nil { + t.Fatal("connect to test database") + } + t.Cleanup(func() { conn.Close(context.Background()) }) + + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + jobID := workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") + + testWorker := "worker-lease-" + uuid.NewString() + t.Cleanup(func() { workerCommand(t, "rm", "-f", testWorker) }) + tx, err := conn.Begin(ctx) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { tx.Rollback(context.Background()) }) + // S3 writes finish before variant metadata is inserted. Block that INSERT + // to kill the worker before the result COMMIT and broker acknowledgement. + if _, err := tx.Exec(ctx, "LOCK TABLE attachment_variants IN SHARE MODE"); err != nil { + t.Fatal(err) + } + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", testWorker, + "-e", "JOB_TIMEOUT_SECONDS=15", "worker") + workerWait(t, "variant INSERT blocked after S3 writes", 10*time.Second, func() bool { + var blocked bool + if _, err := conn.Exec(ctx, "SELECT pg_stat_clear_snapshot()"); err != nil { + t.Fatal(err) + } + err := conn.QueryRow(ctx, `SELECT EXISTS ( + SELECT 1 FROM pg_stat_activity + WHERE $1::int = ANY(pg_blocking_pids(pid)) + AND query LIKE '%INSERT INTO attachment_variants%' + )`, int32(conn.PgConn().PID())).Scan(&blocked) + if err != nil { + t.Fatal(err) + } + return blocked + }) + workerCommand(t, "kill", "--signal", "SIGKILL", testWorker) + if err := tx.Rollback(ctx); err != nil { + t.Fatal(err) + } + if workerSQL(t, "SELECT status||':'||attempts FROM attachments WHERE id='"+id+"'") != "processing:1" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "0" { + t.Fatal("crashed worker committed a result") + } + workerWait(t, "unacknowledged job returned to broker", 10*time.Second, func() bool { + return workerQueue(t) == "1:0" + }) + + // Leave lease_until unchanged: recovery must wait for its natural expiry. + compose(t, "start", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 40*time.Second) + if len(ready.Variants) != 3 || !bytes.Equal(workerContent(t, user, att.ID, "original"), source) { + t.Fatal("lease recovery lost variants or changed original") + } + workerWait(t, "recovered job acknowledgement", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + if workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") != jobID || + workerSQL(t, "SELECT attempts FROM attachments WHERE id='"+id+"'") != "2" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "3" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND attempt=2 AND published_at IS NOT NULL") != "1" { + t.Fatal("lease recovery replaced the job, duplicated variants or skipped retry publication") + } + t.Logf("PASS attachment=%s: SIGKILL after S3 writes, expired lease recovered, same job ready on attempt 2", id) +} -- 2.54.0 From 5442dfd3bc0127cc9ca0b8db85e17aacd517175e Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 22:06:11 +0300 Subject: [PATCH 19/23] feat(worker): add versioned image processing --- cmd/worker/main.go | 3 +- internal/worker/image.go | 30 +++++-- internal/worker/image_process.go | 11 ++- student-tests/image_pipeline_test.go | 126 +++++++++++++++++++++++++++ student.mk | 6 +- 5 files changed, 161 insertions(+), 15 deletions(-) create mode 100644 student-tests/image_pipeline_test.go diff --git a/cmd/worker/main.go b/cmd/worker/main.go index 08bccc29..60c1cd8a 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -31,6 +31,7 @@ var ( func main() { maxPixels := flag.Int("process-image", 0, "process an image from stdin with the given pixel limit") + pipelineVersion := flag.Int("pipeline-version", 1, "pipeline version for process-image") replay := flag.String("replay", "", "replay a failed attachment by UUID; requires retained staging and no existing variants") operator := flag.String("operator", "", "operator requesting replay") reason := flag.String("reason", "", "reason for replay") @@ -38,7 +39,7 @@ func main() { flag.Parse() if *maxPixels > 0 { - if err := worker.ProcessImage(*maxPixels); err != nil { + if err := worker.ProcessImage(*maxPixels, *pipelineVersion); err != nil { if errors.Is(err, worker.ErrInvalidSource) { os.Exit(2) } diff --git a/internal/worker/image.go b/internal/worker/image.go index ae1e7a42..fe6091a4 100644 --- a/internal/worker/image.go +++ b/internal/worker/image.go @@ -21,7 +21,10 @@ import ( "mtusi2026-messenger/internal/db" ) -var ErrInvalidSource = errors.New("invalid source image") +var ( + ErrInvalidSource = errors.New("invalid source image") + ErrUnsupportedPipelineVersion = errors.New("unsupported pipeline version") +) type imageVariant struct { Name db.AttachmentVariantName @@ -78,7 +81,7 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt return nil, err } - images, err := runImageProcess(ctx, tmp, w.maxPixels) + images, err := runImageProcess(ctx, tmp, w.maxPixels, row.PipelineVersion) <-w.decodeSlot if err != nil { return nil, err @@ -120,7 +123,16 @@ func (w *Worker) process(ctx context.Context, row db.Attachment) ([]db.CreateAtt return variants, nil } -func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { +func imageVariants(r io.ReadSeeker, maxPixels, pipelineVersion int) ([]imageVariant, error) { + quality := 80 + switch pipelineVersion { + case 1: + case 2: + quality = 75 + default: + return nil, ErrUnsupportedPipelineVersion + } + cfg, format, err := image.DecodeConfig(r) if err != nil || (format != "png" && format != "jpeg") || @@ -152,9 +164,9 @@ func imageVariants(r io.ReadSeeker, maxPixels int) ([]imageVariant, error) { contentType := "image/jpeg" if item.name == db.AttachmentVariantNameOptimized { contentType = "image/webp" - data, err = encodeWebP(item.image) + data, err = encodeWebP(item.image, quality) } else { - data, err = encodeJPEG(item.image) + data, err = encodeJPEG(item.image, 85) } if err != nil { @@ -190,22 +202,22 @@ func fitImage(src image.Image, maxSize int) image.Image { return src } -func encodeJPEG(src image.Image) ([]byte, error) { +func encodeJPEG(src image.Image, quality int) ([]byte, error) { dst := image.NewRGBA(image.Rect(0, 0, src.Bounds().Dx(), src.Bounds().Dy())) draw.Draw(dst, dst.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src) draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Over) var out bytes.Buffer - if err := jpeg.Encode(&out, dst, &jpeg.Options{Quality: 85}); err != nil { + if err := jpeg.Encode(&out, dst, &jpeg.Options{Quality: quality}); err != nil { return nil, err } return out.Bytes(), nil } -func encodeWebP(src image.Image) ([]byte, error) { +func encodeWebP(src image.Image, quality int) ([]byte, error) { var out bytes.Buffer - if err := webp.Encode(&out, src, webp.Options{Quality: 80, Method: 4}); err != nil { + if err := webp.Encode(&out, src, webp.Options{Quality: quality, Method: 4}); err != nil { return nil, err } diff --git a/internal/worker/image_process.go b/internal/worker/image_process.go index 4811d5a8..e0f17b3a 100644 --- a/internal/worker/image_process.go +++ b/internal/worker/image_process.go @@ -10,8 +10,8 @@ import ( "strconv" ) -func ProcessImage(maxPixels int) error { - variants, err := imageVariants(os.Stdin, maxPixels) +func ProcessImage(maxPixels, pipelineVersion int) error { + variants, err := imageVariants(os.Stdin, maxPixels, pipelineVersion) if err != nil { return err } @@ -19,13 +19,16 @@ func ProcessImage(maxPixels int) error { return gob.NewEncoder(os.Stdout).Encode(variants) } -func runImageProcess(ctx context.Context, source *os.File, maxPixels int) ([]imageVariant, error) { +func runImageProcess(ctx context.Context, source *os.File, maxPixels, pipelineVersion int) ([]imageVariant, error) { executable, err := os.Executable() if err != nil { return nil, err } - cmd := exec.CommandContext(ctx, executable, "-process-image", strconv.Itoa(maxPixels)) + cmd := exec.CommandContext(ctx, executable, + "-process-image", strconv.Itoa(maxPixels), + "-pipeline-version", strconv.Itoa(pipelineVersion), + ) cmd.Stdin = source data, err := cmd.Output() if ctx.Err() != nil { diff --git a/student-tests/image_pipeline_test.go b/student-tests/image_pipeline_test.go new file mode 100644 index 00000000..b951f179 --- /dev/null +++ b/student-tests/image_pipeline_test.go @@ -0,0 +1,126 @@ +//go:build pipeline + +package studenttests_test + +import ( + "bytes" + "context" + "encoding/gob" + "image" + "image/color" + "image/jpeg" + "image/png" + "os" + "os/exec" + "path/filepath" + "testing" + "time" + + "golang.org/x/image/webp" +) + +func TestPipelineImageVersions(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + + binary := filepath.Join(t.TempDir(), "worker") + build := exec.CommandContext(ctx, "go", "build", "-tags=nodynamic", "-o", binary, "../cmd/worker") + if out, err := build.CombinedOutput(); err != nil { + t.Fatalf("build worker: %v\n%s", err, out) + } + + src := image.NewNRGBA(image.Rect(0, 0, 320, 200)) + for y := 0; y < 200; y++ { + for x := 0; x < 320; x++ { + src.SetNRGBA(x, y, color.NRGBA{ + R: uint8(x*17 + y*3), + G: uint8(x*5 + y*11), + B: uint8(x * y), A: 255, + }) + } + } + + var source bytes.Buffer + if err := png.Encode(&source, src); err != nil { + t.Fatal(err) + } + + sourcePath := filepath.Join(t.TempDir(), "source.png") + if err := os.WriteFile(sourcePath, source.Bytes(), 0600); err != nil { + t.Fatal(err) + } + + // Decode the child process protocol without exporting worker internals. + type variant struct { + Name, ContentType string + Data []byte + Width, Height int + } + process := func(version string) []variant { + t.Helper() + args := []string{"-process-image", "40000000"} + if version != "" { + args = append(args, "-pipeline-version", version) + } + cmd := exec.CommandContext(ctx, binary, args...) + input, err := os.Open(sourcePath) + if err != nil { + t.Fatal(err) + } + defer input.Close() + cmd.Stdin = input + var stderr bytes.Buffer + cmd.Stderr = &stderr + out, err := cmd.Output() + if err != nil { + t.Fatalf("process v%s: %v: %s", version, err, stderr.String()) + } + + var variants []variant + if err := gob.NewDecoder(bytes.NewReader(out)).Decode(&variants); err != nil { + t.Fatal(err) + } + if len(variants) != 3 { + t.Fatalf("expected three variants, got %d", len(variants)) + } + for i, name := range []string{"thumbnail", "crop", "optimized"} { + v := variants[i] + var cfg image.Config + var err error + width, height, contentType := 256, 160, "image/jpeg" + if name == "optimized" { + width, height, contentType = 320, 200, "image/webp" + cfg, err = webp.DecodeConfig(bytes.NewReader(v.Data)) + } else { + if name == "crop" { + width, height = 128, 128 + } + cfg, err = jpeg.DecodeConfig(bytes.NewReader(v.Data)) + } + if err != nil || v.Name != name || v.ContentType != contentType || + v.Width != width || v.Height != height || cfg.Width != width || cfg.Height != height { + t.Fatalf("invalid v%s %s: metadata=%dx%d, decoded=%dx%d, error=%v", + version, name, v.Width, v.Height, cfg.Width, cfg.Height, err) + } + } + return variants + } + + v1, v2 := process("1"), process("2") + defaultVersion := process("") + for i := range v1 { + if !bytes.Equal(v1[i].Data, defaultVersion[i].Data) { + t.Fatal("default processing differs from v1") + } + wantEqual := v1[i].Name != "optimized" + if bytes.Equal(v1[i].Data, v2[i].Data) != wantEqual { + t.Fatalf("expected only optimized bytes to differ: %s", v1[i].Name) + } + } + + cmd := exec.CommandContext(ctx, binary, "-process-image", "40000000", "-pipeline-version", "3") + cmd.Stdin = bytes.NewReader(source.Bytes()) + if out, err := cmd.Output(); err == nil || len(out) != 0 { + t.Fatal("unsupported version must fail without a result") + } +} diff --git a/student.mk b/student.mk index c5c51fa9..acae1ddd 100644 --- a/student.mk +++ b/student.mk @@ -8,7 +8,7 @@ ACTION ?= stop-one.sh ACTION_AT ?= 10s DRY_RUN ?= true -.PHONY: help-go contract-go race-go load-go failure-go load-action-go reconcile reconcile-test-go worker-go +.PHONY: help-go contract-go race-go load-go failure-go load-action-go reconcile reconcile-test-go worker-go pipeline-go help-go: @echo "contract-go: contract tests" @@ -17,6 +17,7 @@ help-go: @echo "load-go: load test" @echo "failure-go: dependency failure tests (stops redis/postgres/s3 containers)" @echo "reconcile: attachment audit; DRY_RUN=false to repair" + @echo "pipeline-go: image pipeline versions (no running services required)" contract-go: go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL) @@ -46,3 +47,6 @@ reconcile-test-go: worker-go: go test -count=1 -tags=worker ./student-tests/... -v -args -base-url=$(BASE_URL) + +pipeline-go: + go test -count=1 -tags=nodynamic,pipeline ./student-tests/... -v -- 2.54.0 From f8ca7a72182e940f8c3cff3ace4585e02650a024 Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 22:26:35 +0300 Subject: [PATCH 20/23] feat(worker): add pipeline version upgrade command --- cmd/worker/main.go | 42 +++++++++++++-- db/migrations/00004_attachment_pipeline.sql | 2 +- db/queries/attachments.sql | 21 ++++++++ internal/db/attachments.sql.go | 59 ++++++++++++++++++++ internal/worker/upgrade.go | 60 +++++++++++++++++++++ internal/worker/worker.go | 2 +- 6 files changed, 181 insertions(+), 5 deletions(-) create mode 100644 internal/worker/upgrade.go diff --git a/cmd/worker/main.go b/cmd/worker/main.go index 60c1cd8a..06dcb162 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -24,9 +24,11 @@ import ( ) var ( - errConflictingReplayFlags = errors.New("replay and list-failed cannot be combined") - errInvalidReplayID = errors.New("replay must be an attachment UUID") - errMissingReplayAudit = errors.New("replay requires nonempty operator and reason") + errConflictingReplayFlags = errors.New("replay and list-failed cannot be combined") + errInvalidReplayID = errors.New("replay must be an attachment UUID") + errMissingReplayAudit = errors.New("replay requires nonempty operator and reason") + errConflictingUpgradeFlags = errors.New("upgrade cannot be combined with replay or list-failed") + errInvalidUpgradeID = errors.New("upgrade must be an attachment UUID") ) func main() { @@ -36,6 +38,7 @@ func main() { operator := flag.String("operator", "", "operator requesting replay") reason := flag.String("reason", "", "reason for replay") listFailed := flag.Bool("list-failed", false, "list up to 100 failed attachments") + upgrade := flag.String("upgrade", "", "upgrade a v1 queued or processing attachment to v2; requires retained staging") flag.Parse() if *maxPixels > 0 { @@ -56,12 +59,16 @@ func main() { var err error switch { + case *upgrade != "" && (*listFailed || *replay != ""): + err = errConflictingUpgradeFlags case *listFailed && *replay != "": err = errConflictingReplayFlags case *listFailed: err = runListFailed(ctx) case *replay != "": err = runReplay(ctx, *replay, *operator, *reason) + case *upgrade != "": + err = runUpgrade(ctx, *upgrade) default: err = runWorker(ctx) } @@ -133,6 +140,35 @@ func runReplay(ctx context.Context, replay, operator, reason string) error { return nil } +func runUpgrade(ctx context.Context, upgrade string) error { + id, err := uuid.Parse(upgrade) + if err != nil { + return errInvalidUpgradeID + } + + ctx, cancel := context.WithTimeout(ctx, 30*time.Second) + defer cancel() + + cfg, pool, err := loadDatabase(ctx) + if err != nil { + return err + } + defer pool.Close() + + log := logger.New(cfg.Logging.Level) + storage, err := s3store.NewAPI(ctx, cfg.S3, log) + if err != nil { + return err + } + + if err := worker.Upgrade(ctx, pool, storage, id); err != nil { + return err + } + + log.Info("attachment pipeline upgrade queued", "attachment_id", id, "pipeline_version", 2) + return nil +} + func runWorker(ctx context.Context) error { cfg, pool, err := loadDatabase(ctx) if err != nil { diff --git a/db/migrations/00004_attachment_pipeline.sql b/db/migrations/00004_attachment_pipeline.sql index 9bd17b93..676f4563 100644 --- a/db/migrations/00004_attachment_pipeline.sql +++ b/db/migrations/00004_attachment_pipeline.sql @@ -35,7 +35,7 @@ CREATE TABLE outbox ( created_at timestamptz NOT NULL DEFAULT now(), available_at timestamptz NOT NULL DEFAULT now(), published_at timestamptz, - UNIQUE (job_id, attempt) + UNIQUE (job_id, pipeline_version, attempt) ); CREATE INDEX idx_outbox_pending ON outbox (available_at, id) WHERE published_at IS NULL; diff --git a/db/queries/attachments.sql b/db/queries/attachments.sql index 94060500..d0de5aab 100644 --- a/db/queries/attachments.sql +++ b/db/queries/attachments.sql @@ -113,6 +113,14 @@ WHERE id = sqlc.arg(id)::uuid ) FOR UPDATE; +-- name: LockAttachmentForUpgrade :one +SELECT * FROM attachments +WHERE id = sqlc.arg(id)::uuid + AND pipeline_version = 1 + AND status IN ('queued', 'processing') + AND staging_key IS NOT NULL +FOR UPDATE; + -- name: ClearAttachmentStagingKey :exec UPDATE attachments SET staging_key = NULL @@ -160,6 +168,19 @@ WHERE id = sqlc.arg(id)::uuid AND attempts = sqlc.arg(attempt)::int AND lease_until > now(); +-- name: UpgradeAttachmentPipeline :execrows +UPDATE attachments +SET pipeline_version = 2, + status = 'queued', + retry_base = attempts, + error_code = NULL, + lease_until = NULL, + updated_at = now() +WHERE id = sqlc.arg(id)::uuid + AND pipeline_version = 1 + AND status IN ('queued', 'processing') + AND staging_key IS NOT NULL; + -- name: ReplayAttachmentJob :execrows UPDATE attachments SET status = 'queued', diff --git a/internal/db/attachments.sql.go b/internal/db/attachments.sql.go index b367fe26..a0a12720 100644 --- a/internal/db/attachments.sql.go +++ b/internal/db/attachments.sql.go @@ -509,6 +509,43 @@ func (q *Queries) LockAttachmentByStagingKey(ctx context.Context, stagingKey str return i, err } +const lockAttachmentForUpgrade = `-- name: LockAttachmentForUpgrade :one +SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments +WHERE id = $1::uuid + AND pipeline_version = 1 + AND status IN ('queued', 'processing') + AND staging_key IS NOT NULL +FOR UPDATE +` + +func (q *Queries) LockAttachmentForUpgrade(ctx context.Context, id uuid.UUID) (Attachment, error) { + row := q.db.QueryRow(ctx, lockAttachmentForUpgrade, id) + var i Attachment + err := row.Scan( + &i.ID, + &i.ChatID, + &i.OwnerID, + &i.S3Key, + &i.Filename, + &i.ContentType, + &i.SizeBytes, + &i.Sha256, + &i.Status, + &i.ErrorCode, + &i.CreatedAt, + &i.UpdatedAt, + &i.StagingKey, + &i.JobID, + &i.PipelineVersion, + &i.Attempts, + &i.RetryBase, + &i.Width, + &i.Height, + &i.LeaseUntil, + ) + return i, err +} + const lockAttachmentJob = `-- name: LockAttachmentJob :one SELECT id, chat_id, owner_id, s3_key, filename, content_type, size_bytes, sha256, status, error_code, created_at, updated_at, staging_key, job_id, pipeline_version, attempts, retry_base, width, height, lease_until FROM attachments WHERE id = $1::uuid @@ -738,3 +775,25 @@ func (q *Queries) RetryAttachmentJob(ctx context.Context, arg RetryAttachmentJob } return result.RowsAffected(), nil } + +const upgradeAttachmentPipeline = `-- name: UpgradeAttachmentPipeline :execrows +UPDATE attachments +SET pipeline_version = 2, + status = 'queued', + retry_base = attempts, + error_code = NULL, + lease_until = NULL, + updated_at = now() +WHERE id = $1::uuid + AND pipeline_version = 1 + AND status IN ('queued', 'processing') + AND staging_key IS NOT NULL +` + +func (q *Queries) UpgradeAttachmentPipeline(ctx context.Context, id uuid.UUID) (int64, error) { + result, err := q.db.Exec(ctx, upgradeAttachmentPipeline, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} diff --git a/internal/worker/upgrade.go b/internal/worker/upgrade.go new file mode 100644 index 00000000..ed1dd92a --- /dev/null +++ b/internal/worker/upgrade.go @@ -0,0 +1,60 @@ +package worker + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + + "mtusi2026-messenger/internal/db" + s3store "mtusi2026-messenger/internal/s3" +) + +var ( + errAttachmentNotUpgradeable = errors.New("attachment is not upgradeable: expected v1 queued or processing with staging") + errUpgradeNotUpdated = errors.New("attachment upgrade did not update one row") +) + +func Upgrade(ctx context.Context, pool txBeginner, storage *s3store.Client, id uuid.UUID) error { + tx, err := pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(context.Background()) + + q := db.New(tx) + row, err := q.LockAttachmentForUpgrade(ctx, id) + if errors.Is(err, pgx.ErrNoRows) { + return errAttachmentNotUpgradeable + } + if err != nil { + return err + } + if row.JobID == nil { + return errMissingPipelineJob + } + + if err := verify(ctx, storage, *row.StagingKey, row.SizeBytes, row.Sha256); err != nil { + return err + } + + n, err := q.UpgradeAttachmentPipeline(ctx, id) + if err != nil { + return err + } + if n != 1 { + return errUpgradeNotUpdated + } + + if _, err := q.CreateOutboxEntry(ctx, db.CreateOutboxEntryParams{ + AttachmentID: id, + Attempt: row.Attempts + 1, + AvailableAt: time.Now(), + }); err != nil { + return err + } + + return tx.Commit(ctx) +} diff --git a/internal/worker/worker.go b/internal/worker/worker.go index a02cf82e..9a7f6f6a 100644 --- a/internal/worker/worker.go +++ b/internal/worker/worker.go @@ -116,7 +116,7 @@ func (w *Worker) consume(ctx context.Context, client *rabbitmq.Client) error { job.Type != "attachment.process.v1" || job.JobID == uuid.Nil || job.AttachmentID == uuid.Nil || - job.PipelineVersion != 1 || + (job.PipelineVersion != 1 && job.PipelineVersion != 2) || job.Attempt < 1 || job.CreatedAt.IsZero() { if err := delivery.Reject(false); err != nil { -- 2.54.0 From 179c7957586bf56ac10d494ea21c3747a53ca63c Mon Sep 17 00:00:00 2001 From: kk10 Date: Mon, 16 Nov 2026 22:51:35 +0300 Subject: [PATCH 21/23] test(pipeline): verify idempotency under faults and reordered delivery --- student-tests/attachment_helpers_test.go | 2 +- student-tests/compose_helpers_test.go | 79 +++++- student-tests/image_pipeline_test.go | 126 ---------- student-tests/pipeline_fault_test.go | 302 +++++++++++++++++++++++ student-tests/worker_test.go | 71 ------ student.mk | 4 +- 6 files changed, 383 insertions(+), 201 deletions(-) delete mode 100644 student-tests/image_pipeline_test.go create mode 100644 student-tests/pipeline_fault_test.go diff --git a/student-tests/attachment_helpers_test.go b/student-tests/attachment_helpers_test.go index dd87cb9c..ebb80bc1 100644 --- a/student-tests/attachment_helpers_test.go +++ b/student-tests/attachment_helpers_test.go @@ -1,4 +1,4 @@ -//go:build contract || reconcile || failure || worker +//go:build contract || reconcile || failure || worker || pipeline package studenttests_test diff --git a/student-tests/compose_helpers_test.go b/student-tests/compose_helpers_test.go index a5d176da..58c36047 100644 --- a/student-tests/compose_helpers_test.go +++ b/student-tests/compose_helpers_test.go @@ -1,12 +1,19 @@ -//go:build failure || worker +//go:build failure || worker || pipeline package studenttests_test import ( + "context" + "io" "net/http" "os/exec" + "strings" "testing" "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" ) func compose(t *testing.T, args ...string) { @@ -45,3 +52,73 @@ func waitReady(t *testing.T) { } t.Fatal("service did not become ready in 60s") } + +func workerCommand(t *testing.T, args ...string) string { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, "docker", args...) + cmd.Dir = ".." + out, err := cmd.Output() + if err != nil { + t.Fatalf("Docker command failed: %v", err) + } + return strings.TrimSpace(string(out)) +} + +func workerSQL(t *testing.T, query string) string { + t.Helper() + return workerCommand(t, "compose", "exec", "-T", "postgres", "psql", + "-U", "messenger", "-d", "messenger", "-Atqc", query) +} + +func workerWait(t *testing.T, description string, timeout time.Duration, condition func() bool) { + t.Helper() + deadline := time.Now().Add(timeout) + for time.Now().Before(deadline) { + if condition() { + return + } + time.Sleep(300 * time.Millisecond) + } + t.Fatalf("timeout waiting for %s", description) +} + +func workerQueue(t *testing.T) string { + t.Helper() + out := workerCommand(t, "compose", "exec", "-T", "rabbitmq", "rabbitmqctl", + "list_queues", "name", "messages_ready", "messages_unacknowledged", "--silent") + for _, line := range strings.Split(out, "\n") { + fields := strings.Fields(line) + if len(fields) == 3 && fields[0] == "attachments.process.v1" { + return fields[1] + ":" + fields[2] + } + } + t.Fatal("attachment queue missing") + return "" +} + +func workerUpload(t *testing.T, user testUser, chatID uuid.UUID) (dto.AttachmentResponse, []byte) { + t.Helper() + source := makePNG(t, 320, 200) + resp := uploadAttachment(t, user, chatID, "worker.png", "image/png", source) + requireStatus(t, resp, http.StatusAccepted) + var att dto.AttachmentResponse + mustDecode(t, resp, &att) + if att.Status != "queued" { + t.Fatalf("expected queued, got %s", att.Status) + } + return att, source +} + +func workerContent(t *testing.T, user testUser, id uuid.UUID, variant string) []byte { + t.Helper() + resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+id.String()+"/content?variant="+variant, user.Token, nil) + requireStatus(t, resp, http.StatusOK) + defer resp.Body.Close() + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + return data +} diff --git a/student-tests/image_pipeline_test.go b/student-tests/image_pipeline_test.go deleted file mode 100644 index b951f179..00000000 --- a/student-tests/image_pipeline_test.go +++ /dev/null @@ -1,126 +0,0 @@ -//go:build pipeline - -package studenttests_test - -import ( - "bytes" - "context" - "encoding/gob" - "image" - "image/color" - "image/jpeg" - "image/png" - "os" - "os/exec" - "path/filepath" - "testing" - "time" - - "golang.org/x/image/webp" -) - -func TestPipelineImageVersions(t *testing.T) { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - - binary := filepath.Join(t.TempDir(), "worker") - build := exec.CommandContext(ctx, "go", "build", "-tags=nodynamic", "-o", binary, "../cmd/worker") - if out, err := build.CombinedOutput(); err != nil { - t.Fatalf("build worker: %v\n%s", err, out) - } - - src := image.NewNRGBA(image.Rect(0, 0, 320, 200)) - for y := 0; y < 200; y++ { - for x := 0; x < 320; x++ { - src.SetNRGBA(x, y, color.NRGBA{ - R: uint8(x*17 + y*3), - G: uint8(x*5 + y*11), - B: uint8(x * y), A: 255, - }) - } - } - - var source bytes.Buffer - if err := png.Encode(&source, src); err != nil { - t.Fatal(err) - } - - sourcePath := filepath.Join(t.TempDir(), "source.png") - if err := os.WriteFile(sourcePath, source.Bytes(), 0600); err != nil { - t.Fatal(err) - } - - // Decode the child process protocol without exporting worker internals. - type variant struct { - Name, ContentType string - Data []byte - Width, Height int - } - process := func(version string) []variant { - t.Helper() - args := []string{"-process-image", "40000000"} - if version != "" { - args = append(args, "-pipeline-version", version) - } - cmd := exec.CommandContext(ctx, binary, args...) - input, err := os.Open(sourcePath) - if err != nil { - t.Fatal(err) - } - defer input.Close() - cmd.Stdin = input - var stderr bytes.Buffer - cmd.Stderr = &stderr - out, err := cmd.Output() - if err != nil { - t.Fatalf("process v%s: %v: %s", version, err, stderr.String()) - } - - var variants []variant - if err := gob.NewDecoder(bytes.NewReader(out)).Decode(&variants); err != nil { - t.Fatal(err) - } - if len(variants) != 3 { - t.Fatalf("expected three variants, got %d", len(variants)) - } - for i, name := range []string{"thumbnail", "crop", "optimized"} { - v := variants[i] - var cfg image.Config - var err error - width, height, contentType := 256, 160, "image/jpeg" - if name == "optimized" { - width, height, contentType = 320, 200, "image/webp" - cfg, err = webp.DecodeConfig(bytes.NewReader(v.Data)) - } else { - if name == "crop" { - width, height = 128, 128 - } - cfg, err = jpeg.DecodeConfig(bytes.NewReader(v.Data)) - } - if err != nil || v.Name != name || v.ContentType != contentType || - v.Width != width || v.Height != height || cfg.Width != width || cfg.Height != height { - t.Fatalf("invalid v%s %s: metadata=%dx%d, decoded=%dx%d, error=%v", - version, name, v.Width, v.Height, cfg.Width, cfg.Height, err) - } - } - return variants - } - - v1, v2 := process("1"), process("2") - defaultVersion := process("") - for i := range v1 { - if !bytes.Equal(v1[i].Data, defaultVersion[i].Data) { - t.Fatal("default processing differs from v1") - } - wantEqual := v1[i].Name != "optimized" - if bytes.Equal(v1[i].Data, v2[i].Data) != wantEqual { - t.Fatalf("expected only optimized bytes to differ: %s", v1[i].Name) - } - } - - cmd := exec.CommandContext(ctx, binary, "-process-image", "40000000", "-pipeline-version", "3") - cmd.Stdin = bytes.NewReader(source.Bytes()) - if out, err := cmd.Output(); err == nil || len(out) != 0 { - t.Fatal("unsupported version must fail without a result") - } -} diff --git a/student-tests/pipeline_fault_test.go b/student-tests/pipeline_fault_test.go new file mode 100644 index 00000000..48960bfe --- /dev/null +++ b/student-tests/pipeline_fault_test.go @@ -0,0 +1,302 @@ +//go:build pipeline + +package studenttests_test + +import ( + "bytes" + "encoding/base64" + "reflect" + "testing" + "time" + + "github.com/google/uuid" + "golang.org/x/image/webp" +) + +func pipelineS3Gate(t *testing.T, suffix string) (string, func(string) string) { + t.Helper() + proxy := "pipeline-gate-" + uuid.NewString() + workerContainer := workerCommand(t, "compose", "ps", "-a", "-q", "worker") + network := workerCommand(t, "inspect", "--format", + "{{range $name, $value := .NetworkSettings.Networks}}{{$name}}{{end}}", workerContainer) + t.Cleanup(func() { workerCommand(t, "rm", "-f", proxy) }) + const proxyScript = ` +import base64 +import http.client +import http.server +import threading +import sys + +waiting = threading.Event() +release = threading.Event() +written = threading.Event() +held_body = b'' + +class Proxy(http.server.BaseHTTPRequestHandler): + def log_message(self, *args): + pass + + def do_GET(self): + if self.path == '/_body': + self.send_response(200) + self.end_headers() + self.wfile.write(base64.b64encode(held_body)) + return + if self.path == '/_state': + data = f'{int(waiting.is_set())}:{int(written.is_set())}'.encode() + self.send_response(200) + self.end_headers() + self.wfile.write(data) + return + if self.path == '/_release': + release.set() + self.send_response(200) + self.end_headers() + return + self.forward() + + def do_PUT(self): + self.forward() + + def forward(self): + global held_body + body = self.rfile.read(int(self.headers.get('Content-Length', 0))) + gated = self.command == 'PUT' and self.path.split('?')[0].endswith(sys.argv[1]) + if gated: + held_body = body + waiting.set() + if not release.wait(90): + self.send_error(504) + return + conn = http.client.HTTPConnection('s3', 9000, timeout=20) + try: + conn.request(self.command, self.path, body, dict(self.headers)) + response = conn.getresponse() + data = response.read() + if gated and response.status == 200: + written.set() + self.send_response(response.status) + for name, value in response.getheaders(): + if name.lower() not in ('connection', 'transfer-encoding', 'content-length'): + self.send_header(name, value) + self.send_header('Content-Length', str(len(data))) + self.end_headers() + self.wfile.write(data) + finally: + conn.close() + +http.server.ThreadingHTTPServer(('0.0.0.0', 9000), Proxy).serve_forever() +` + workerCommand(t, "run", "-d", "--name", proxy, "--network", network, + "python:3.13.9-alpine3.22", "python", "-u", "-c", proxyScript, suffix) + control := func(path string) string { + t.Helper() + return workerCommand(t, "exec", proxy, "python", "-c", + "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:9000/"+path+"').read().decode())") + } + return proxy, control +} + +func TestPipelineStaleProcessing(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + jobID := workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") + + // Hold the last v1 PUT while v2 completes, without a DB row lock. + proxy, control := pipelineS3Gate(t, "/v1/optimized") + oldWorker := "pipeline-v1-" + uuid.NewString() + t.Cleanup(func() { workerCommand(t, "rm", "-f", oldWorker) }) + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", oldWorker, + "-e", "WORKER_CONCURRENCY=1", "-e", "JOB_TIMEOUT_SECONDS=120", + "-e", "S3_ENDPOINT=http://"+proxy+":9000", "worker") + workerWait(t, "v1 waiting before optimized PUT", 20*time.Second, func() bool { + return control("_state") == "1:0" + }) + if workerSQL(t, "SELECT pipeline_version||':'||status||':'||attempts FROM attachments WHERE id='"+id+"'") != "1:processing:1" { + t.Fatal("v1 was not processing before upgrade") + } + + workerCommand(t, "compose", "run", "--rm", "--no-deps", "worker", "-upgrade", id) + compose(t, "start", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 30*time.Second) + if len(ready.Variants) != 3 || + workerSQL(t, "SELECT pipeline_version||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:2" { + t.Fatal("v2 did not become ready while v1 was held") + } + content := make(map[string][]byte) + for _, name := range []string{"original", "thumbnail", "crop", "optimized"} { + content[name] = workerContent(t, user, att.ID, name) + } + if !bytes.Equal(content["original"], source) { + t.Fatal("v2 changed original bytes") + } + v1, err := base64.StdEncoding.DecodeString(control("_body")) + if err != nil { + t.Fatal(err) + } + for _, data := range [][]byte{v1, content["optimized"]} { + cfg, err := webp.DecodeConfig(bytes.NewReader(data)) + if err != nil || cfg.Width != 320 || cfg.Height != 200 { + t.Fatal("expected valid optimized WebP from both versions") + } + } + if bytes.Equal(v1, content["optimized"]) { + t.Fatal("fixture must produce different v1 and v2 optimized bytes") + } + + control("_release") + workerWait(t, "late v1 S3 write", 20*time.Second, func() bool { + return control("_state") == "1:1" + }) + workerWait(t, "stale v1 redelivery acknowledged", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + after := waitAttachment(t, user, att.ID, "ready", 5*time.Second) + if !reflect.DeepEqual(ready, after) || + workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") != jobID || + workerSQL(t, "SELECT pipeline_version||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:2" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where+" AND pipeline_version=1") != "0" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where+" AND pipeline_version=2") != "3" { + t.Fatal("late v1 processing changed current metadata") + } + for name, before := range content { + if !bytes.Equal(before, workerContent(t, user, att.ID, name)) { + t.Fatalf("late v1 processing overwrote %s", name) + } + } + t.Logf("PASS attachment=%s: held v1 PUT; v2 ready; late v1 wrote S3 but could not replace v2; stale redelivery acknowledged", id) +} + +func TestPipelineReorderAndDuplicate(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + // Keep v1 durable in outbox, but delay its publication until v2 is ready. + stopService(t, "rabbitmq") + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + jobID := workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") + workerSQL(t, "UPDATE outbox SET available_at=now()+interval '1 hour' WHERE "+where) + if workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND published_at IS NULL") != "1" { + t.Fatal("v1 was published before the reorder injection") + } + workerCommand(t, "compose", "run", "--rm", "--no-deps", "worker", "-upgrade", id) + compose(t, "start", "rabbitmq", "worker") + ready := waitAttachment(t, user, att.ID, "ready", 40*time.Second) + workerWait(t, "v2 acknowledgement", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + if len(ready.Variants) != 3 || + workerSQL(t, "SELECT pipeline_version||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:1" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND pipeline_version=1 AND published_at IS NULL") != "1" { + t.Fatal("v2 did not finish before v1 publication") + } + content := make(map[string][]byte) + for _, name := range []string{"original", "thumbnail", "crop", "optimized"} { + content[name] = workerContent(t, user, att.ID, name) + } + if !bytes.Equal(content["original"], source) { + t.Fatal("v2 changed original bytes") + } + + for _, injection := range []struct { + name, query, version string + }{ + {"reordered v1", "UPDATE outbox SET available_at=now() WHERE " + where + " AND pipeline_version=1", "1"}, + {"duplicate v2", "UPDATE outbox SET published_at=NULL WHERE " + where + " AND pipeline_version=2", "2"}, + } { + compose(t, "stop", "worker") + workerSQL(t, injection.query) + workerWait(t, injection.name+" published", 15*time.Second, func() bool { + return workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+ + " AND pipeline_version="+injection.version+" AND published_at IS NOT NULL") == "1" && + workerQueue(t) == "1:0" + }) + compose(t, "start", "worker") + workerWait(t, injection.name+" acknowledged", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + after := waitAttachment(t, user, att.ID, "ready", 5*time.Second) + if !reflect.DeepEqual(ready, after) || + workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") != jobID || + workerSQL(t, "SELECT pipeline_version||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:1" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where+" AND pipeline_version=1") != "0" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where+" AND pipeline_version=2") != "3" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where) != "2" { + t.Fatalf("%s changed metadata or created extra work", injection.name) + } + for name, before := range content { + if !bytes.Equal(before, workerContent(t, user, att.ID, name)) { + t.Fatalf("%s changed %s bytes", injection.name, name) + } + } + } + t.Logf("PASS attachment=%s: v2 completed before v1 delivery; stale v1 and duplicate v2 acknowledged without changes", id) +} + +func TestPipelineCrashBeforeWrite(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + stopService(t, "worker") + if workerQueue(t) != "0:0" { + t.Fatal("run on an idle stand with an empty attachment queue") + } + att, source := workerUpload(t, user, chat.ID) + id := att.ID.String() + where := "attachment_id='" + id + "'" + jobID := workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") + workerCommand(t, "compose", "run", "--rm", "--no-deps", "worker", "-upgrade", id) + + // Original is the first result PUT. Neither it nor any variant reaches S3. + proxy, control := pipelineS3Gate(t, "/attachments/"+id) + testWorker := "pipeline-crash-" + uuid.NewString() + t.Cleanup(func() { workerCommand(t, "rm", "-f", testWorker) }) + workerCommand(t, "compose", "run", "-d", "--no-deps", "--name", testWorker, + "-e", "WORKER_CONCURRENCY=1", "-e", "JOB_TIMEOUT_SECONDS=15", + "-e", "S3_ENDPOINT=http://"+proxy+":9000", "worker") + workerWait(t, "v2 held before first result PUT", 10*time.Second, func() bool { + return control("_state") == "1:0" + }) + if workerSQL(t, "SELECT pipeline_version||':'||status||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:processing:1" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "0" { + t.Fatal("expected v2 processing without a committed result") + } + workerCommand(t, "kill", "--signal", "SIGKILL", testWorker) + // Kill the held request too: it must never be forwarded after the crash. + workerCommand(t, "kill", "--signal", "SIGKILL", proxy) + workerWait(t, "crashed v2 job returned to broker", 10*time.Second, func() bool { + return workerQueue(t) == "1:0" + }) + compose(t, "start", "worker") + // Recovery must use the natural lease expiry; no status/lease SQL injection. + ready := waitAttachment(t, user, att.ID, "ready", 40*time.Second) + workerWait(t, "recovered v2 acknowledgement", 15*time.Second, func() bool { + return workerQueue(t) == "0:0" + }) + if len(ready.Variants) != 3 || + !bytes.Equal(workerContent(t, user, att.ID, "original"), source) || + workerSQL(t, "SELECT job_id FROM attachments WHERE id='"+id+"'") != jobID || + workerSQL(t, "SELECT pipeline_version||':'||attempts FROM attachments WHERE id='"+id+"'") != "2:2" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where+" AND pipeline_version=2") != "3" || + workerSQL(t, "SELECT count(*) FROM attachment_variants WHERE "+where) != "3" || + workerSQL(t, "SELECT count(*) FROM outbox WHERE "+where+" AND pipeline_version=2 AND attempt=2 AND published_at IS NOT NULL") != "1" { + t.Fatal("crash recovery lost the accepted job or changed its identity or result") + } + for _, name := range []string{"thumbnail", "crop", "optimized"} { + if len(workerContent(t, user, att.ID, name)) == 0 { + t.Fatalf("recovered v2 has empty %s", name) + } + } + t.Logf("PASS attachment=%s: SIGKILL before first result PUT; natural lease recovery; same job ready on v2 attempt2", id) +} diff --git a/student-tests/worker_test.go b/student-tests/worker_test.go index 5e41431d..67a8dfac 100644 --- a/student-tests/worker_test.go +++ b/student-tests/worker_test.go @@ -7,7 +7,6 @@ import ( "context" "encoding/json" "image/jpeg" - "io" "net/http" "os" "os/exec" @@ -24,76 +23,6 @@ import ( "mtusi2026-messenger/internal/dto" ) -func workerCommand(t *testing.T, args ...string) string { - t.Helper() - ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) - defer cancel() - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Dir = ".." - out, err := cmd.Output() - if err != nil { - t.Fatalf("Docker command failed: %v", err) - } - return strings.TrimSpace(string(out)) -} - -func workerSQL(t *testing.T, query string) string { - t.Helper() - return workerCommand(t, "compose", "exec", "-T", "postgres", "psql", - "-U", "messenger", "-d", "messenger", "-Atqc", query) -} - -func workerWait(t *testing.T, description string, timeout time.Duration, condition func() bool) { - t.Helper() - deadline := time.Now().Add(timeout) - for time.Now().Before(deadline) { - if condition() { - return - } - time.Sleep(300 * time.Millisecond) - } - t.Fatalf("timeout waiting for %s", description) -} - -func workerQueue(t *testing.T) string { - t.Helper() - out := workerCommand(t, "compose", "exec", "-T", "rabbitmq", "rabbitmqctl", - "list_queues", "name", "messages_ready", "messages_unacknowledged", "--silent") - for _, line := range strings.Split(out, "\n") { - fields := strings.Fields(line) - if len(fields) == 3 && fields[0] == "attachments.process.v1" { - return fields[1] + ":" + fields[2] - } - } - t.Fatal("attachment queue missing") - return "" -} - -func workerUpload(t *testing.T, user testUser, chatID uuid.UUID) (dto.AttachmentResponse, []byte) { - t.Helper() - source := makePNG(t, 320, 200) - resp := uploadAttachment(t, user, chatID, "worker.png", "image/png", source) - requireStatus(t, resp, http.StatusAccepted) - var att dto.AttachmentResponse - mustDecode(t, resp, &att) - if att.Status != "queued" { - t.Fatalf("expected queued, got %s", att.Status) - } - return att, source -} - -func workerContent(t *testing.T, user testUser, id uuid.UUID, variant string) []byte { - t.Helper() - resp := doRequest(t, http.MethodGet, "/api/v1/attachments/"+id.String()+"/content?variant="+variant, user.Token, nil) - requireStatus(t, resp, http.StatusOK) - defer resp.Body.Close() - data, err := io.ReadAll(resp.Body) - if err != nil { - t.Fatal(err) - } - return data -} - func TestWorkerPersistenceAndDuplicate(t *testing.T) { user := createUser(t) chat := createChat(t, user, user.ID) diff --git a/student.mk b/student.mk index acae1ddd..c36e9a6c 100644 --- a/student.mk +++ b/student.mk @@ -17,7 +17,7 @@ help-go: @echo "load-go: load test" @echo "failure-go: dependency failure tests (stops redis/postgres/s3 containers)" @echo "reconcile: attachment audit; DRY_RUN=false to repair" - @echo "pipeline-go: image pipeline versions (no running services required)" + @echo "pipeline-go: versioned pipeline tests (requires Compose; stops worker)" contract-go: go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL) @@ -49,4 +49,4 @@ worker-go: go test -count=1 -tags=worker ./student-tests/... -v -args -base-url=$(BASE_URL) pipeline-go: - go test -count=1 -tags=nodynamic,pipeline ./student-tests/... -v + go test -count=1 -tags=nodynamic,pipeline ./student-tests/... -v -args -base-url=$(BASE_URL) -- 2.54.0 From 346720166bbb0aff4cbcfb1b202493fcda17f864 Mon Sep 17 00:00:00 2001 From: kk10 Date: Tue, 17 Nov 2026 11:17:07 +0300 Subject: [PATCH 22/23] docs(report): complete lab 5 report --- REPORT.md | 137 +++++++++++++++++++++++++++++++++++---- evidence/contract-go.txt | 68 +++++++++++++++++++ evidence/make-test.txt | 3 + evidence/pipeline-go.txt | 13 ++++ evidence/worker-go.txt | 40 ++++++++++++ 5 files changed, 247 insertions(+), 14 deletions(-) create mode 100644 evidence/contract-go.txt create mode 100644 evidence/make-test.txt create mode 100644 evidence/pipeline-go.txt create mode 100644 evidence/worker-go.txt diff --git a/REPORT.md b/REPORT.md index e98f75e9..2f51f1d0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,146 @@ # Отчёт — лабораторная 5 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Каменски Лин, БПИ2301 +- Целевая оценка; выбранный трек 5, если нужен: 5; трек 2 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: материалы лабораторной; Go 1.27.1, chi v5, pgx v5, sqlc, goose, AWS SDK for Go v2, amqp091-go, imaging, gen2brain/webp, golang.org/x/image, PostgreSQL 18.6, Redis 8.8.3, Nginx 1.31.7, Docker Compose, SeaweedFS 4.51, RabbitMQ 4.2.9; Codex - для анализа реализации и проверок, оформления отчёта ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуются Go 1.26+ и Docker с Compose. Образы: `golang:1.27.1`, `postgres:18.6`, `redis:8.8.3-alpine3.23`, `nginx:1.31.7-alpine3.24`, `chrislusf/seaweedfs:4.51`, `rabbitmq:4.2.9-alpine`. + +Создать локальные секреты - файлы в `secrets/`, в каждый записать значение без лишних символов: + +- `database_url.txt` - URL PostgreSQL для API и worker; +- `cache_url.txt` - URL Redis; +- `postgres_password.txt` - пароль пользователя PostgreSQL `messenger`; +- `test_database_url.txt` - URL БД для тестов с хоста; +- `s3_access_key_id.txt` - S3 access key ID для API и worker; +- `s3_secret_access_key.txt` - S3 secret access key для API и worker; +- `s3_bootstrap_access_key_id.txt` - bootstrap access key ID; +- `s3_bootstrap_secret_access_key.txt` - bootstrap secret access key; +- `broker_url.txt` - AMQP URL для API и worker; +- `broker_password.txt` - пароль пользователя RabbitMQ `messenger`. + +Пример (значения заменить своими): + +```bash +mkdir -p secrets +printf '%s' 'CHANGE_ME' > secrets/postgres_password.txt +printf '%s' 'postgres://messenger:CHANGE_ME@postgres:5432/messenger?sslmode=disable' > secrets/database_url.txt +printf '%s' 'redis://redis:6379/0' > secrets/cache_url.txt +``` + +Скопировать шаблон переменных окружения: + +```bash +cp .env.example .env +``` + +Сборка и запуск: + +```bash +docker compose up --build -d +``` + +Готовность API проверяется запросом к `/health/ready`; после этого API доступен на http://localhost:8080. + +Сваггер доступен на http://localhost:8080/swagger/. + +Безопасная остановка (данные PostgreSQL, S3 и RabbitMQ в volumes сохраняются): +```bash +docker compose down +``` + +Намеренное удаление учебных данных: +```bash +docker compose down -v +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +**Процессы/хранилища:** клиент → nginx → `api` × `API_REPLICAS` (по умолчанию 2) → staging в SeaweedFS S3 + PostgreSQL → outbox publisher → RabbitMQ → `worker` → оригинал и варианты в S3 + результат в PostgreSQL. Redis используется как кэш сессий с fallback в PostgreSQL. Единственная публичная точка входа API - `127.0.0.1:8080`. + +**Источник истины** - PostgreSQL: метаданные вложений, состояния заданий, попытки, lease (срок захвата задания обработчиком), версии pipeline и outbox. Байты оригиналов и вариантов хранятся в приватном S3 bucket `messenger-attachments`. Сообщения брокера содержат ID и служебные поля, без байтов изображений и credentials. + +**Что перенесено из lab4:** Go-приложение и PostgreSQL, аутентификация, сессии, чаты, сообщения, идемпотентность и `X-Instance-Id`, Redis-кэш сессий, S3-хранилище (SeaweedFS), API вложений и `attachment_ids` в сообщениях, reconciler, `compose.yaml`, `deploy/nginx.conf`, `Dockerfile`, `Dockerfile.migrate`, `Dockerfile.s3config`, `Dockerfile.reconcile`, `scripts/restart.sh`, `scripts/stop-one.sh`, `student-tests`, `student.mk`, `Makefile`, `web/swagger`, `contracts`. + +**Что изменено в lab5:** upload возвращает `202 queued` после сохранения оригинала в staging и транзакции с метаданными и outbox; добавлены RabbitMQ и отдельный worker, состояния `processing`/`ready`/`failed`, thumbnail JPEG, crop JPEG и optimized WebP; миграция pipeline с таблицами вариантов, outbox и audit replay; ограниченные повторы, lease recovery, команды просмотра failed, replay и upgrade версии pipeline. Обработка изображений выполняется в worker, API проверяет загружаемый файл и сохраняет источник. + +**Транзакционные границы.** API сначала сохраняет проверенный оригинал в staging, затем в одной транзакции PostgreSQL создаёт вложение `queued` и запись outbox. Ответ `202` возвращается после COMMIT. Worker записывает оригинал и все варианты в S3, затем под блокировкой строки проверяет job ID, версию, попытку и срок захвата задания. Метаданные вариантов и переход в `ready` фиксируются одной транзакцией. Общей транзакции S3 и PostgreSQL нет: сбой между операциями может оставить объекты без опубликованного результата. + +**Брокер и подтверждения.** RabbitMQ хранит durable очередь `attachments.process.v1`, сообщения публикуются как persistent. Publisher в API читает outbox и отмечает публикацию только после publisher confirm - подтверждения приёма брокером. При сбое запись остаётся для повторной публикации. Consumer ack подтверждает обработку: worker отправляет его после устойчивой фиксации результата, повтора или `failed`. Доставка at least once допускает дубли; повтор готового задания проверяет размеры и SHA-256 объектов и не создаёт новые варианты. + +**Обработка изображений.** Оригинал сохраняется без изменения байтов. Thumbnail - JPEG с качеством 85, до 256×256 с сохранением пропорций, без увеличения; crop - JPEG с качеством 85, центральная обрезка 128×128 с допустимым увеличением. Optimized - WebP, до 1280×1280 с сохранением пропорций, без увеличения, Method 4, качество 80 для v1 и 75 для v2. Перед обработкой применяется EXIF orientation; EXIF/XMP/ICC в варианты не переносятся. Прозрачность в JPEG заменяется белым фоном, в WebP сохраняется. + +**Ограничения обработки.** Размер загрузки - до 10 MiB, число пикселей - до 40 млн. Worker проверяет размер и SHA-256 источника, размеры изображения проверяются до полного декодирования. По умолчанию работают 2 consumer с prefetch 1, одновременно декодируется одно изображение. Декодирование, resize и кодирование выполняются в дочернем процессе, который завершается при истечении таймаута задания (по умолчанию 60 с). Лимиты контейнера worker - 1 CPU и 1 GiB RAM, общие для основного и дочернего процессов; отдельного лимита памяти дочернего процесса нет. + +**Повторы и восстановление.** По умолчанию допускается 5 попыток. Для временных ошибок используется экспоненциальная задержка со случайным разбросом (backoff с jitter): 1-2 с, 2-4 с и далее до 32-64 с. Повреждённый или отсутствующий источник переводит задание в `failed` с `invalid_source`, исчерпание попыток - с `retry_exhausted`. Возврат в `queued` и outbox следующей попытки фиксируются одной транзакцией. Если worker завершился во время обработки, после истечения срока захвата задания фоновая проверка возвращает его на повтор либо фиксирует `failed`, если попытки закончились. + +**Реестр failed и replay.** Неуспешные задания хранятся в PostgreSQL и доступны через `worker -list-failed`. Явный replay разрешён только для `failed` с сохранённым staging и без записанных вариантов. Перед повтором проверяются размер и SHA-256 источника; переход в `queued`, новый бюджет попыток, запись оператора и причины в audit и outbox фиксируются одной транзакцией. Job ID и версия сохраняются. Готовое задание повторно запустить через replay нельзя. + +**Очистка staging.** Worker удаляет источник из staging после COMMIT состояния `ready`; ошибка удаления логируется и не отменяет готовый результат. Остатки staging для `ready`/`failed` и объекты без строки БД удаляет явный запуск reconciler, по умолчанию после 24 часов. Для связанных объектов срок считается от `updated_at`, для объектов без строки - от времени изменения в S3. Источники `queued`/`processing` сохраняются независимо от возраста. Периодической очистки staging нет; после удаления источника replay недоступен. + +**Версии pipeline.** Новые загрузки используют v1. Команда `worker -upgrade UUID` переводит незавершённое вложение v1 (`queued`/`processing` с staging) на v2, сохраняя attachment ID, job ID и исходные байты. Смена версии и outbox фиксируются одной транзакцией. Варианты хранятся по ключам `variants//v/`, уникальность в БД - `(attachment_id, pipeline_version, variant)`. Проверка версии, попытки и срока захвата не позволяет старому worker опубликовать результат вместо нового. Upgrade готового или failed-вложения не поддерживается; остаточные S3-объекты старой версии автоматически не очищаются. + +**Переменные `.env.example`:** `APP_HOST`, `APP_PORT` - адрес и порт API; `MAX_INFLIGHT_REQUESTS` - ограничитель одновременных запросов (0 - выключен); `SESSION_TTL_SECONDS` - срок жизни сессии; `LOG_LEVEL` - уровень логов; `DATABASE_URL_FILE`, `CACHE_URL_FILE` - пути к secrets с URL PostgreSQL и Redis; `SESSION_STORE` - режим хранения сессий (`postgres` или `redis`); `API_REPLICAS` - число реплик API; `IDEMPOTENCY_TTL_SECONDS` - срок хранения ключей идемпотентности; `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET` - настройки S3; `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE`, `S3_BOOTSTRAP_ACCESS_KEY_ID_FILE`, `S3_BOOTSTRAP_SECRET_ACCESS_KEY_FILE` - пути к S3 secrets; `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` - лимиты загрузки; `BROKER_URL_FILE` - путь к secret с AMQP URL; `BROKER_PASSWORD_FILE` - путь к secret с паролем RabbitMQ; `WORKER_CONCURRENCY` - число consumer; `JOB_MAX_ATTEMPTS` - лимит попыток; `JOB_TIMEOUT_SECONDS` - таймаут задания и срок его захвата; `STAGING_RETENTION_SECONDS` - срок хранения остатков staging перед очисткой reconciler. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | `PASS` | `evidence/make-test.txt` | +| Уровень 3 | +| JPEG, MIME, целостность, лимиты размера и пикселей, безопасный filename, проверка доступа к вложениям | `make contract-go` | `PASS` | `evidence/contract-go.txt` | +| Сохранность задания после перезапуска API и broker; queued → ready; неизменный оригинал и JPEG thumbnail; отсутствие дублей вариантов при повторной доставке | `make worker-go`: `TestWorkerPersistenceAndDuplicate` | `PASS` | `evidence/worker-go.txt` | +| Ограниченный retry, failed и безопасный error_code | `make worker-go`: `TestWorkerRetryExhausted` | `PASS` | `evidence/worker-go.txt` | +| Уровень 4 | +| Размеры thumbnail, сохранение пропорций, отсутствие увеличения, белый фон вместо прозрачности | `make contract-go`: `TestThumbnail` | `PASS` | `evidence/contract-go.txt` | +| Центральная обрезка crop 128×128, включая маленькие изображения | `make contract-go`: `TestCrop` | `PASS` | `evidence/contract-go.txt` | +| Optimized WebP, ограничение размеров, сохранение пропорций и прозрачности | `make contract-go`: `TestOptimized` | `PASS` | `evidence/contract-go.txt` | +| Применение EXIF orientation и удаление EXIF из вариантов | `make contract-go`: `TestVariantsEXIF` | `PASS` | `evidence/contract-go.txt` | +| Ограничение времени обработки, завершение дочернего процесса, работоспособность worker после таймаута | `make worker-go`: `TestWorkerProcessingTimeout` | `PASS` | `evidence/worker-go.txt` | +| Восстановление задания после COMMIT и падения API до публикации в broker | `make worker-go`: `TestWorkerOutboxRecovery` | `PASS` | `evidence/worker-go.txt` | +| Реестр failed, явный replay с audit, отказ повтора без источника и повторного replay готового задания | `make worker-go`: `TestWorkerReplay` | `PASS` | `evidence/worker-go.txt` | +| Падение worker после записи объектов до COMMIT/ack, восстановление после истечения срока захвата задания | `make worker-go`: `TestWorkerLeaseRecovery` | `PASS` | `evidence/worker-go.txt` | +| Уровень 5, трек 2 | +| Позднее завершение v1 после готовности v2 не меняет текущий результат | `make pipeline-go`: `TestPipelineStaleProcessing` | `PASS` | `evidence/pipeline-go.txt` | +| Обратный порядок доставки v2/v1 и дубль v2 не меняют результат и не создают новые варианты | `make pipeline-go`: `TestPipelineReorderAndDuplicate` | `PASS` | `evidence/pipeline-go.txt` | +| Падение до первой записи результата в S3, восстановление того же задания после истечения срока захвата | `make pipeline-go`: `TestPipelineCrashBeforeWrite` | `PASS` | `evidence/pipeline-go.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Трек 2: доказанная идемпотентность pipeline + +**Гипотеза:** повторная доставка и изменение порядка заданий не меняют готовый результат. Старый worker не может заменить результат новой версии своим. После падения API или worker принятое задание восстанавливается и доходит до ready без повторной загрузки файла. + +Инварианты: attachment ID, job ID и байты оригинала сохраняются; после готовности v2 старые задания и дубли не меняют метаданные и байты текущих вариантов; в БД остаётся один набор из трёх вариантов текущей версии; после падения до или после записи объектов то же задание доходит до ready. + +Методика: `make pipeline-go` выполняет три последовательных сценария на свободном стенде с пустой очередью. Каждый создаёт через API синтетическое PNG 320×200 и переводит вложение на v2 штатной командой upgrade. Временный S3-прокси задерживает запись объекта в S3 для проверки позднего завершения v1 и падения до первой записи результата. Для перестановки доставки тест откладывает публикацию v1 через `available_at` в outbox, затем повторно публикует v2 сбросом `published_at`. Проверяются API, байты объектов, строки БД и освобождение очереди после ack. Падение после записи объектов проверяет `TestWorkerLeaseRecovery` из `make worker-go`: INSERT вариантов блокируется, worker завершается через SIGKILL до COMMIT/ack, затем ожидается естественное истечение срока захвата задания. + +Стенд и лимиты описаны выше. Обычный worker использует 2 consumer с prefetch 1; временные worker в pipeline-тестах - 1 consumer, таймаут 120 с для задержанной v1 и 15 с для падения до записи. В тесте падения после записи таймаут также 15 с. Приведён один сохранённый прогон каждого сценария, без нагрузочного профиля и отдельного прогрева; RPS, перцентили задержек и фактическое потребление CPU/RAM не измерялись. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Задержка записи optimized WebP версии v1 в S3 до готовности v2 | Старый worker не заменит результат v2 | v2 осталась ready, метаданные и байты не изменились; 0 строк вариантов v1 и 3 строки v2; старое задание подтверждено | Не измерялось / потери нет | +| Доставка v1 после v2, затем повтор v2 | Порядок и дубли не повлияют на готовый результат | Job ID, версия, попытка, метаданные и все 4 объекта не изменились; новых строк вариантов и outbox нет | Не измерялось / потери нет | +| SIGKILL worker до записи первого объекта результата в S3 | То же задание завершится после восстановления | После истечения срока захвата получен ready v2 на попытке 2, сохранены job ID и оригинал, доступны 3 варианта | Не измерялось / потери нет | +| SIGKILL worker после записи объектов в S3 до COMMIT/ack | Повтор завершит то же задание без дублей | После истечения срока захвата получен ready на попытке 2, сохранены job ID и оригинал, в БД 3 варианта | Не измерялось / потери нет | +| SIGKILL API после COMMIT до публикации в broker | Outbox восстановит публикацию без создания нового задания | То же задание автоматически опубликовано и завершено на попытке 1, оригинал сохранён, доступны 3 варианта | Не измерялось / потери нет | + +Результаты: все сценарии прошли. Длительности pipeline-тестов - 12,67 / 41,43 / 26,05 с, всего 80,150 с (`evidence/pipeline-go.txt`). Длительности теста падения после записи объектов в S3 - 26,54 с, восстановления outbox - 33,15 с (`evidence/worker-go.txt`). Это полное время тестов с подготовкой и очисткой, время восстановления отдельно не измерялось. + +**Вывод:** гипотеза подтверждена в проверенных сценариях. Принятые задания завершились после восстановления, дубли и старая версия не изменили текущий результат. Доставка остаётся at least once: падение после публикации до фиксации outbox или после COMMIT результата до ack допускает повторную доставку. Идемпотентность результата не означает exactly-once доставку или общую транзакцию S3 и PostgreSQL. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Nginx, PostgreSQL и SeaweedFS работают в одном экземпляре на одном хосте. Реплики API не защищают от отказа этих компонентов или самого хоста. +- Если удалить сессию из Redis не удалось, logout возвращает `503 unavailable`: сессия уже удалена из PostgreSQL, но старый токен может приниматься из кэша до 60 с. Несмотря на `503`, может потребоваться повторный вход. Пока Redis недоступен, получить `204` нельзя, хотя сессия в БД уже удалена; после восстановления повторный logout вернёт `401`. +- Полное декодирование требует памяти под распакованное изображение. Для ограничения расхода RAM на каждой API-реплике работает один декодер, поэтому параллельные загрузки ожидают своей очереди. +- Общей транзакции PostgreSQL и S3 нет: расхождения исправляются последующей сверкой. Reconciler отмечает отсутствие оригинала, но не восстанавливает байты. Сохранность volumes не заменяет резервные копии хранилищ. +- Reconciler загружает списки объектов и метаданных целиком в память, поэтому расход памяти растёт с объёмом хранилища. +- RabbitMQ также работает в одном экземпляре. Проверены перезапуск API и broker с сохранением volumes, падение worker до и после записи объектов, повторная доставка и устаревшая версия задания. Потеря volumes, отказ хоста и одновременные отказы нескольких хранилищ не проверялись. +- При удалении staging сбой COMMIT после удаления объекта может оставить старый ключ в БД. Reconciler не сверяет варианты изображений; остатки объектов старой версии автоматически не удаляются. +- Replay доступен только для failed с сохранённым staging и без записанных вариантов. Upgrade поддерживает только незавершённую v1; повторная обработка готовых вложений не реализована. +- Очистка остатков staging требует явного запуска reconciler. Источники queued/processing защищены от удаления независимо от возраста. +- Память ограничена на уровне контейнера worker, отдельного лимита дочернего процесса нет. Поведение при исчерпании памяти и длительной перегрузке не исследовалось. Проверки идемпотентности выполнены на небольших PNG 320×200, без измерения пропускной способности и времени восстановления. diff --git a/evidence/contract-go.txt b/evidence/contract-go.txt new file mode 100644 index 00000000..eb64400b --- /dev/null +++ b/evidence/contract-go.txt @@ -0,0 +1,68 @@ +> make contract-go +go test -tags=contract ./student-tests/... -v -args -base-url=http://localhost:8080 +=== RUN TestAttachmentJPEG +--- PASS: TestAttachmentJPEG (0.42s) +=== RUN TestAttachmentTooManyPixels +--- PASS: TestAttachmentTooManyPixels (2.12s) +=== RUN TestAttachmentUnsafeFilename +--- PASS: TestAttachmentUnsafeFilename (0.14s) +=== RUN TestAttachmentTooLarge +--- PASS: TestAttachmentTooLarge (0.22s) +=== RUN TestAttachmentCorruptedImage +--- PASS: TestAttachmentCorruptedImage (0.22s) +=== RUN TestAttachmentMimeSubstitution +--- PASS: TestAttachmentMimeSubstitution (0.16s) +=== RUN TestAttachmentForeignID +--- PASS: TestAttachmentForeignID (0.22s) +=== RUN TestAttachmentFromAnotherChat +--- PASS: TestAttachmentFromAnotherChat (1.02s) +=== RUN TestCreateChatRollback +--- PASS: TestCreateChatRollback (0.16s) +=== RUN TestInvalidJSON +--- PASS: TestInvalidJSON (0.00s) +=== RUN TestForeignChat +--- PASS: TestForeignChat (0.60s) +=== RUN TestEmptyMessage +--- PASS: TestEmptyMessage (0.20s) +=== RUN TestDuplicateUsername +--- PASS: TestDuplicateUsername (0.24s) +=== RUN TestPagination +--- PASS: TestPagination (0.31s) +=== RUN TestThumbnail +=== RUN TestThumbnail/landscape +=== RUN TestThumbnail/portrait +=== RUN TestThumbnail/small +=== RUN TestThumbnail/thin +--- PASS: TestThumbnail (2.18s) + --- PASS: TestThumbnail/landscape (0.35s) + --- PASS: TestThumbnail/portrait (0.62s) + --- PASS: TestThumbnail/small (0.40s) + --- PASS: TestThumbnail/thin (0.82s) +=== RUN TestVariantsEXIF +=== RUN TestVariantsEXIF/thumbnail +=== RUN TestVariantsEXIF/optimized +--- PASS: TestVariantsEXIF (1.19s) + --- PASS: TestVariantsEXIF/thumbnail (0.80s) + --- PASS: TestVariantsEXIF/optimized (0.39s) +=== RUN TestCrop +=== RUN TestCrop/landscape +=== RUN TestCrop/portrait +=== RUN TestCrop/small +--- PASS: TestCrop (1.61s) + --- PASS: TestCrop/landscape (0.62s) + --- PASS: TestCrop/portrait (0.39s) + --- PASS: TestCrop/small (0.60s) +=== RUN TestOptimized +=== RUN TestOptimized/landscape +=== RUN TestOptimized/portrait +=== RUN TestOptimized/small +--- PASS: TestOptimized (2.50s) + --- PASS: TestOptimized/landscape (0.84s) + --- PASS: TestOptimized/portrait (1.06s) + --- PASS: TestOptimized/small (0.59s) +=== RUN TestLoginWrongPassword +--- PASS: TestLoginWrongPassword (0.22s) +=== RUN TestLogout +--- PASS: TestLogout (0.18s) +PASS +ok mtusi2026-messenger/student-tests 13.930s \ No newline at end of file diff --git a/evidence/make-test.txt b/evidence/make-test.txt new file mode 100644 index 00000000..5f2fb7f0 --- /dev/null +++ b/evidence/make-test.txt @@ -0,0 +1,3 @@ +> make test +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab5 public API scenario; infrastructure and grading evidence remain separate. \ No newline at end of file diff --git a/evidence/pipeline-go.txt b/evidence/pipeline-go.txt new file mode 100644 index 00000000..c233a1d3 --- /dev/null +++ b/evidence/pipeline-go.txt @@ -0,0 +1,13 @@ +> make pipeline-go +go test -count=1 -tags=nodynamic,pipeline ./student-tests/... -v -args -base-url=http://localhost:8080 +=== RUN TestPipelineStaleProcessing + pipeline_fault_test.go:174: PASS attachment=01a1e881-531b-7c12-8bcc-1bb759d11d06: held v1 PUT; v2 ready; late v1 wrote S3 but could not replace v2; stale redelivery acknowledged +--- PASS: TestPipelineStaleProcessing (12.67s) +=== RUN TestPipelineReorderAndDuplicate + pipeline_fault_test.go:245: PASS attachment=01a1e881-8af0-70c3-a95d-6fde917efa7f: v2 completed before v1 delivery; stale v1 and duplicate v2 acknowledged without changes +--- PASS: TestPipelineReorderAndDuplicate (41.43s) +=== RUN TestPipelineCrashBeforeWrite + pipeline_fault_test.go:301: PASS attachment=01a1e882-22d9-749f-ad66-36ecf038165b: SIGKILL before first result PUT; natural lease recovery; same job ready on v2 attempt2 +--- PASS: TestPipelineCrashBeforeWrite (26.05s) +PASS +ok mtusi2026-messenger/student-tests 80.150s \ No newline at end of file diff --git a/evidence/worker-go.txt b/evidence/worker-go.txt new file mode 100644 index 00000000..d9f11a35 --- /dev/null +++ b/evidence/worker-go.txt @@ -0,0 +1,40 @@ +> docker compose ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab5-api-1 mtusi-messenger:lab5 "/app/server" api 35 minutes ago Up 35 minutes (healthy) 8080/tcp +mtusi2026lab5-api-2 mtusi-messenger:lab5 "/app/server" api 35 minutes ago Up 35 minutes (healthy) 8080/tcp +mtusi2026lab5-load_balancer-1 nginx:1.31.7-alpine3.24 "/docker-entrypoint.…" load_balancer 35 minutes ago Up 35 minutes 127.0.0.1:8080->8080/tcp +mtusi2026lab5-postgres-1 postgres:18.6 "docker-entrypoint.s…" postgres 35 minutes ago Up 35 minutes (healthy) 127.0.0.1:5432->5432/tcp +mtusi2026lab5-rabbitmq-1 rabbitmq:4.2.9-alpine "/bin/sh -ec 'RABBIT…" rabbitmq 35 minutes ago Up 35 minutes (healthy) 4369/tcp, 5671-5672/tcp, 15691-15692/tcp, 25672/tcp +mtusi2026lab5-redis-1 redis:8.8.3-alpine3.23 "docker-entrypoint.s…" redis 35 minutes ago Up 35 minutes (healthy) 6379/tcp +mtusi2026lab5-s3-1 chrislusf/seaweedfs:4.51 "/entrypoint.sh serv…" s3 35 minutes ago Up 35 minutes (healthy) 7333/tcp, 8080/tcp, 8333/tcp, 8888/tcp, 9333/tcp, 18080/tcp, 18888/tcp, 19333/tcp +mtusi2026lab5-worker-1 mtusi-messenger-worker:lab5 "/app/worker" worker 35 minutes ago Up 35 minutes +> make worker-go +go test -count=1 -tags=worker ./student-tests/... -v -args -base-url=http://localhost:8080 +=== RUN TestWorkerPersistenceAndDuplicate + worker_test.go:116: PASS attachment=01a1e86c-a8f6-7816-82aa-f21d58b7d859: queued survives API/broker restart; ready; duplicate acknowledged with unchanged result +--- PASS: TestWorkerPersistenceAndDuplicate (33.88s) +=== RUN TestWorkerRetryExhausted + worker_test.go:161: PASS attachment=01a1e86d-245d-78aa-b370-288b7b9aae01: 5 attempts, failed/retry_exhausted, content/link rejected +--- PASS: TestWorkerRetryExhausted (39.01s) +=== RUN TestWorkerProcessingTimeout +--- PASS: TestWorkerProcessingTimeout (10.11s) +=== RUN TestWorkerReplay +--- PASS: TestWorkerReplay (15.20s) +=== RUN TestWorkerOutboxRecovery + worker_test.go:342: PASS attachment=01a1e86e-2d67-70db-98e7-ea3f137bb7c1: commit, API SIGKILL before publication, automatic outbox recovery, same job ready +--- PASS: TestWorkerOutboxRecovery (33.15s) +=== RUN TestWorkerLeaseRecovery + worker_test.go:425: PASS attachment=01a1e86e-b2b4-7d23-a1cb-0ba40351a02f: SIGKILL after S3 writes, expired lease recovered, same job ready on attempt 2 +--- PASS: TestWorkerLeaseRecovery (26.54s) +PASS +ok mtusi2026-messenger/student-tests 157.912s +> docker compose ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab5-api-1 mtusi-messenger:lab5 "/app/server" api 38 minutes ago Up About a minute (healthy) 8080/tcp +mtusi2026lab5-api-2 mtusi-messenger:lab5 "/app/server" api 38 minutes ago Up About a minute (healthy) 8080/tcp +mtusi2026lab5-load_balancer-1 nginx:1.31.7-alpine3.24 "/docker-entrypoint.…" load_balancer 38 minutes ago Up 38 minutes 127.0.0.1:8080->8080/tcp +mtusi2026lab5-postgres-1 postgres:18.6 "docker-entrypoint.s…" postgres 39 minutes ago Up 38 minutes (healthy) 127.0.0.1:5432->5432/tcp +mtusi2026lab5-rabbitmq-1 rabbitmq:4.2.9-alpine "/bin/sh -ec 'RABBIT…" rabbitmq 2 minutes ago Up About a minute (healthy) 4369/tcp, 5671-5672/tcp, 15691-15692/tcp, 25672/tcp +mtusi2026lab5-redis-1 redis:8.8.3-alpine3.23 "docker-entrypoint.s…" redis 39 minutes ago Up 38 minutes (healthy) 6379/tcp +mtusi2026lab5-s3-1 chrislusf/seaweedfs:4.51 "/entrypoint.sh serv…" s3 38 minutes ago Up 38 minutes (healthy) 7333/tcp, 8080/tcp, 8333/tcp, 8888/tcp, 9333/tcp, 18080/tcp, 18888/tcp, 19333/tcp +mtusi2026lab5-worker-1 mtusi-messenger-worker:lab5 "/app/worker" worker 38 minutes ago Up 41 seconds \ No newline at end of file -- 2.54.0 From c872d95208e57db12e146c8b846a5835decf713d Mon Sep 17 00:00:00 2001 From: kk10 Date: Tue, 17 Nov 2026 11:27:58 +0300 Subject: [PATCH 23/23] docs(report): add pull request link --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 2f51f1d0..c65237bc 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Каменски Лин, БПИ2301 - Целевая оценка; выбранный трек 5, если нужен: 5; трек 2 -- Commit/PR: TODO после публикации +- Commit/PR: [Pull Request 83](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab5/pulls/83) - Использованные источники, библиотеки и помощь ИИ: материалы лабораторной; Go 1.27.1, chi v5, pgx v5, sqlc, goose, AWS SDK for Go v2, amqp091-go, imaging, gen2brain/webp, golang.org/x/image, PostgreSQL 18.6, Redis 8.8.3, Nginx 1.31.7, Docker Compose, SeaweedFS 4.51, RabbitMQ 4.2.9; Codex - для анализа реализации и проверок, оформления отчёта ## Запуск из чистого clone -- 2.54.0