From 0a361367c7b31de619c8db20c34f93c7f309ff03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D1=8F=20=D0=9C=D0=BE=D1=80=D0=BE=D0=B7?= <145702378+MiniLynx13@users.noreply.github.com> Date: Mon, 16 Nov 2026 11:46:03 +0300 Subject: [PATCH 1/3] feat:lab4-catchup --- Dockerfile | 31 ++ cmd/messenger/main.go | 107 +++++ compose.yaml | 130 ++++++ go.mod | 30 ++ go.sum | 62 +++ infra/minio/bootstrap.sh | 52 +++ infra/nginx/nginx.conf | 29 ++ migrations/0001_init.sql | 31 ++ migrations/0002_sessions.sql | 9 + migrations/0003_messages_alt_index.sql | 5 + migrations/0004_idempotency.sql | 14 + migrations/0005_attachments.sql | 30 ++ scripts/migrate.sh | 13 + scripts/restart.sh | 26 ++ scripts/restore-api.sh | 36 ++ scripts/stop-one.sh | 20 + src/api/auth.go | 79 ++++ src/api/errors.go | 28 ++ src/api/handlers.go | 537 ++++++++++++++++++++++ src/api/middleware.go | 46 ++ src/api/router.go | 24 + src/config/config.go | 136 ++++++ src/domain/attachments.go | 189 ++++++++ src/domain/cache.go | 91 ++++ src/domain/idempotency.go | 75 +++ src/domain/models.go | 92 ++++ src/domain/postgres.go | 608 +++++++++++++++++++++++++ src/domain/s3.go | 213 +++++++++ src/domain/sessions.go | 108 +++++ 29 files changed, 2851 insertions(+) create mode 100644 Dockerfile create mode 100644 cmd/messenger/main.go create mode 100644 compose.yaml create mode 100644 go.mod create mode 100644 go.sum create mode 100644 infra/minio/bootstrap.sh create mode 100644 infra/nginx/nginx.conf create mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_sessions.sql create mode 100644 migrations/0003_messages_alt_index.sql create mode 100644 migrations/0004_idempotency.sql create mode 100644 migrations/0005_attachments.sql create mode 100644 scripts/migrate.sh create mode 100644 scripts/restart.sh create mode 100644 scripts/restore-api.sh create mode 100644 scripts/stop-one.sh create mode 100644 src/api/auth.go create mode 100644 src/api/errors.go create mode 100644 src/api/handlers.go create mode 100644 src/api/middleware.go create mode 100644 src/api/router.go create mode 100644 src/config/config.go create mode 100644 src/domain/attachments.go create mode 100644 src/domain/cache.go create mode 100644 src/domain/idempotency.go create mode 100644 src/domain/models.go create mode 100644 src/domain/postgres.go create mode 100644 src/domain/s3.go create mode 100644 src/domain/sessions.go diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..040241e0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,31 @@ +# --- build stage --- +FROM golang:1.22-alpine AS build + +WORKDIR /src +RUN apk add --no-cache ca-certificates + +COPY go.mod go.sum ./ +RUN go mod download + +COPY cmd ./cmd +COPY src ./src +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/messenger + +# --- runtime stage --- +FROM alpine:3.20 +RUN apk add --no-cache ca-certificates postgresql-client && \ + addgroup -S app && adduser -S -G app app +WORKDIR /app + +COPY --from=build /out/messenger /app/messenger +COPY migrations /app/migrations +COPY scripts/migrate.sh /app/migrate.sh +RUN chmod +x /app/migrate.sh + +USER app +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=5 \ + CMD wget -qO- http://127.0.0.1:8080/health/ready >/dev/null || exit 1 + +ENTRYPOINT ["/app/messenger"] \ No newline at end of file diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go new file mode 100644 index 00000000..0f0cdce1 --- /dev/null +++ b/cmd/messenger/main.go @@ -0,0 +1,107 @@ +package main + +import ( + "context" + "errors" + "fmt" + "log" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "mtusi-messenger/src/api" + "mtusi-messenger/src/config" + "mtusi-messenger/src/domain" +) + +func main() { + cfg := config.Load() + if cfg.DatabaseURL == "" { + log.Fatal("DATABASE_URL is required (env DATABASE_URL or DATABASE_URL_FILE)") + } + + rootCtx, cancelRoot := context.WithCancel(context.Background()) + defer cancelRoot() + + store, err := domain.NewStore(rootCtx, cfg.DatabaseURL) + if err != nil { + log.Fatalf("postgres: %v", err) + } + defer store.Close() + + var s3store *domain.S3Store + if cfg.S3Endpoint != "" { + s3store, err = domain.NewS3Store(rootCtx, cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, + cfg.S3AccessKeyID, cfg.S3SecretKey, cfg.MaxUploadBytes, cfg.MaxImagePixels) + if err != nil { + log.Fatalf("s3: %v", err) + } + } else { + log.Fatal("S3_ENDPOINT is required for lab4") + } + + // Кэш сессий в Redis/Valkey. Если CACHE_URL не задан — работаем без кэша. + var cache *domain.SessionCache + if cfg.CacheURL != "" { + cache, err = domain.NewSessionCache(rootCtx, cfg.CacheURL) + if err != nil { + if cfg.RedisRequired { + log.Fatalf("redis required but unavailable: %v", err) + } + log.Printf("redis unavailable, continuing without session cache: %v", err) + cache = nil + } else { + defer cache.Close() + } + } else if cfg.RedisRequired { + log.Fatal("SESSION_STORE=redis but CACHE_URL is not configured") + } + + sessions := domain.NewSessionStore(store, cache, cfg.SessionTTL) + handler := &api.Handler{Store: store, Sessions: sessions, S3: s3store, MaxUpload: cfg.MaxUploadBytes} + router := api.NewRouter(handler, cfg.InstanceID) + + go func() { + ticker := time.NewTicker(2 * time.Minute) + defer ticker.Stop() + for { + select { + case <-rootCtx.Done(): + return + case <-ticker.C: + if err := store.ReconcileOrphans(rootCtx, s3store, cfg.S3GCGrace); err != nil { + log.Printf("reconcile: %v", err) + } + } + } + }() + + srv := &http.Server{ + Addr: fmt.Sprintf("%s:%d", cfg.Host, cfg.Port), + Handler: router, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + stop := make(chan os.Signal, 1) + signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) + + go func() { + log.Printf("messenger listening on %s (env=%s, session_ttl=%s)", srv.Addr, cfg.Env, cfg.SessionTTL) + log.Printf("instance_id=%s", cfg.InstanceID) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Fatalf("server error: %v", err) + } + }() + + <-stop + log.Println("shutting down...") + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + _ = srv.Shutdown(ctx) + log.Println("stopped") +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..eb616c89 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,130 @@ +x-api: &api + build: + context: . + dockerfile: Dockerfile + env_file: + - .env + secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key] + depends_on: + postgres: { condition: service_healthy } + redis: { condition: service_healthy } + s3: { condition: service_healthy } + s3-init: { condition: service_completed_successfully } + networks: [backend] + +services: + postgres: + image: postgres:16.3-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + secrets: [postgres_password] + volumes: [pgdata:/var/lib/postgresql/data] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + networks: [backend] + deploy: + resources: + limits: { cpus: "${PG_CPUS:-1.0}", memory: "${PG_MEM:-512M}" } + + redis: + image: redis:7.2.5-alpine + command: ["redis-server", "--appendonly", "yes", "--save"] + volumes: [redisdata:/data] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + networks: [backend] + + s3: + image: pgsty/silo:RELEASE.2026-10-26T00-00-00Z + command: ["server", "/data", "--console-address", ":9001"] + environment: + MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user + MINIO_ROOT_PASSWORD_FILE: /run/secrets/minio_root_password + secrets: [minio_root_user, minio_root_password] + volumes: [s3data:/data] + healthcheck: + test: ["CMD", "mc", "ready", "local"] + interval: 5s + timeout: 3s + retries: 20 + networks: [backend] + deploy: + resources: + limits: { cpus: "${S3_CPUS:-1.0}", memory: "${S3_MEM:-512M}" } + + s3-init: + image: pgsty/silo:RELEASE.2026-10-26T00-00-00Z + depends_on: + s3: { condition: service_healthy } + environment: + MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user + MINIO_ROOT_PASSWORD_FILE: /run/secrets/minio_root_password + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key + entrypoint: ["/bin/sh", "/bootstrap/bootstrap.sh"] + secrets: + - minio_root_user + - minio_root_password + - s3_access_key_id + - s3_secret_access_key + volumes: + - ./infra/minio/bootstrap.sh:/bootstrap/bootstrap.sh:ro + - /tmp/silo-init-data:/data + networks: [backend] + deploy: + replicas: 1 + restart_policy: { condition: "no" } + + api: + <<: *api + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: + cpus: "${API_CPU_PER_REPLICA:-0.5}" + memory: "${API_MEM_PER_REPLICA:-128M}" + + migrate: + <<: *api + entrypoint: ["/app/migrate.sh"] + depends_on: + postgres: { condition: service_healthy } + deploy: + replicas: 1 + restart_policy: + condition: "no" + + lb: + image: nginx:1.27.0-alpine + volumes: + - ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro + ports: + - "8080:8080" + depends_on: [api] + networks: [backend] + +volumes: + pgdata: + redisdata: + s3data: + +networks: + backend: + driver: bridge + +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 } + minio_root_user: { file: ./secrets/minio_root_user.txt } + minio_root_password: { file: ./secrets/minio_root_password.txt } \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..ce04daa2 --- /dev/null +++ b/go.mod @@ -0,0 +1,30 @@ +module mtusi-messenger + +go 1.22 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.5.5 + github.com/minio/minio-go/v7 v7.0.72 + github.com/redis/go-redis/v9 v9.5.1 + golang.org/x/crypto v0.23.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/goccy/go-json v0.10.2 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect + github.com/jackc/puddle/v2 v2.2.1 // indirect + github.com/klauspost/compress v1.17.6 // indirect + github.com/klauspost/cpuid/v2 v2.2.6 // indirect + github.com/minio/md5-simd v1.1.2 // indirect + github.com/rs/xid v1.5.0 // indirect + golang.org/x/net v0.23.0 // indirect + golang.org/x/sync v0.1.0 // indirect + golang.org/x/sys v0.20.0 // indirect + golang.org/x/text v0.15.0 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..9a1cd55c --- /dev/null +++ b/go.sum @@ -0,0 +1,62 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +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-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= +github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw= +github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc= +github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.72 h1:ZSbxs2BfJensLyHdVOgHv+pfmvxYraaUy07ER04dWnA= +github.com/minio/minio-go/v7 v7.0.72/go.mod h1:4yBA8v80xGA30cfM3fz0DKYMXunWl/AV/6tWEs9ryzo= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= +github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= +golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/infra/minio/bootstrap.sh b/infra/minio/bootstrap.sh new file mode 100644 index 00000000..45aed49e --- /dev/null +++ b/infra/minio/bootstrap.sh @@ -0,0 +1,52 @@ +#!/bin/sh +set -eu + +MINIO_ROOT_USER_FILE="${MINIO_ROOT_USER_FILE:-/run/secrets/minio_root_user}" +MINIO_ROOT_PASSWORD_FILE="${MINIO_ROOT_PASSWORD_FILE:-/run/secrets/minio_root_password}" +S3_ENDPOINT="${S3_ENDPOINT:-http://s3:9000}" +S3_BUCKET="${S3_BUCKET:-messenger-attachments}" +API_USER_FILE="${S3_ACCESS_KEY_ID_FILE:-/run/secrets/s3_access_key_id}" +API_PASS_FILE="${S3_SECRET_ACCESS_KEY_FILE:-/run/secrets/s3_secret_access_key}" + +for f in "$MINIO_ROOT_USER_FILE" "$MINIO_ROOT_PASSWORD_FILE"; do + [ -f "$f" ] || { echo "ERROR: missing $f" >&2; exit 1; } +done + +ROOT_USER="$(cat "$MINIO_ROOT_USER_FILE")" +ROOT_PASS="$(cat "$MINIO_ROOT_PASSWORD_FILE")" + +mc alias set local "$S3_ENDPOINT" "$ROOT_USER" "$ROOT_PASS" >/dev/null + +# 1) bucket: приватный, создаётся один раз +mc mb --ignore-existing "local/$S3_BUCKET" >/dev/null +mc anonymous set none "local/$S3_BUCKET" >/dev/null + +# 2) ограниченный пользователь API (если креды заданы заранее) +if [ -s "$API_USER_FILE" ] && [ -s "$API_PASS_FILE" ]; then + API_USER="$(cat "$API_USER_FILE")" + API_PASS="$(cat "$API_PASS_FILE")" + if ! mc admin user info local "$API_USER" >/dev/null 2>&1; then + mc admin user add local "$API_USER" "$API_PASS" >/dev/null + fi + # Политика: только PutObject/GetObject/DeleteObject в bucket. + cat >/tmp/api-policy.json </dev/null 2>&1 || true + mc admin policy attach local api-attachments --user "$API_USER" >/dev/null 2>&1 || true +else + echo "WARN: API S3 credentials not pre-created; generate and place them in secrets/" >&2 +fi + +echo "s3 bootstrap done (bucket=$S3_BUCKET)" \ No newline at end of file diff --git a/infra/nginx/nginx.conf b/infra/nginx/nginx.conf new file mode 100644 index 00000000..9d5c3ede --- /dev/null +++ b/infra/nginx/nginx.conf @@ -0,0 +1,29 @@ +worker_processes auto; +events { worker_connections 4096; } + +http { + # Docker's embedded DNS. nginx будет обращаться сюда за IP реплик. + resolver 127.0.0.11 valid=2s ipv6=off; + resolver_timeout 5s; + + server { + listen 8080; + client_max_body_size 12m; + + location / { + set $api_backend http://api:8080; + + proxy_pass $api_backend; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + + proxy_connect_timeout 2s; + proxy_send_timeout 15s; + proxy_read_timeout 15s; + + proxy_next_upstream error timeout http_502 http_503 http_504; + } + } +} \ No newline at end of file diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..3925e4ac --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,31 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS 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 TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Индекс истории: ровно под ORDER BY (created_at, id) и keyset-курсор. +CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id + ON messages (chat_id, created_at, id); \ No newline at end of file diff --git a/migrations/0002_sessions.sql b/migrations/0002_sessions.sql new file mode 100644 index 00000000..f77b30d7 --- /dev/null +++ b/migrations/0002_sessions.sql @@ -0,0 +1,9 @@ +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions (user_id); +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions (expires_at); \ No newline at end of file diff --git a/migrations/0003_messages_alt_index.sql b/migrations/0003_messages_alt_index.sql new file mode 100644 index 00000000..12d58f11 --- /dev/null +++ b/migrations/0003_messages_alt_index.sql @@ -0,0 +1,5 @@ +-- Индекс B для «стоимости записи»: +-- покрывающий индекс, включающий text — растёт быстрее, помогает только +-- покрывающим запросам. +CREATE INDEX IF NOT EXISTS idx_messages_chat_covering + ON messages (chat_id, created_at, id) INCLUDE (sender_id, text); \ No newline at end of file diff --git a/migrations/0004_idempotency.sql b/migrations/0004_idempotency.sql new file mode 100644 index 00000000..da621207 --- /dev/null +++ b/migrations/0004_idempotency.sql @@ -0,0 +1,14 @@ +CREATE TABLE IF NOT EXISTS 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, + status_code INTEGER NOT NULL, + response JSONB NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, key) +); + +CREATE INDEX IF NOT EXISTS idx_idempotency_created + ON idempotency_keys (created_at); \ No newline at end of file diff --git a/migrations/0005_attachments.sql b/migrations/0005_attachments.sql new file mode 100644 index 00000000..d8765167 --- /dev/null +++ b/migrations/0005_attachments.sql @@ -0,0 +1,30 @@ +CREATE TABLE IF NOT EXISTS 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 CASCADE, + object_key TEXT NOT NULL UNIQUE, + filename TEXT NOT NULL, + content_type TEXT NOT NULL CHECK (content_type IN ('image/png','image/jpeg')), + size_bytes BIGINT NOT NULL CHECK (size_bytes > 0 AND size_bytes <= 10485760), + sha256 TEXT NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + width INTEGER NOT NULL CHECK (width > 0), + height INTEGER NOT NULL CHECK (height > 0), + status TEXT NOT NULL DEFAULT 'ready' CHECK (status IN ('pending','ready','failed')), + error_code TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments (chat_id, created_at, id); +CREATE INDEX IF NOT EXISTS idx_attachments_owner ON attachments (owner_id); +-- Для reconciler/поиска «зависших» pending-записей: +CREATE INDEX IF NOT EXISTS idx_attachments_pending ON attachments (created_at) WHERE status <> 'ready'; + +ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids UUID[] NOT NULL DEFAULT '{}'; + +-- Журнал компенсации: объекты S3, которые могли остаться без метаданных. +CREATE TABLE IF NOT EXISTS attachment_gc ( + object_key TEXT PRIMARY KEY, + reason TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); \ No newline at end of file diff --git a/scripts/migrate.sh b/scripts/migrate.sh new file mode 100644 index 00000000..5d3457a3 --- /dev/null +++ b/scripts/migrate.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu +# Применяет миграции к БД, читая DATABASE_URL из файла секрета. +# Устойчиво к повторному запуску (CREATE ... IF NOT EXISTS). +URL_FILE="${DATABASE_URL_FILE:-/run/secrets/database_url}" +DATABASE_URL="$(cat "$URL_FILE")" +PSQL="psql $DATABASE_URL -v ON_ERROR_STOP=1 -q" + +for f in migrations/*.sql; do + echo "applying $f" + $PSQL -f "$f" +done +echo "migrations done" \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..742babeb --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,26 @@ +#!/bin/sh +set -eu + +# ./scripts/restart.sh # 2 реплики (по умолчанию) +# ./scripts/restart.sh 4 # 4 реплики +REPLICAS="${1:-2}" + +# Останов с сохранением volumes. +docker compose down --remove-orphans + +# Пересоздание сети + контейнеров с нужным числом реплик. +API_REPLICAS="$REPLICAS" \ + docker compose --env-file .env -f compose.yaml up -d --build + +# Ждём готовности с хоста. +i=0 +while [ "$i" -lt 90 ]; do + if curl -sf http://localhost:8080/health/ready >/dev/null 2>&1; then + echo "ready after ${i}s (replicas=$REPLICAS)" + exit 0 + fi + i=$((i + 1)) + sleep 1 +done +echo "stack did not become ready in 90s" >&2 +exit 1 \ No newline at end of file diff --git a/scripts/restore-api.sh b/scripts/restore-api.sh new file mode 100644 index 00000000..266c2840 --- /dev/null +++ b/scripts/restore-api.sh @@ -0,0 +1,36 @@ +#!/bin/sh +set -eu + +# Все контейнеры сервиса api (включая Exited). +# `docker compose ps -a -q api` возвращает их ID. +STOPPED="" +for id in $(docker compose ps -a -q api); do + state=$(docker inspect --format '{{.State.Status}}' "$id") + if [ "$state" = "exited" ] || [ "$state" = "created" ]; then + STOPPED="$STOPPED $id" + fi +done + +if [ -z "$STOPPED" ]; then + echo "all api containers already running" + exit 0 +fi + +for id in $STOPPED; do + hn=$(docker inspect --format '{{.Config.Hostname}}' "$id") + docker start "$id" >/dev/null + echo "started $id ($hn)" +done + +# Дождаться, пока LB увидит их снова (curl с хоста). +i=0 +while [ "$i" -lt 30 ]; do + if curl -sf http://localhost:8080/health/ready >/dev/null 2>&1; then + echo "ready after ${i}s" + exit 0 + fi + i=$((i + 1)) + sleep 1 +done +echo "stack did not become ready in 30s" >&2 +exit 1 \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..370c3476 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,20 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +# Находим ID контейнера, чьё имя (HOSTNAME) совпадает с TARGET_INSTANCE_ID. +CID=$(docker compose ps -q api | while read -r id; do + name=$(docker inspect --format '{{.Config.Hostname}}' "$id") + if [ "$name" = "$TARGET_INSTANCE_ID" ]; then + echo "$id" + break + fi +done) + +if [ -z "$CID" ]; then + echo "container with hostname $TARGET_INSTANCE_ID not found" >&2 + exit 2 +fi + +docker stop "$CID" +echo "stopped $CID ($TARGET_INSTANCE_ID)" \ No newline at end of file diff --git a/src/api/auth.go b/src/api/auth.go new file mode 100644 index 00000000..be30c192 --- /dev/null +++ b/src/api/auth.go @@ -0,0 +1,79 @@ +package api + +import ( + "context" + "encoding/base64" + "errors" + "net/http" + "strings" + + "mtusi-messenger/src/domain" +) + +// bearerAuth извлекает токен, проверяет сессию и кладёт пользователя в контекст. +// Basic на бизнес-эндпоинтах не принимается. X-User-Id игнорируется. +func (h *Handler) bearerAuth(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + header := r.Header.Get("Authorization") + if !strings.HasPrefix(header, "Bearer ") { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing bearer token") + return + } + token := strings.TrimSpace(strings.TrimPrefix(header, "Bearer ")) + if token == "" { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing bearer token") + return + } + + u, err := h.Sessions.Lookup(r.Context(), token) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrUnauthorized): + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid session") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable") + return + } + + ctx := context.WithValue(r.Context(), userKey, *u) + ctx = context.WithValue(ctx, tokenKey, token) + next(w, r.WithContext(ctx)) + } +} + +func userFrom(r *http.Request) (domain.User, bool) { + u, ok := r.Context().Value(userKey).(domain.User) + return u, ok +} + +func tokenFrom(r *http.Request) string { + if v, ok := r.Context().Value(tokenKey).(string); ok { + return v + } + return "" +} + +// parseBasicCredentials разбирает Authorization: Basic base64(username:password). +func parseBasicCredentials(header string) (string, string, error) { + if !strings.HasPrefix(header, "Basic ") { + return "", "", errors.New("not basic") + } + raw := strings.TrimSpace(strings.TrimPrefix(header, "Basic ")) + decoded, err := base64.StdEncoding.DecodeString(raw) + if err != nil { + return "", "", errors.New("invalid base64") + } + parts := strings.SplitN(string(decoded), ":", 2) + if len(parts) != 2 { + return "", "", errors.New("missing colon") + } + return parts[0], parts[1], nil +} diff --git a/src/api/errors.go b/src/api/errors.go new file mode 100644 index 00000000..7c5b5df8 --- /dev/null +++ b/src/api/errors.go @@ -0,0 +1,28 @@ +package api + +import ( + "encoding/json" + "net/http" + + "mtusi-messenger/src/domain" +) + +// writeError пишет ошибку в формате контракта. +func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(domain.ErrorBody{ + Error: domain.ErrorDetail{ + Code: code, + Message: message, + RequestID: requestIDFrom(r), + }, + }) +} + +// writeJSON пишет успешный JSON-ответ. +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(v) +} diff --git a/src/api/handlers.go b/src/api/handlers.go new file mode 100644 index 00000000..eee49f6d --- /dev/null +++ b/src/api/handlers.go @@ -0,0 +1,537 @@ +package api + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "log" + "net/http" + "regexp" + "strconv" + "strings" + + "mtusi-messenger/src/domain" + + "github.com/google/uuid" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) +var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +type Handler struct { + Store *domain.Store + Sessions *domain.SessionStore + S3 *domain.S3Store + MaxUpload int64 +} + +// --- Health --- + +func (h *Handler) Live(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +// Ready проверяет БД (обязательная зависимость). Redis — кэш, его недоступность +// не должна ронять readiness: API может работать, обходя кэш. +func (h *Handler) Ready(w http.ResponseWriter, r *http.Request) { + if err := h.Store.Ping(r.Context()); err != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +// --- Users --- + +type createUserReq struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` +} + +func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) { + var req createUserReq + if err := decodeSingleJSON(r.Body, &req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if !usernameRe.MatchString(req.Username) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username") + return + } + if n := len([]rune(req.DisplayName)); n < 1 || n > 100 || strings.TrimSpace(req.DisplayName) == "" { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name") + return + } + // Пароль: 12–128 code points, не состоит только из пробелов. + if n := len([]rune(req.Password)); n < 12 || n > 128 || strings.TrimSpace(req.Password) == "" { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password") + return + } + u, err := h.Store.CreateUser(r.Context(), req.Username, req.DisplayName, req.Password) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrConflict): + writeError(w, r, http.StatusConflict, "conflict", "username taken") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusCreated, u) +} + +func (h *Handler) CurrentUser(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + u, _ := userFrom(r) + writeJSON(w, http.StatusOK, u) + })(w, r) +} + +// --- Auth --- + +func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) { + username, password, err := parseBasicCredentials(r.Header.Get("Authorization")) + if err != nil { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials") + return + } + u, err := h.Store.VerifyPassword(r.Context(), username, password) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrUnauthorized): + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + s, err := h.Sessions.Create(r.Context(), *u) + if err != nil { + if errors.Is(err, domain.ErrTimeout) { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout") + return + } + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable") + return + } + writeJSON(w, http.StatusCreated, s) +} + +func (h *Handler) RevokeSession(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + token := tokenFrom(r) + if err := h.Sessions.Revoke(r.Context(), token); err != nil { + if errors.Is(err, domain.ErrTimeout) { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout") + return + } + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable") + return + } + w.WriteHeader(http.StatusNoContent) + })(w, r) +} + +// --- Chats --- + +type createChatReq struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` +} + +func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + var req createChatReq + if err := decodeSingleJSON(r.Body, &req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if strings.TrimSpace(req.Title) == "" || len([]rune(req.Title)) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title") + return + } + if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids") + return + } + c, err := h.Store.CreateChat(r.Context(), req.Title, req.MemberIDs, me.ID) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid members") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusCreated, c) + })(w, r) +} + +func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + limit := 50 + if v := r.URL.Query().Get("limit"); v != "" { + n, err := strconv.Atoi(v) + if err != nil || n < 1 || n > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid limit") + return + } + limit = n + } + cursor := r.URL.Query().Get("cursor") + chats, next, err := h.Store.ListChats(r.Context(), me.ID, limit, cursor) + switch { + case err == nil: + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusOK, domain.ChatPage{Items: chats, NextCursor: next}) + })(w, r) +} + +func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + chatID := r.PathValue("chat_id") + c, err := h.Store.GetChat(r.Context(), chatID, me.ID) + switch { + case err == nil: + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat_id") + return + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusOK, c) + })(w, r) +} + +// --- Messages --- + +type createMessageReq struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` +} + +func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + chatID := r.PathValue("chat_id") + + // Idempotency-Key обязателен. + key := r.Header.Get("Idempotency-Key") + if key == "" { + writeError(w, r, http.StatusBadRequest, "invalid_request", "Idempotency-Key required") + return + } + if !idempotencyKeyRe.MatchString(key) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid Idempotency-Key") + return + } + + if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil { + switch { + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat_id") + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + } + return + } + + // Читаем тело один раз и хешируем нормализованный JSON. + rawBody, err := io.ReadAll(io.LimitReader(r.Body, 64*1024)) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "cannot read body") + return + } + var req createMessageReq + if err := decodeSingleJSON(bytes.NewReader(rawBody), &req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if len([]rune(req.Text)) > 4000 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "message too long") + return + } + if strings.TrimSpace(req.Text) == "" && len(req.AttachmentIDs) == 0 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "empty message") + return + } + bodyHash, err := domain.HashBody(rawBody) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if len(req.Text) > 0 && len([]rune(req.Text)) == 0 { + // всё пробелы, но вложения есть — допустимо + } + + attachmentIDs := req.AttachmentIDs + if attachmentIDs == nil { + attachmentIDs = []string{} + } + msg, rec, replay, err := h.Store.AddMessageIdempotent( + r.Context(), chatID, me.ID, req.Text, attachmentIDs, key, bodyHash) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + case errors.Is(err, domain.ErrConflict): + writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + + if replay { + // Возвращаем сохранённый 201 и то же Message. + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(rec.StatusCode) + _, _ = w.Write(rec.Response) + return + } + writeJSON(w, http.StatusCreated, msg) + })(w, r) +} + +func (h *Handler) ListMessages(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + chatID := r.PathValue("chat_id") + if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil { + switch { + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat_id") + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + } + return + } + limit := 50 + if v := r.URL.Query().Get("limit"); v != "" { + n, err := strconv.Atoi(v) + if err != nil || n < 1 || n > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid limit") + return + } + limit = n + } + cursor := r.URL.Query().Get("cursor") + items, next, err := h.Store.ListMessages(r.Context(), chatID, limit, cursor) + switch { + case err == nil: + // ok + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor") + return + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "query timeout") + return + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusOK, domain.MessagePage{Items: items, NextCursor: next}) + })(w, r) +} + +func decodeSingleJSON(r io.Reader, v any) error { + dec := json.NewDecoder(r) + dec.DisallowUnknownFields() + if err := dec.Decode(v); err != nil { + return err + } + if dec.More() { + return errors.New("trailing data after JSON value") + } + // Пробуем прочитать ещё один токен — если это не EOF, значит есть мусор. + var extra any + if err := dec.Decode(&extra); err != io.EOF { + return errors.New("trailing data after JSON value") + } + return nil +} + +// --- Attachments --- + +// safeFilename отбрасывает пути и опасные имена; используется только для отображения. +func safeFilename(name string) (string, bool) { + name = strings.TrimSpace(name) + if name == "" || len(name) > 255 { + return "", false + } + if strings.ContainsAny(name, "/\\") || strings.Contains(name, "..") { + return "", false + } + for _, r := range name { + if r < 0x20 || r == 0x7f { + return "", false + } + } + return name, true +} + +func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + chatID := r.PathValue("chat_id") + + if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil { + switch { + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat_id") + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + } + return + } + + filename, ok := safeFilename(r.URL.Query().Get("filename")) + if !ok { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid filename") + return + } + + objectKey := "attachments/" + chatID + "/" + uuid.NewString() + pendingID, err := h.Store.CreateAttachmentPending(r.Context(), chatID, me.ID, objectKey, filename) + if err != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + + res, err := h.S3.PutValidatedImage(r.Context(), objectKey, r.Body) + if err != nil { + _ = h.Store.MarkAttachmentFailed(r.Context(), pendingID, err.Error()) + _ = h.Store.ScheduleObjectGC(r.Context(), objectKey, "upload_failed") + switch { + case errors.Is(err, domain.ErrTooLarge): + writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file too large") + case errors.Is(err, domain.ErrUnsupported): + writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "only PNG/JPEG") + case errors.Is(err, domain.ErrNotImage): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid image") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "storage unavailable") + } + return + } + + att, err := h.Store.FinalizeAttachment(r.Context(), pendingID, res.ContentType, res.SizeBytes, res.SHA256, res.Width, res.Height) + if err != nil { + // S3 PUT прошёл, COMMIT — нет: объект в GC. + _ = h.Store.ScheduleObjectGC(r.Context(), objectKey, "finalize_failed") + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + writeJSON(w, http.StatusCreated, att) + })(w, r) +} + +func (h *Handler) GetAttachment(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + att, err := h.Store.GetAttachmentForUser(r.Context(), r.PathValue("attachment_id"), me.ID) + switch { + case err == nil: + writeJSON(w, http.StatusOK, att) + case errors.Is(err, domain.ErrNotFound): + writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + } + })(w, r) +} + +func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + me, _ := userFrom(r) + id := r.PathValue("attachment_id") + att, err := h.Store.GetAttachmentForUser(r.Context(), id, me.ID) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") + return + } + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + key, err := h.Store.GetAttachmentObjectKey(r.Context(), att.ID) + if err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") + return + } + + rc, contentType, size, err := h.S3.GetObject(r.Context(), key) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "file missing in storage") + return + } + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "storage unavailable") + return + } + defer rc.Close() + + w.Header().Set("Content-Type", contentType) + w.Header().Set("Content-Length", strconv.FormatInt(size, 10)) + w.Header().Set("Content-Disposition", `inline; filename="`+strings.ReplaceAll(att.Filename, `"`, "")+`"`) + w.WriteHeader(http.StatusOK) + + written, err := io.Copy(w, rc) + if err != nil || written != size { + // Соединение уже частично отправлено, но клиент получит обрезанный файл. + // Логируем это для отладки. + log.Printf("download truncated: written=%d expected=%d err=%v", written, size, err) + } + })(w, r) +} diff --git a/src/api/middleware.go b/src/api/middleware.go new file mode 100644 index 00000000..7cce92e1 --- /dev/null +++ b/src/api/middleware.go @@ -0,0 +1,46 @@ +package api + +import ( + "context" + "net/http" + + "github.com/google/uuid" +) + +type ctxKey string + +const ( + requestIDKey ctxKey = "request_id" + userKey ctxKey = "user" + tokenKey ctxKey = "token" +) + +func requestIDFrom(r *http.Request) string { + if v, ok := r.Context().Value(requestIDKey).(string); ok { + return v + } + return "" +} + +func withRequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = uuid.NewString() + } + w.Header().Set("X-Request-Id", id) + ctx := context.WithValue(r.Context(), requestIDKey, id) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +// withInstanceID ставит X-Instance-Id на КАЖДЫЙ ответ (включая ошибки и health). +// ID генерируется один раз при старте процесса — стабилен в пределах жизни. +func withInstanceID(instanceID 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", instanceID) + next.ServeHTTP(w, r) + }) + } +} diff --git a/src/api/router.go b/src/api/router.go new file mode 100644 index 00000000..d5f9b317 --- /dev/null +++ b/src/api/router.go @@ -0,0 +1,24 @@ +package api + +import "net/http" + +func NewRouter(h *Handler, instanceID string) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("GET /health/live", h.Live) + mux.HandleFunc("GET /health/ready", h.Ready) + mux.HandleFunc("POST /api/v1/users", h.CreateUser) + mux.HandleFunc("GET /api/v1/users/me", h.CurrentUser) + mux.HandleFunc("POST /api/v1/auth/sessions", h.CreateSession) + mux.HandleFunc("DELETE /api/v1/auth/sessions/current", h.RevokeSession) + mux.HandleFunc("POST /api/v1/chats", h.CreateChat) + mux.HandleFunc("GET /api/v1/chats", h.ListChats) + mux.HandleFunc("GET /api/v1/chats/{chat_id}", h.GetChat) + mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", h.CreateMessage) + mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", h.ListMessages) + mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", h.UploadAttachment) + mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", h.GetAttachment) + mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", h.DownloadAttachment) + + // Порядок: instanceID снаружи, requestID внутри. + return withInstanceID(instanceID)(withRequestID(mux)) +} diff --git a/src/config/config.go b/src/config/config.go new file mode 100644 index 00000000..d9fa3e8c --- /dev/null +++ b/src/config/config.go @@ -0,0 +1,136 @@ +package config + +import ( + "crypto/rand" + "encoding/hex" + "os" + "strconv" + "time" +) + +type Config struct { + Host string + Port int + Env string + DatabaseURL string + CacheURL string + SessionTTL time.Duration + SessionStore string + RedisRequired bool + InstanceID string + S3Endpoint string + S3Region string + S3Bucket string + S3AccessKeyID string + S3SecretKey string + MaxUploadBytes int64 + MaxImagePixels int64 + S3GCGrace time.Duration +} + +func getenv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func readSecretFromFile(path string) string { + if path == "" { + return "" + } + b, err := os.ReadFile(path) + if err != nil { + return "" + } + return string(b) +} + +func Load() Config { + port := 8080 + if v := os.Getenv("APP_PORT"); v != "" { + if p, err := strconv.Atoi(v); err == nil { + port = p + } + } + ttl := 3600 + if v := os.Getenv("SESSION_TTL_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n > 0 { + ttl = n + } + } + + // DATABASE_URL и CACHE_URL могут прийти либо напрямую, либо через *_FILE. + dbURL := os.Getenv("DATABASE_URL") + if dbURL == "" { + dbURL = readSecretFromFile(os.Getenv("DATABASE_URL_FILE")) + } + cacheURL := os.Getenv("CACHE_URL") + if cacheURL == "" { + cacheURL = readSecretFromFile(os.Getenv("CACHE_URL_FILE")) + } + + instanceID := os.Getenv("INSTANCE_ID") + if instanceID == "" { + instanceID = os.Getenv("HOSTNAME") + } + if instanceID == "" { + instanceID = "api-" + randomShortID() + } + + store := getenv("SESSION_STORE", "postgres") + + s3Access := os.Getenv("S3_ACCESS_KEY_ID") + if s3Access == "" { + s3Access = readSecretFromFile(os.Getenv("S3_ACCESS_KEY_ID_FILE")) + } + s3Secret := os.Getenv("S3_SECRET_ACCESS_KEY") + if s3Secret == "" { + s3Secret = readSecretFromFile(os.Getenv("S3_SECRET_ACCESS_KEY_FILE")) + } + maxUpload := int64(10485760) + if v := os.Getenv("MAX_UPLOAD_BYTES"); v != "" { + if n, err := strconv.ParseInt(v, 10, 64); err == nil && n > 0 { + maxUpload = n + } + } + maxPixels := int64(40000000) + if v := os.Getenv("MAX_IMAGE_PIXELS"); v != "" { + if n, err := strconv.ParseInt(v, 10, 64); err == nil && n > 0 { + maxPixels = n + } + } + gcGrace := 600 * time.Second + if v := os.Getenv("S3_GC_GRACE_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n > 0 { + gcGrace = time.Duration(n) * time.Second + } + } + return Config{ + Host: getenv("APP_HOST", "0.0.0.0"), + Port: port, + Env: getenv("APP_ENV", "lab"), + DatabaseURL: dbURL, + CacheURL: cacheURL, + SessionTTL: time.Duration(ttl) * time.Second, + SessionStore: store, + RedisRequired: store == "redis", + InstanceID: instanceID, + S3Endpoint: getenv("S3_ENDPOINT", ""), + S3Region: getenv("S3_REGION", "us-east-1"), + S3Bucket: getenv("S3_BUCKET", "messenger-attachments"), + S3AccessKeyID: s3Access, + S3SecretKey: s3Secret, + MaxUploadBytes: maxUpload, + MaxImagePixels: maxPixels, + S3GCGrace: gcGrace, + } +} + +func randomShortID() string { + b := make([]byte, 6) + if _, err := rand.Read(b); err != nil { + return "unknown" + } + return hex.EncodeToString(b) +} diff --git a/src/domain/attachments.go b/src/domain/attachments.go new file mode 100644 index 00000000..0a724bda --- /dev/null +++ b/src/domain/attachments.go @@ -0,0 +1,189 @@ +package domain + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" +) + +// CreateAttachmentPending резервирует строку ДО записи в S3. +// Это даёт точку компенсации: если S3 PUT упал, строка снимается/чистится. +func (s *Store) CreateAttachmentPending(ctx context.Context, chatID, ownerID, objectKey, filename string) (string, error) { + id := uuid.NewString() + _, err := s.pool.Exec(ctx, + `INSERT INTO attachments (id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, width, height, status) + VALUES ($1,$2,$3,$4,$5,'image/png',1,repeat('0',64),1,1,'pending')`, + id, chatID, ownerID, objectKey, filename) + if err != nil { + return "", classifyDBError(err) + } + return id, nil +} + +// FinalizeAttachment атомарно переводит pending→ready с реальными метаданными. +func (s *Store) FinalizeAttachment(ctx context.Context, id, contentType string, size int64, sha string, w, h int) (*Attachment, error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var a Attachment + var errCode *string + err = tx.QueryRow(ctx, + `UPDATE attachments + SET content_type=$2, size_bytes=$3, sha256=$4, width=$5, height=$6, + status='ready', error_code=NULL, updated_at=now() + WHERE id=$1 AND status='pending' + RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at`, + id, contentType, size, sha, w, h, + ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, + &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + a.ErrorCode = errCode + a.Variants = []Variant{} + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + return &a, nil +} + +// MarkAttachmentFailed помечает pending как failed (компенсация). +func (s *Store) MarkAttachmentFailed(ctx context.Context, id, code string) error { + _, err := s.pool.Exec(ctx, + `UPDATE attachments SET status='failed', error_code=$2, updated_at=now() + WHERE id=$1 AND status='pending'`, id, code) + return classifyDBError(err) +} + +// ScheduleObjectGC ставит object_key в очередь на удаление (grace period). +func (s *Store) ScheduleObjectGC(ctx context.Context, objectKey, reason string) error { + _, err := s.pool.Exec(ctx, + `INSERT INTO attachment_gc (object_key, reason) VALUES ($1,$2) + ON CONFLICT (object_key) DO NOTHING`, objectKey, reason) + return classifyDBError(err) +} + +// GetAttachmentForUser возвращает вложение, только если пользователь — участник чата. +func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (*Attachment, error) { + var a Attachment + var errCode *string + err := s.pool.QueryRow(ctx, ` + SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, + a.status, a.error_code, a.created_at, a.updated_at + FROM attachments a + JOIN chat_members m ON m.chat_id = a.chat_id + WHERE a.id=$1 AND m.user_id=$2 AND a.status='ready'`, id, userID, + ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, + &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + a.ErrorCode = errCode + a.Variants = []Variant{} + return &a, nil +} + +// GetAttachmentObjectKey — только для внутреннего download после проверки ACL. +func (s *Store) GetAttachmentObjectKey(ctx context.Context, id string) (string, error) { + var key string + err := s.pool.QueryRow(ctx, `SELECT object_key FROM attachments WHERE id=$1`, id).Scan(&key) + if errors.Is(err, pgx.ErrNoRows) { + return "", ErrNotFound + } + if err != nil { + return "", classifyDBError(err) + } + return key, nil +} + +// ValidateAttachmentIDsForChat проверяет, что все вложения принадлежат чату, +// имеют статус ready и лимит 10. Возвращает ErrInvalid/ErrNotFound. +func (s *Store) ValidateAttachmentIDsForChat(ctx context.Context, chatID string, ids []string) error { + if len(ids) > 10 { + return ErrInvalid + } + seen := map[string]bool{} + for _, id := range ids { + if seen[id] { + return ErrInvalid + } + seen[id] = true + var ok bool + err := s.pool.QueryRow(ctx, + `SELECT true FROM attachments WHERE id=$1 AND chat_id=$2 AND status='ready'`, + id, chatID).Scan(&ok) + if errors.Is(err, pgx.ErrNoRows) { + return ErrNotFound + } + if err != nil { + return classifyDBError(err) + } + } + return nil +} + +// ReconcileOrphans: удаляет объекты из attachment_gc старше grace, которых нет в БД, +// и «призрачные» объекты pending старше grace. Вызывается из фонового тикера. +func (s *Store) ReconcileOrphans(ctx context.Context, s3 *S3Store, grace time.Duration) error { + // 1) GC-очередь: удалить объекты в S3, затем строку. + rows, err := s.pool.Query(ctx, + `SELECT object_key FROM attachment_gc WHERE created_at < now() - $1::interval LIMIT 100`, + grace.String()) + if err != nil { + return classifyDBError(err) + } + var keys []string + for rows.Next() { + var k string + if err := rows.Scan(&k); err != nil { + rows.Close() + return classifyDBError(err) + } + keys = append(keys, k) + } + rows.Close() + for _, k := range keys { + if err := s3.DeleteObject(ctx, k); err != nil { + continue + } + _, _ = s.pool.Exec(ctx, `DELETE FROM attachment_gc WHERE object_key=$1`, k) + } + + // 2) pending-записи старше grace: объект мог попасть в S3, а commit — нет. + prow, err := s.pool.Query(ctx, + `SELECT id, object_key FROM attachments + WHERE status='pending' AND created_at < now() - $1::interval LIMIT 100`, + grace.String()) + if err != nil { + return classifyDBError(err) + } + type pend struct{ id, key string } + var pendings []pend + for prow.Next() { + var p pend + if err := prow.Scan(&p.id, &p.key); err != nil { + prow.Close() + return classifyDBError(err) + } + pendings = append(pendings, p) + } + prow.Close() + for _, p := range pendings { + _ = s3.DeleteObject(ctx, p.key) + _, _ = s.pool.Exec(ctx, `DELETE FROM attachments WHERE id=$1 AND status='pending'`, p.id) + } + return nil +} diff --git a/src/domain/cache.go b/src/domain/cache.go new file mode 100644 index 00000000..45032295 --- /dev/null +++ b/src/domain/cache.go @@ -0,0 +1,91 @@ +package domain + +import ( + "context" + "encoding/json" + "time" + + "github.com/redis/go-redis/v9" +) + +// SessionCache — необязательный кэш сессий поверх Redis. +// Источник истины — PostgreSQL. Кэш ускоряет проверку токена. +type SessionCache struct { + rdb *redis.Client +} + +func NewSessionCache(ctx context.Context, url string) (*SessionCache, error) { + opt, err := redis.ParseURL(url) + if err != nil { + return nil, err + } + // Жёсткие короткие таймауты: Redis — кэш, а не критический путь. + opt.DialTimeout = 1 * time.Second + opt.ReadTimeout = 500 * time.Millisecond + opt.WriteTimeout = 500 * time.Millisecond + opt.MaxRetries = 0 // без автоматических ретраев: одна попытка — и уходим в БД + opt.PoolTimeout = 1 * time.Second + + rdb := redis.NewClient(opt) + + // Проверка связи при старте — короткая. + c, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + if err := rdb.Ping(c).Err(); err != nil { + _ = rdb.Close() + return nil, err + } + return &SessionCache{rdb: rdb}, nil +} + +func (c *SessionCache) userKey(userID string) string { return "user:" + userID } + +// opCtx возвращает контекст с коротким таймаутом для каждой операции. +// Не наследуем HTTP-контекст напрямую, чтобы не блокировать ответ клиенту. +func (c *SessionCache) opCtx() (context.Context, context.CancelFunc) { + return context.WithTimeout(context.Background(), 500*time.Millisecond) +} + +// SetUser кладёт публичные данные пользователя в кэш с TTL до конца сессии. +func (c *SessionCache) SetUser(ctx context.Context, userID string, u User, expires time.Time) { + ttl := time.Until(expires) + if ttl <= 0 { + return + } + b, err := json.Marshal(u) + if err != nil { + return + } + opCtx, cancel := c.opCtx() + defer cancel() + _ = c.rdb.Set(opCtx, c.userKey(userID), b, ttl).Err() +} + +func (c *SessionCache) GetUser(ctx context.Context, userID string) (User, bool) { + opCtx, cancel := c.opCtx() + defer cancel() + b, err := c.rdb.Get(opCtx, c.userKey(userID)).Bytes() + if err != nil { + return User{}, false + } + var u User + if err := json.Unmarshal(b, &u); err != nil { + return User{}, false + } + return u, true +} + +// DelUser — на случай удаления пользователя (в lab2 не вызывается). +func (c *SessionCache) DelUser(ctx context.Context, userID string) error { + opCtx, cancel := c.opCtx() + defer cancel() + return c.rdb.Del(opCtx, c.userKey(userID)).Err() +} + +func (c *SessionCache) Ping(ctx context.Context) error { + c2, cancel := context.WithTimeout(ctx, 1*time.Second) + defer cancel() + return c.rdb.Ping(c2).Err() +} + +func (c *SessionCache) Close() error { return c.rdb.Close() } diff --git a/src/domain/idempotency.go b/src/domain/idempotency.go new file mode 100644 index 00000000..f340f77d --- /dev/null +++ b/src/domain/idempotency.go @@ -0,0 +1,75 @@ +package domain + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "time" + + "github.com/jackc/pgx/v5" +) + +// IdempotencyRecord — сохранённый результат POST. +type IdempotencyRecord struct { + StatusCode int + Response json.RawMessage +} + +// LookupIdempotency возвращает запись, если ключ уже использован. +// Второй аргумент — совпадает ли хеш тела с сохранённым. +func (s *Store) LookupIdempotency(ctx context.Context, userID, method, path, key, bodyHash string) (*IdempotencyRecord, bool, error) { + var ( + storedHash string + rec IdempotencyRecord + ) + err := s.pool.QueryRow(ctx, + `SELECT request_hash, status_code, response + FROM idempotency_keys + WHERE user_id=$1 AND method=$2 AND path=$3 AND key=$4`, + userID, method, path, key, + ).Scan(&storedHash, &rec.StatusCode, &rec.Response) + if errors.Is(err, pgx.ErrNoRows) { + return nil, false, nil + } + if err != nil { + return nil, false, classifyDBError(err) + } + if storedHash != bodyHash { + return nil, true, ErrConflict + } + return &rec, true, nil +} + +// SaveIdempotency пишет результат. Конфликт PK означает, что параллельный +// запрос успел раньше — вызывающий должен перечитать через LookupIdempotency. +func (s *Store) SaveIdempotency(ctx context.Context, userID, method, path, key, bodyHash string, status int, resp json.RawMessage) error { + _, err := s.pool.Exec(ctx, + `INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, status_code, response) + VALUES ($1,$2,$3,$4,$5,$6,$7)`, + userID, method, path, key, bodyHash, status, resp) + return classifyDBError(err) +} + +// HashBody — стабильный хеш JSON независимо от порядка ключей. +func HashBody(raw []byte) (string, error) { + var v any + if err := json.Unmarshal(raw, &v); err != nil { + return "", err + } + normalized, err := json.Marshal(v) // map keys сортируются + if err != nil { + return "", err + } + sum := sha256.Sum256(normalized) + return hex.EncodeToString(sum[:]), nil +} + +// CleanupIdempotency — можно звать из фонового тикера (опционально). +func (s *Store) CleanupIdempotency(ctx context.Context, olderThan time.Duration) error { + _, err := s.pool.Exec(ctx, + `DELETE FROM idempotency_keys WHERE created_at < now() - $1::interval`, + olderThan.String()) + return err +} diff --git a/src/domain/models.go b/src/domain/models.go new file mode 100644 index 00000000..9f427722 --- /dev/null +++ b/src/domain/models.go @@ -0,0 +1,92 @@ +package domain + +import ( + "errors" + "time" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` + AttachmentIDs []string `json:"attachment_ids"` +} + +type MessagePage struct { + Items []Message `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type ChatPage struct { + Items []Chat `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type Session struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt time.Time `json:"expires_at"` + User User `json:"user"` +} + +type ErrorBody struct { + Error ErrorDetail `json:"error"` +} + +type ErrorDetail struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +type Variant struct { + Name string `json:"name"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + Width int `json:"width"` + Height int `json:"height"` + SHA256 string `json:"sha256"` +} + +type Attachment struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + OwnerID string `json:"owner_id"` + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + Status string `json:"status"` + Variants []Variant `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` +} + +var ( + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrInvalid = errors.New("invalid request") + ErrUnauthorized = errors.New("unauthorized") + ErrTimeout = errors.New("timeout") + ErrUnavailable = errors.New("unavailable") + ErrTooLarge = errors.New("payload too large") + ErrUnsupported = errors.New("unsupported media type") + ErrNotImage = errors.New("not a valid image") +) diff --git a/src/domain/postgres.go b/src/domain/postgres.go new file mode 100644 index 00000000..3497f4c6 --- /dev/null +++ b/src/domain/postgres.go @@ -0,0 +1,608 @@ +package domain + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "encoding/json" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + "golang.org/x/crypto/argon2" +) + +type Store struct { + pool *pgxpool.Pool +} + +func NewStore(ctx context.Context, dsn string) (*Store, error) { + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + return nil, classifyDBError(err) + } + cfg.MaxConns = 10 + cfg.MinConns = 1 + cfg.MaxConnLifetime = time.Hour + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.ConnConfig.ConnectTimeout = 5 * time.Second + + cfg.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error { + _, err := conn.Exec(ctx, ` + SET statement_timeout = '5s'; + SET lock_timeout = '2s'; + SET idle_in_transaction_session_timeout = '5s'; + `) + return err + } + + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, classifyDBError(err) + } + ctxPing, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(ctxPing); err != nil { + pool.Close() + return nil, classifyDBError(err) + } + return &Store{pool: pool}, nil +} + +func (s *Store) Close() { s.pool.Close() } + +func (s *Store) Ping(ctx context.Context) error { + c, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + return s.pool.Ping(c) +} + +// Argon2id параметры — OWASP baseline: m=19456 KiB (19 MiB), t=2, p=1. +// Хеш кодируется в формате PHC: $argon2id$v=19$m=19456,t=2,p=1$$ +const ( + argonMemory uint32 = 19456 + argonTime uint32 = 2 + argonThreads uint8 = 1 + argonKeyLen uint32 = 32 + argonSaltLen = 16 +) + +func hashPassword(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", err + } + key := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + b64Salt := base64.RawStdEncoding.EncodeToString(salt) + b64Key := base64.RawStdEncoding.EncodeToString(key) + // PHC string; параметры можно будет менять в будущем, старые хеши останутся валидными. + return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s", + argonMemory, argonTime, argonThreads, b64Salt, b64Key), nil +} + +func verifyPassword(password, encoded string) bool { + // Минимальный парсер PHC-строки. + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return false + } + var mem, time uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &time, &threads); err != nil { + return false + } + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return false + } + wantKey, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return false + } + gotKey := argon2.IDKey([]byte(password), salt, time, mem, threads, uint32(len(wantKey))) + return subtle.ConstantTimeCompare(gotKey, wantKey) == 1 +} + +// --- Users --- + +func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*User, error) { + hash, err := hashPassword(password) + if err != nil { + return nil, classifyDBError(err) + } + id := uuid.NewString() + var u User + err = s.pool.QueryRow(ctx, + `INSERT INTO users (id, username, display_name, password_hash) + VALUES ($1,$2,$3,$4) + RETURNING id, username, display_name, created_at`, + id, username, displayName, string(hash), + ).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { + return nil, ErrConflict + } + return nil, classifyDBError(err) + } + return &u, nil +} + +func (s *Store) GetUserByID(ctx context.Context, id string) (*User, error) { + var u User + err := s.pool.QueryRow(ctx, + `SELECT id, username, display_name, created_at FROM users WHERE id=$1`, id, + ).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + return &u, nil +} + +// VerifyPassword возвращает пользователя, если пароль верный; иначе ErrUnauthorized. +func (s *Store) VerifyPassword(ctx context.Context, username, password string) (*User, error) { + var u User + var hash string + err := s.pool.QueryRow(ctx, + `SELECT id, username, display_name, created_at, password_hash FROM users WHERE username=$1`, + username, + ).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash) + if errors.Is(err, pgx.ErrNoRows) { + // Тратим сопоставимое время на проверку фиктивного хеша, + // чтобы не различать "нет пользователя" и "неверный пароль" по таймингу. + _ = verifyPassword(password, "$argon2id$v=19$m=19456,t=2,p=1$AAAAAAAAAAAAAAAAAAAAAA$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") + return nil, ErrUnauthorized + } + if err != nil { + return nil, classifyDBError(err) + } + if !verifyPassword(password, hash) { + return nil, ErrUnauthorized + } + return &u, nil +} + +// --- Chats --- + +func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string, creatorID string) (*Chat, error) { + // Проверка входных данных. + seen := map[string]bool{} + for _, id := range memberIDs { + if seen[id] { + return nil, ErrInvalid + } + seen[id] = true + } + if !seen[creatorID] { + return nil, ErrInvalid + } + + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + // Проверяем, что все участники существуют. + for id := range seen { + var exists bool + if err := tx.QueryRow(ctx, `SELECT true FROM users WHERE id=$1`, id).Scan(&exists); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrInvalid + } + return nil, classifyDBError(err) + } + } + + chatID := uuid.NewString() + var c Chat + err = tx.QueryRow(ctx, + `INSERT INTO chats (id, title) VALUES ($1,$2) RETURNING id, title, created_at`, + chatID, title, + ).Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + return nil, classifyDBError(err) + } + + for id := range seen { + if _, err := tx.Exec(ctx, + `INSERT INTO chat_members (chat_id, user_id) VALUES ($1,$2)`, + c.ID, id, + ); err != nil { + return nil, classifyDBError(err) + } + } + + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + + // Порядок member_ids — как в запросе. + c.MemberIDs = append([]string(nil), memberIDs...) + return &c, nil +} + +func (s *Store) GetChat(ctx context.Context, chatID, userID string) (*Chat, error) { + var exists bool + err := s.pool.QueryRow(ctx, + `SELECT true FROM chat_members WHERE chat_id=$1 AND user_id=$2`, + chatID, userID, + ).Scan(&exists) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + + var c Chat + err = s.pool.QueryRow(ctx, + `SELECT id, title, created_at FROM chats WHERE id=$1`, chatID, + ).Scan(&c.ID, &c.Title, &c.CreatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + + rows, err := s.pool.Query(ctx, + `SELECT user_id FROM chat_members WHERE chat_id=$1 ORDER BY user_id`, chatID) + if err != nil { + return nil, classifyDBError(err) + } + defer rows.Close() + for rows.Next() { + var uid string + if err := rows.Scan(&uid); err != nil { + return nil, classifyDBError(err) + } + c.MemberIDs = append(c.MemberIDs, uid) + } + return &c, rows.Err() +} + +// ListChats возвращает чаты пользователя с keyset-пагинацией по (created_at, id). +func (s *Store) ListChats(ctx context.Context, userID string, limit int, cursor string) ([]Chat, *string, error) { + var rows pgx.Rows + var err error + + if cursor == "" { + rows, err = s.pool.Query(ctx, + `SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1 + ORDER BY c.created_at, c.id + LIMIT $2`, userID, limit+1) + } else { + var cCreated time.Time + if err := s.pool.QueryRow(ctx, + `SELECT created_at FROM chats WHERE id=$1`, cursor, + ).Scan(&cCreated); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, ErrInvalid + } + return nil, nil, classifyDBError(err) + } + rows, err = s.pool.Query(ctx, + `SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1 + AND (c.created_at, c.id) > ($2, $3) + ORDER BY c.created_at, c.id + LIMIT $4`, userID, cCreated, cursor, limit+1) + } + if err != nil { + return nil, nil, classifyDBError(err) + } + defer rows.Close() + + var chats []Chat + for rows.Next() { + var c Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, nil, classifyDBError(err) + } + chats = append(chats, c) + } + if err := rows.Err(); err != nil { + return nil, nil, classifyDBError(err) + } + + var next *string + if len(chats) > limit { + chats = chats[:limit] + last := chats[len(chats)-1].ID + next = &last + } + if chats == nil { + chats = []Chat{} + } + + // Догружаем участников. + for i := range chats { + mrows, err := s.pool.Query(ctx, + `SELECT user_id FROM chat_members WHERE chat_id=$1 ORDER BY user_id`, chats[i].ID) + if err != nil { + return nil, nil, classifyDBError(err) + } + for mrows.Next() { + var uid string + if err := mrows.Scan(&uid); err != nil { + mrows.Close() + return nil, nil, classifyDBError(err) + } + chats[i].MemberIDs = append(chats[i].MemberIDs, uid) + } + mrows.Close() + } + return chats, next, nil +} + +// --- Messages --- + +func (s *Store) AddMessage(ctx context.Context, chatID, senderID, text string) (*Message, error) { + // Проверка членства + вставка в одной транзакции. + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var ok bool + if err := tx.QueryRow(ctx, + `SELECT true FROM chat_members WHERE chat_id=$1 AND user_id=$2`, + chatID, senderID, + ).Scan(&ok); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, classifyDBError(err) + } + + var m Message + var attach []string + err = tx.QueryRow(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids) + VALUES ($1,$2,$3,$4,$5) + RETURNING id, chat_id, sender_id, text, created_at, attachment_ids`, + uuid.NewString(), chatID, senderID, text, []string{}, + ).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt, &attach) + if err != nil { + return nil, classifyDBError(err) + } + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + m.AttachmentIDs = attach + if m.AttachmentIDs == nil { + m.AttachmentIDs = []string{} + } + return &m, nil +} + +// ListMessages — keyset-пагинация по (created_at, id). +// Курсор — это id последнего элемента предыдущей страницы; сам id уникален, +// поэтому используем его для поиска (created_at, id) в БД. +func (s *Store) ListMessages(ctx context.Context, chatID string, limit int, cursor string) ([]Message, *string, error) { + var rows pgx.Rows + var err error + + if cursor == "" { + rows, err = s.pool.Query(ctx, + `SELECT id, chat_id, sender_id, text, created_at, attachment_ids + FROM messages + WHERE chat_id=$1 + ORDER BY created_at, id + LIMIT $2`, chatID, limit+1) + } else { + // Определяем позицию курсора. + var cCreated time.Time + if err := s.pool.QueryRow(ctx, + `SELECT created_at FROM messages WHERE id=$1 AND chat_id=$2`, + cursor, chatID, + ).Scan(&cCreated); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, ErrInvalid + } + return nil, nil, classifyDBError(err) + } + rows, err = s.pool.Query(ctx, + `SELECT id, chat_id, sender_id, text, created_at, attachment_ids + FROM messages + WHERE chat_id=$1 + AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT $4`, chatID, cCreated, cursor, limit+1) + } + if err != nil { + return nil, nil, classifyDBError(err) + } + defer rows.Close() + + var items []Message + for rows.Next() { + var m Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt, &m.AttachmentIDs); err != nil { + return nil, nil, classifyDBError(err) + } + if m.AttachmentIDs == nil { + m.AttachmentIDs = []string{} + } + items = append(items, m) + } + if err := rows.Err(); err != nil { + return nil, nil, classifyDBError(err) + } + + var next *string + if len(items) > limit { + items = items[:limit] + last := items[len(items)-1].ID + next = &last + } + if items == nil { + items = []Message{} + } + return items, next, nil +} + +func classifyDBError(err error) error { + if err == nil { + return nil + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + switch pgErr.Code { + case "57014": // query_canceled (statement_timeout) + return ErrTimeout + case "55P03": // lock_not_available (lock_timeout) + return ErrTimeout + case "40001": // serialization_failure + return ErrUnavailable + case "53300": // too_many_connections + return ErrUnavailable + case "22P02", "22007", "22023": // invalid_text_representation / invalid_datetime_format / invalid_parameter_value + return ErrInvalid + } + } + if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) { + return ErrTimeout + } + if errors.Is(err, pgx.ErrNoRows) { + return ErrNotFound + } + return err +} + +// AddMessageIdempotent — атомарно проверяет членство, вставляет сообщение +// и сохраняет результат идемпотентности в одной транзакции. +// Если ключ уже есть с тем же body — возвращает сохранённый ответ и replay=true. +func (s *Store) AddMessageIdempotent( + ctx context.Context, + chatID, senderID, text string, + attachmentIDs []string, + key, bodyHash string, +) (msg *Message, rec *IdempotencyRecord, replay bool, err error) { + path := "/api/v1/chats/" + chatID + "/messages" + + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.Serializable}) + if err != nil { + return nil, nil, false, classifyDBError(err) + } + defer tx.Rollback(ctx) + + // 1) Членство. + var ok bool + if err := tx.QueryRow(ctx, + `SELECT true FROM chat_members WHERE chat_id=$1 AND user_id=$2`, + chatID, senderID, + ).Scan(&ok); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, false, ErrNotFound + } + return nil, nil, false, classifyDBError(err) + } + + // Вложения должны принадлежать этому чату и быть ready. + if len(attachmentIDs) > 10 { + return nil, nil, false, ErrInvalid + } + seen := map[string]bool{} + for _, aid := range attachmentIDs { + if seen[aid] { + return nil, nil, false, ErrInvalid + } + seen[aid] = true + var ok bool + if err := tx.QueryRow(ctx, + `SELECT true FROM attachments WHERE id=$1 AND chat_id=$2 AND status='ready'`, + aid, chatID).Scan(&ok); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, false, ErrNotFound + } + return nil, nil, false, classifyDBError(err) + } + } + + // 2) Уже был такой ключ? + var storedHash string + var storedStatus int + var storedResp json.RawMessage + err = tx.QueryRow(ctx, + `SELECT request_hash, status_code, response + FROM idempotency_keys + WHERE user_id=$1 AND method='POST' AND path=$2 AND key=$3`, + senderID, path, key, + ).Scan(&storedHash, &storedStatus, &storedResp) + switch { + case err == nil: + if storedHash != bodyHash { + return nil, nil, false, ErrConflict + } + return nil, &IdempotencyRecord{StatusCode: storedStatus, Response: storedResp}, true, nil + case !errors.Is(err, pgx.ErrNoRows): + return nil, nil, false, classifyDBError(err) + } + + // 3) Вставка сообщения. + var m Message + var attach []string + err = tx.QueryRow(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids) + VALUES ($1,$2,$3,$4,$5) + RETURNING id, chat_id, sender_id, text, created_at, attachment_ids`, + uuid.NewString(), chatID, senderID, text, attachmentIDs, + ).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt, &attach) + if err != nil { + // Гонка на одном ключе в разных репликах: unique violation в idempotency_keys + // маловероятен здесь, но serialization failure возможен. + return nil, nil, false, classifyDBError(err) + } + m.AttachmentIDs = attach + if m.AttachmentIDs == nil { + m.AttachmentIDs = []string{} + } + + // 4) Сохранение ответа. + respJSON, _ := json.Marshal(m) + _, err = tx.Exec(ctx, + `INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, status_code, response) + VALUES ($1,'POST',$2,$3,$4,201,$5)`, + senderID, path, key, bodyHash, respJSON) + if err != nil { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { + // Кто-то параллельно успел вставить: перечитываем в этой же tx. + if err2 := tx.QueryRow(ctx, + `SELECT request_hash, status_code, response + FROM idempotency_keys + WHERE user_id=$1 AND method='POST' AND path=$2 AND key=$3`, + senderID, path, key, + ).Scan(&storedHash, &storedStatus, &storedResp); err2 == nil { + if storedHash != bodyHash { + return nil, nil, false, ErrConflict + } + return nil, &IdempotencyRecord{StatusCode: storedStatus, Response: storedResp}, true, nil + } + } + return nil, nil, false, classifyDBError(err) + } + + if err := tx.Commit(ctx); err != nil { + return nil, nil, false, classifyDBError(err) + } + return &m, nil, false, nil +} diff --git a/src/domain/s3.go b/src/domain/s3.go new file mode 100644 index 00000000..461c21fd --- /dev/null +++ b/src/domain/s3.go @@ -0,0 +1,213 @@ +package domain + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "hash" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "net" + "net/http" + "os" + "strings" + "time" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +type S3Store struct { + client *minio.Client + bucket string + maxBytes int64 + maxPixels int64 + tr *http.Transport +} + +func NewS3Store(ctx context.Context, endpoint, region, bucket, access, secret string, maxBytes, maxPixels int64) (*S3Store, error) { + if endpoint == "" || access == "" || secret == "" || bucket == "" { + return nil, errors.New("s3 configuration incomplete") + } + + tr := &http.Transport{ + MaxIdleConns: 100, + MaxIdleConnsPerHost: 100, + IdleConnTimeout: 30 * time.Second, + DialContext: (&net.Dialer{ + Timeout: 3 * time.Second, // Быстрый отказ при недоступности + KeepAlive: 30 * time.Second, + }).DialContext, + TLSHandshakeTimeout: 3 * time.Second, + ResponseHeaderTimeout: 5 * time.Second, + } + + cli, err := minio.New(endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(access, secret, ""), + Secure: strings.HasPrefix(endpoint, "https://"), + Region: region, + Transport: tr, + }) + if err != nil { + return nil, err + } + + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if _, err := cli.BucketExists(pingCtx, bucket); err != nil { + return nil, fmt.Errorf("s3 bucket check: %w", err) + } + return &S3Store{client: cli, bucket: bucket, maxBytes: maxBytes, maxPixels: maxPixels, tr: tr}, nil +} + +type UploadResult struct { + ObjectKey string + ContentType string + SizeBytes int64 + SHA256 string + Width int + Height int +} + +// PutValidatedImage читает тело потоково во временный файл на диске, +// проверяет размер, MIME, пиксели и затем стримит в S3. +// Это гарантирует, что память не растёт с размером файла. +func (s *S3Store) PutValidatedImage(ctx context.Context, objectKey string, body io.Reader) (*UploadResult, error) { + // 1. Создаём временный файл. + tmpFile, err := os.CreateTemp("", "upload-*") + if err != nil { + return nil, err + } + tmpPath := tmpFile.Name() + defer func() { + tmpFile.Close() + os.Remove(tmpPath) + }() + + // 2. Копируем тело в файл с ограничением. + limited := io.LimitReader(body, s.maxBytes+1) + size, err := io.Copy(tmpFile, limited) + if err != nil { + return nil, err + } + if size > s.maxBytes { + return nil, ErrTooLarge + } + if size == 0 { + return nil, ErrUnsupported + } + + // 3. Проверяем MIME по первым 512 байтам. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err + } + header := make([]byte, 512) + n, err := io.ReadFull(tmpFile, header) + if err != nil && err != io.ErrUnexpectedEOF && err != io.EOF { + return nil, err + } + header = header[:n] + ct := http.DetectContentType(header) + if ct != "image/png" && ct != "image/jpeg" { + return nil, ErrUnsupported + } + + // 4. Проверяем заголовок изображения (размеры). + // DecodeConfig читает только начало, но мы используем файл, поэтому это безопасно. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err + } + cfg, _, err := image.DecodeConfig(tmpFile) + if err != nil { + return nil, ErrNotImage + } + if int64(cfg.Width)*int64(cfg.Height) > s.maxPixels { + return nil, ErrNotImage + } + + // 5. Считаем SHA-256 и стримим файл в S3. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err + } + var hasher hash.Hash = sha256.New() + tee := io.TeeReader(tmpFile, hasher) + + putCtx, cancelPut := context.WithTimeout(ctx, 5*time.Second) + defer cancelPut() + + _, err = s.client.PutObject(putCtx, s.bucket, objectKey, tee, size, + minio.PutObjectOptions{ContentType: ct}) + if err != nil { + return nil, err + } + + sha := hex.EncodeToString(hasher.Sum(nil)) + + return &UploadResult{ + ObjectKey: objectKey, + ContentType: ct, + SizeBytes: size, + SHA256: sha, + Width: cfg.Width, + Height: cfg.Height, + }, nil +} + +func (s *S3Store) GetObject(ctx context.Context, objectKey string) (io.ReadCloser, string, int64, error) { + // Общий дедлайн на все попытки — 6 секунд. + overallCtx, overallCancel := context.WithTimeout(ctx, 6*time.Second) + defer overallCancel() + + var lastErr error + for attempt := 0; attempt < 2; attempt++ { + if attempt > 0 { + time.Sleep(500 * time.Millisecond) + s.tr.CloseIdleConnections() + } + + attemptCtx, cancel := context.WithTimeout(overallCtx, 3*time.Second) + obj, err := s.client.GetObject(attemptCtx, s.bucket, objectKey, minio.GetObjectOptions{}) + if err != nil { + cancel() + lastErr = err + continue + } + + info, err := obj.Stat() + if err != nil { + obj.Close() + cancel() + if minio.ToErrorResponse(err).Code == "NoSuchKey" { + return nil, "", 0, ErrNotFound + } + lastErr = err + continue + } + + data, err := io.ReadAll(obj) + obj.Close() + cancel() + if err != nil { + lastErr = err + continue + } + if int64(len(data)) != info.Size { + lastErr = fmt.Errorf("size mismatch: got %d, expected %d", len(data), info.Size) + continue + } + + return io.NopCloser(bytes.NewReader(data)), info.ContentType, info.Size, nil + } + + s.tr.CloseIdleConnections() + return nil, "", 0, fmt.Errorf("s3 get failed after retries: %w", lastErr) +} + +func (s *S3Store) DeleteObject(ctx context.Context, objectKey string) error { + return s.client.RemoveObject(ctx, s.bucket, objectKey, minio.RemoveObjectOptions{}) +} diff --git a/src/domain/sessions.go b/src/domain/sessions.go new file mode 100644 index 00000000..5eaf1786 --- /dev/null +++ b/src/domain/sessions.go @@ -0,0 +1,108 @@ +package domain + +import ( + "context" + "crypto/rand" + "encoding/base64" + "errors" + "time" + + "github.com/jackc/pgx/v5" +) + +type SessionStore struct { + store *Store + cache *SessionCache + ttl time.Duration +} + +func NewSessionStore(store *Store, cache *SessionCache, ttl time.Duration) *SessionStore { + return &SessionStore{store: store, cache: cache, ttl: ttl} +} + +func newToken() (string, error) { + b := make([]byte, 32) // 256 бит + if _, err := rand.Read(b); err != nil { + return "", classifyDBError(err) + } + return base64.RawURLEncoding.EncodeToString(b), nil +} + +// Create — пишем сессию в БД (источник истины) и кэшируем публичные данные User. +func (s *SessionStore) Create(ctx context.Context, user User) (*Session, error) { + token, err := newToken() + if err != nil { + return nil, classifyDBError(err) + } + expires := time.Now().UTC().Add(s.ttl) + if _, err := s.store.pool.Exec(ctx, + `INSERT INTO sessions (token, user_id, expires_at) VALUES ($1,$2,$3)`, + token, user.ID, expires); err != nil { + return nil, classifyDBError(err) + } + if s.cache != nil { + s.cache.SetUser(ctx, user.ID, user, expires) + } + return &Session{ + Token: token, + TokenType: "Bearer", + ExpiresAt: expires, + User: user, + }, nil +} + +// Lookup ВСЕГДА обращается к PostgreSQL за фактом существования сессии. +// Кэш используется только для публичных данных User. +func (s *SessionStore) Lookup(ctx context.Context, token string) (*User, error) { + var ( + userID string + expiresAt time.Time + ) + err := s.store.pool.QueryRow(ctx, + `SELECT user_id, expires_at FROM sessions WHERE token=$1`, token, + ).Scan(&userID, &expiresAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrUnauthorized + } + if err != nil { + return nil, classifyDBError(err) + } + if time.Now().UTC().After(expiresAt) { + _, _ = s.store.pool.Exec(ctx, `DELETE FROM sessions WHERE token=$1`, token) + return nil, ErrUnauthorized + } + + if s.cache != nil { + if u, ok := s.cache.GetUser(ctx, userID); ok { + return &u, nil + } + } + + u, err := s.store.GetUserByID(ctx, userID) + if err != nil { + return nil, ErrUnauthorized + } + if s.cache != nil { + s.cache.SetUser(ctx, userID, *u, expiresAt) + } + return u, nil +} + +func (s *SessionStore) Revoke(ctx context.Context, token string) error { + var userID string + err := s.store.pool.QueryRow(ctx, + `DELETE FROM sessions WHERE token=$1 RETURNING user_id`, token, + ).Scan(&userID) + if errors.Is(err, pgx.ErrNoRows) { + // Сессии уже нет — с точки зрения клиента токен отозван. + return nil + } + if err != nil { + return classifyDBError(err) + } + if s.cache != nil { + // Кэш User не критичен, но полезно сбросить. + _ = s.cache.DelUser(ctx, userID) + } + return nil +} -- 2.54.0 From 90f407b174bbfe95cbbb8cf9627b5e5305f094fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D1=8F=20=D0=9C=D0=BE=D1=80=D0=BE=D0=B7?= <145702378+MiniLynx13@users.noreply.github.com> Date: Mon, 16 Nov 2026 14:41:07 +0300 Subject: [PATCH 2/3] feat:level4 --- Dockerfile | 6 +- cmd/outbox/main.go | 160 +++++++++ cmd/worker/main.go | 212 ++++++++++++ cmd/worker/process.go | 123 +++++++ compose.yaml | 23 ++ go.mod | 9 +- go.sum | 14 +- migrations/0006_attachment_jobs.sql | 49 +++ src/api/handlers.go | 81 ++++- src/api/router.go | 1 + src/domain/attachment_states.go | 12 + src/domain/attachments.go | 493 +++++++++++++++++++++++++--- src/domain/broker.go | 80 +++++ src/domain/jobs.go | 13 + src/domain/models.go | 26 +- src/domain/s3.go | 45 +++ 16 files changed, 1270 insertions(+), 77 deletions(-) create mode 100644 cmd/outbox/main.go create mode 100644 cmd/worker/main.go create mode 100644 cmd/worker/process.go create mode 100644 migrations/0006_attachment_jobs.sql create mode 100644 src/domain/attachment_states.go create mode 100644 src/domain/broker.go create mode 100644 src/domain/jobs.go diff --git a/Dockerfile b/Dockerfile index 040241e0..4ee7b168 100644 --- a/Dockerfile +++ b/Dockerfile @@ -9,7 +9,9 @@ RUN go mod download COPY cmd ./cmd COPY src ./src -RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/messenger +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/messenger && \ + CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/outbox ./cmd/outbox && \ + CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/worker ./cmd/worker # --- runtime stage --- FROM alpine:3.20 @@ -18,6 +20,8 @@ RUN apk add --no-cache ca-certificates postgresql-client && \ WORKDIR /app COPY --from=build /out/messenger /app/messenger +COPY --from=build /out/worker /app/worker +COPY --from=build /out/outbox /app/outbox COPY migrations /app/migrations COPY scripts/migrate.sh /app/migrate.sh RUN chmod +x /app/migrate.sh diff --git a/cmd/outbox/main.go b/cmd/outbox/main.go new file mode 100644 index 00000000..ff1bf518 --- /dev/null +++ b/cmd/outbox/main.go @@ -0,0 +1,160 @@ +package main + +import ( + "context" + "errors" + "log" + "os" + "os/signal" + "syscall" + "time" + + "mtusi-messenger/src/config" + "mtusi-messenger/src/domain" +) + +const ( + publishInterval = 1 * time.Second + reapInterval = 30 * time.Second + publishBatch = 50 +) + +func main() { + cfg := config.Load() + if cfg.DatabaseURL == "" { + log.Fatal("DATABASE_URL is required (env DATABASE_URL or DATABASE_URL_FILE)") + } + if cfg.CacheURL == "" { + log.Fatal("CACHE_URL is required (env CACHE_URL or CACHE_URL_FILE)") + } + + rootCtx, cancelRoot := context.WithCancel(context.Background()) + defer cancelRoot() + + store, err := domain.NewStore(rootCtx, cfg.DatabaseURL) + if err != nil { + log.Fatalf("postgres: %v", err) + } + defer store.Close() + + broker, err := domain.NewBroker(rootCtx, cfg.CacheURL) + if err != nil { + log.Fatalf("broker: %v", err) + } + + s3, err := domain.NewS3Store(rootCtx, cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, + cfg.S3AccessKeyID, cfg.S3SecretKey, cfg.MaxUploadBytes, cfg.MaxImagePixels) + if err != nil { + log.Fatalf("s3: %v", err) + } + + go gcLoop(rootCtx, store, s3, cfg.S3GCGrace) + + // Reaper зависших processing крутится здесь, потому что outbox уже + // держит соединение с БД и Redis и запускается в единственном экземпляре. + go reaperLoop(rootCtx, store) + + stop := make(chan os.Signal, 1) + signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) + + go func() { + <-stop + log.Println("outbox: shutting down") + cancelRoot() + }() + + ticker := time.NewTicker(publishInterval) + defer ticker.Stop() + + log.Printf("outbox: running (interval=%s batch=%d)", publishInterval, publishBatch) + for { + select { + case <-rootCtx.Done(): + log.Println("outbox: stopped") + return + case <-ticker.C: + if err := publishBatchOnce(rootCtx, store, broker); err != nil { + log.Printf("outbox: publish: %v", err) + } + } + } +} + +// publishBatchOnce: выбираем партию неопубликованных job-ов, публикуем +// по одному, после XADD — MarkPublished. Падение между XADD и MarkPublished +// приведёт к повторной публикации при следующем цикле; worker идемпотентен +// (ключ эффекта — (attachment_id, pipeline_version, variant)), поэтому +// дубль в Streams — норма, а не баг. +func publishBatchOnce(ctx context.Context, store *domain.Store, broker *domain.Broker) error { + jobs, err := store.SelectUnpublishedJobs(ctx, publishBatch) + if err != nil { + return err + } + if len(jobs) == 0 { + return nil + } + + for _, j := range jobs { + if ctx.Err() != nil { + return ctx.Err() + } + msg := domain.JobMessage{ + SchemaVersion: 1, + JobID: j.JobID, + Type: "attachment.process.v1", + AttachmentID: j.AttachmentID, + PipelineVersion: j.PipelineVersion, + Attempt: j.Attempt, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + } + if _, err := broker.Publish(ctx, msg); err != nil { + if errors.Is(err, context.Canceled) { + return err + } + // Не фатально: попробуем в следующем цикле, зафиксировав причину. + _ = store.BumpPublishAttempt(ctx, j.JobID, "publish_failed") + log.Printf("outbox: publish job=%s attachment=%s: %v", + j.JobID, j.AttachmentID, err) + continue + } + if err := store.MarkPublished(ctx, j.JobID); err != nil { + log.Printf("outbox: mark published job=%s: %v", j.JobID, err) + } + } + return nil +} + +func reaperLoop(ctx context.Context, store *domain.Store) { + t := time.NewTicker(reapInterval) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return + case <-t.C: + n, err := store.RequeueStuck(ctx) + if err != nil { + log.Printf("outbox: reaper: %v", err) + continue + } + if n > 0 { + log.Printf("outbox: reaper requeued %d stuck job(s)", n) + } + } + } +} + +func gcLoop(ctx context.Context, store *domain.Store, s3 *domain.S3Store, grace time.Duration) { + t := time.NewTicker(2 * time.Minute) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return + case <-t.C: + if err := store.ReconcileOrphans(ctx, s3, grace); err != nil { + log.Printf("outbox: gc: %v", err) + } + } + } +} diff --git a/cmd/worker/main.go b/cmd/worker/main.go new file mode 100644 index 00000000..25e961d6 --- /dev/null +++ b/cmd/worker/main.go @@ -0,0 +1,212 @@ +package main + +import ( + "context" + "encoding/json" + "errors" + "log" + "os" + "os/signal" + "syscall" + "time" + + "mtusi-messenger/src/config" + "mtusi-messenger/src/domain" + + "github.com/redis/go-redis/v9" +) + +const ( + lease = 60 * time.Second + maxAttempts = 5 + baseBackoff = 2 * time.Second +) + +func main() { + cfg := config.Load() + if cfg.CacheURL == "" { + log.Fatal("CACHE_URL (redis) is required for broker") + } + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + store, err := domain.NewStore(ctx, cfg.DatabaseURL) + if err != nil { + log.Fatalf("db: %v", err) + } + defer store.Close() + + s3, err := domain.NewS3Store(ctx, cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, + cfg.S3AccessKeyID, cfg.S3SecretKey, cfg.MaxUploadBytes, cfg.MaxImagePixels) + if err != nil { + log.Fatalf("s3: %v", err) + } + + broker, err := domain.NewBroker(ctx, cfg.CacheURL) + if err != nil { + log.Fatalf("broker: %v", err) + } + + consumer := cfg.InstanceID + "-worker" + + go reaperLoop(ctx, store) + + stop := make(chan os.Signal, 1) + signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) + go func() { + <-stop + log.Println("worker shutting down") + cancel() + }() + + for ctx.Err() == nil { + msgs, err := broker.Consume(ctx, consumer) + if err != nil { + if ctx.Err() != nil { + return + } + log.Printf("consume: %v", err) + time.Sleep(time.Second) + continue + } + for _, m := range msgs { + handleOne(ctx, store, s3, broker, m) + } + } +} + +func reaperLoop(ctx context.Context, store *domain.Store) { + t := time.NewTicker(30 * time.Second) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return + case <-t.C: + if n, err := store.RequeueStuck(ctx); err != nil { + log.Printf("reaper: %v", err) + } else if n > 0 { + log.Printf("reaper: requeued %d stuck job(s)", n) + } + } + } +} + +func handleOne(ctx context.Context, store *domain.Store, s3 *domain.S3Store, + broker *domain.Broker, m redis.XMessage) { + + var job domain.JobMessage + if raw, ok := m.Values["payload"].(string); ok { + _ = json.Unmarshal([]byte(raw), &job) + } else if raw, ok := m.Values["payload"].([]byte); ok { + _ = json.Unmarshal(raw, &job) + } else { + _ = broker.Ack(ctx, m.ID) + return + } + + // Валидация схемы (обязательные поля). + if job.SchemaVersion != 1 || job.Type != "attachment.process.v1" || + job.JobID == "" || job.AttachmentID == "" { + log.Printf("poison message %s, acking", m.ID) + _ = broker.Ack(ctx, m.ID) + return + } + + // No-op для уже готового результата (redelivery после готовности). + if done, _ := store.VariantsExist(ctx, job.AttachmentID, job.PipelineVersion); done { + _ = broker.Ack(ctx, m.ID) + return + } + + j, err := store.ClaimJobByID(ctx, job.JobID, workerID(), lease) + if errors.Is(err, domain.ErrNotFound) { + // Уже done/failed или lease держит кто-то другой — ack, не дублируем. + _ = broker.Ack(ctx, m.ID) + return + } + if err != nil { + log.Printf("claim: %v", err) + return + } + + stagingKey, _, err := store.GetStagingKey(ctx, j.AttachmentID) + if err != nil { + log.Printf("staging key: %v", err) + return + } + + raw, ct, err := s3.FetchStagingForProcessing(ctx, stagingKey) + if err != nil { + code, permanent := classify(err) + if permanent { + // постоянная ошибка — failed без retry + _ = store.MarkFailedPermanent(ctx, j.JobID, j.AttachmentID, code) + } else { + _, _ = store.RetryJob(ctx, j.JobID, code, maxAttempts, baseBackoff) + } + _ = broker.Ack(ctx, m.ID) + return + } + + variants, err := processImage(raw, ct) + if err != nil { + // decode error — постоянная + _ = store.MarkFailedPermanent(ctx, j.JobID, j.AttachmentID, "invalid_image") + _ = broker.Ack(ctx, m.ID) + return + } + + finalOriginalKey := "final/" + j.AttachmentID + "/original" + var vrows []domain.Variant + for _, v := range variants { + if v.Name == "original" { + // оригинал перекладываем из staging server-side. + if err := s3.MoveToFinal(ctx, stagingKey, finalOriginalKey); err != nil { + _, _ = store.RetryJob(ctx, j.JobID, "storage_error", maxAttempts, baseBackoff) + _ = broker.Ack(ctx, m.ID) + return + } + } else { + sum, err := s3.PutBytes(ctx, finalOriginalKey, v.ContentType, v.Data) + if err != nil { + _, _ = store.RetryJob(ctx, j.JobID, "storage_error", maxAttempts, baseBackoff) + _ = broker.Ack(ctx, m.ID) + return + } + v.SHA256 = sum + } + vrows = append(vrows, domain.Variant{ + Name: v.Name, ContentType: v.ContentType, SizeBytes: int64(len(v.Data)), + Width: v.Width, Height: v.Height, SHA256: v.SHA256, + }) + } + + if err := store.MarkReady(ctx, j.JobID, j.AttachmentID, j.PipelineVersion, finalOriginalKey, vrows); err != nil { + // Уже done — не страшно; иначе retry. + if !errors.Is(err, domain.ErrConflict) { + log.Printf("mark ready: %v", err) + } + _ = broker.Ack(ctx, m.ID) + return + } + _ = broker.Ack(ctx, m.ID) +} + +func workerID() string { + h, _ := os.Hostname() + return h + "-" + time.Now().Format("150405") +} + +func classify(err error) (string, bool) { + switch { + case errors.Is(err, domain.ErrTooLarge): + return "payload_too_large", true + case errors.Is(err, domain.ErrUnsupported): + return "unsupported_media_type", true + case errors.Is(err, domain.ErrNotImage): + return "invalid_image", true + default: + return "storage_error", false + } +} diff --git a/cmd/worker/process.go b/cmd/worker/process.go new file mode 100644 index 00000000..58a05293 --- /dev/null +++ b/cmd/worker/process.go @@ -0,0 +1,123 @@ +package main + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "image" + "image/jpeg" + + "golang.org/x/image/draw" +) + +type VariantSpec struct { + Name string + ContentType string + Width int + Height int + Data []byte + SHA256 string +} + +func encodeOptimizedJPEG(src image.Image, quality int) ([]byte, error) { + var buf bytes.Buffer + if err := jpeg.Encode(&buf, src, &jpeg.Options{Quality: quality}); err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// processImage возвращает 4 варианта. Оригинал — byte-identical с входом. +// thumbnail 256x256 (fit, без искажения), crop 128x128 (center crop), +// optimized — WebP q=80 без метаданных. +func processImage(raw []byte, contentType string) ([]VariantSpec, error) { + src, _, err := image.Decode(bytes.NewReader(raw)) + if err != nil { + return nil, err + } + + out := make([]VariantSpec, 0, 4) + + // original — ровно те байты, что пришли в staging. + sum := sha256.Sum256(raw) + out = append(out, VariantSpec{ + Name: "original", ContentType: contentType, + Width: src.Bounds().Dx(), Height: src.Bounds().Dy(), + Data: raw, SHA256: hex.EncodeToString(sum[:]), + }) + + // thumbnail 256x256 (fit). + th := resizeFit(src, 256, 256) + if err := appendEncoded(&out, "thumbnail", "image/jpeg", th); err != nil { + return nil, err + } + + // crop 128x128 (center crop). + cr := centerCrop(src, 128, 128) + if err := appendEncoded(&out, "crop", "image/jpeg", cr); err != nil { + return nil, err + } + + // optimized + optBuf, err := encodeOptimizedJPEG(src, 70) + if err != nil { + return nil, err + } + optSum := sha256.Sum256(optBuf) + out = append(out, VariantSpec{ + Name: "optimized", ContentType: "image/jpeg", + Width: src.Bounds().Dx(), Height: src.Bounds().Dy(), + Data: optBuf, SHA256: hex.EncodeToString(optSum[:]), + }) + return out, nil +} + +func appendEncoded(out *[]VariantSpec, name, ct string, img image.Image) error { + var buf bytes.Buffer + if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 85}); err != nil { + return err + } + sum := sha256.Sum256(buf.Bytes()) + *out = append(*out, VariantSpec{ + Name: name, ContentType: ct, + Width: img.Bounds().Dx(), Height: img.Bounds().Dy(), + Data: buf.Bytes(), SHA256: hex.EncodeToString(sum[:]), + }) + return nil +} + +func resizeFit(src image.Image, maxW, maxH int) image.Image { + b := src.Bounds() + w, h := b.Dx(), b.Dy() + scale := float64(maxW) / float64(w) + if float64(maxH)/float64(h) < scale { + scale = float64(maxH) / float64(h) + } + if scale > 1 { + scale = 1 + } + nw, nh := int(float64(w)*scale), int(float64(h)*scale) + dst := image.NewRGBA(image.Rect(0, 0, nw, nh)) + draw.CatmullRom.Scale(dst, dst.Bounds(), src, b, draw.Over, nil) + return dst +} + +func centerCrop(src image.Image, w, h int) image.Image { + b := src.Bounds() + sw, sh := b.Dx(), b.Dy() + cw, ch := w, h + if sw < cw { + cw = sw + } + if sh < ch { + ch = sh + } + x0 := (sw - cw) / 2 + y0 := (sh - ch) / 2 + dst := image.NewRGBA(image.Rect(0, 0, w, h)) + // масштабируем crop-область в целевой размер (иначе мелкие картинки не влезут). + draw.CatmullRom.Scale(dst, dst.Bounds(), + src, image.Rect(b.Min.X+x0, b.Min.Y+y0, b.Min.X+x0+cw, b.Min.Y+y0+ch), + draw.Over, nil) + return dst +} diff --git a/compose.yaml b/compose.yaml index eb616c89..4b4939a1 100644 --- a/compose.yaml +++ b/compose.yaml @@ -91,6 +91,29 @@ services: limits: cpus: "${API_CPU_PER_REPLICA:-0.5}" memory: "${API_MEM_PER_REPLICA:-128M}" + + outbox: + <<: *api + entrypoint: ["/app/outbox"] + depends_on: + postgres: { condition: service_healthy } + redis: { condition: service_healthy } + deploy: + replicas: 1 + resources: + limits: { cpus: "0.2", memory: "64M" } + + worker: + <<: *api + entrypoint: ["/app/worker"] + depends_on: + postgres: { condition: service_healthy } + redis: { condition: service_healthy } + s3: { condition: service_healthy } + deploy: + replicas: 2 + resources: + limits: { cpus: "0.5", memory: "256M" } migrate: <<: *api diff --git a/go.mod b/go.mod index ce04daa2..51361002 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module mtusi-messenger -go 1.22 +go 1.26.0 require ( github.com/google/uuid v1.6.0 @@ -8,6 +8,7 @@ require ( github.com/minio/minio-go/v7 v7.0.72 github.com/redis/go-redis/v9 v9.5.1 golang.org/x/crypto v0.23.0 + golang.org/x/image v0.48.0 ) require ( @@ -23,8 +24,8 @@ require ( github.com/minio/md5-simd v1.1.2 // indirect github.com/rs/xid v1.5.0 // indirect golang.org/x/net v0.23.0 // indirect - golang.org/x/sync v0.1.0 // indirect - golang.org/x/sys v0.20.0 // indirect - golang.org/x/text v0.15.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 gopkg.in/ini.v1 v1.67.0 // indirect ) diff --git a/go.sum b/go.sum index 9a1cd55c..8c1b4c29 100644 --- a/go.sum +++ b/go.sum @@ -45,15 +45,17 @@ github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKs github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +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/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +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.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= -golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= -golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +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.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/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= diff --git a/migrations/0006_attachment_jobs.sql b/migrations/0006_attachment_jobs.sql new file mode 100644 index 00000000..bbf60e53 --- /dev/null +++ b/migrations/0006_attachment_jobs.sql @@ -0,0 +1,49 @@ +-- staging → final prefix; job-очередь и lease +ALTER TABLE attachments + ADD COLUMN IF NOT EXISTS pipeline_version integer NOT NULL DEFAULT 1, + ADD COLUMN IF NOT EXISTS staging_key text, + ADD COLUMN IF NOT EXISTS ready_at timestamptz, + ADD COLUMN IF NOT EXISTS failed_at timestamptz, + ADD COLUMN IF NOT EXISTS error_code text; + +-- idempotency эффекта: (attachment_id, pipeline_version, variant) +CREATE TABLE IF NOT EXISTS attachment_variants ( + attachment_id uuid NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, + pipeline_version integer NOT NULL, + variant text NOT NULL, + object_key text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + width int NOT NULL, + height int NOT NULL, + sha256 char(64) NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (attachment_id, pipeline_version, variant) +); + +-- outbox + очередь job-ов +CREATE TABLE IF NOT EXISTS attachment_jobs ( + job_id uuid PRIMARY KEY, + attachment_id uuid NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, + pipeline_version integer NOT NULL, + attempt int NOT NULL DEFAULT 1, + status text NOT NULL DEFAULT 'queued', -- queued|processing|done|failed + -- outbox + published_at timestamptz, + publish_attempts int NOT NULL DEFAULT 0, + -- lease + lease_owner text, + lease_expires_at timestamptz, + -- retry + next_attempt_at timestamptz NOT NULL DEFAULT now(), + last_error_code text, + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now(), + UNIQUE (attachment_id, pipeline_version) -- одна логическая работа на версию +); +CREATE INDEX IF NOT EXISTS idx_attachment_jobs_unpublished + ON attachment_jobs (next_attempt_at) + WHERE published_at IS NULL AND status = 'queued'; +CREATE INDEX IF NOT EXISTS idx_attachment_jobs_lease + ON attachment_jobs (lease_expires_at) + WHERE status = 'processing'; \ No newline at end of file diff --git a/src/api/handlers.go b/src/api/handlers.go index eee49f6d..640f47b9 100644 --- a/src/api/handlers.go +++ b/src/api/handlers.go @@ -419,6 +419,19 @@ func safeFilename(name string) (string, bool) { return name, true } +func errorCodeFor(err error) string { + switch { + case errors.Is(err, domain.ErrTooLarge): + return "payload_too_large" + case errors.Is(err, domain.ErrUnsupported): + return "unsupported_media_type" + case errors.Is(err, domain.ErrNotImage): + return "invalid_image" + default: + return "storage_error" + } +} + func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { me, _ := userFrom(r) @@ -442,17 +455,18 @@ func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { return } - objectKey := "attachments/" + chatID + "/" + uuid.NewString() - pendingID, err := h.Store.CreateAttachmentPending(r.Context(), chatID, me.ID, objectKey, filename) + stagingKey := domain.StagingPrefix + chatID + "/" + uuid.NewString() + pendingID, err := h.Store.CreateAttachmentPending( + r.Context(), chatID, me.ID, stagingKey, filename) if err != nil { writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") return } - res, err := h.S3.PutValidatedImage(r.Context(), objectKey, r.Body) + res, err := h.S3.PutValidatedImage(r.Context(), stagingKey, r.Body) if err != nil { - _ = h.Store.MarkAttachmentFailed(r.Context(), pendingID, err.Error()) - _ = h.Store.ScheduleObjectGC(r.Context(), objectKey, "upload_failed") + _ = h.Store.MarkAttachmentFailed(r.Context(), pendingID, errorCodeFor(err)) + _ = h.Store.ScheduleObjectGC(r.Context(), stagingKey, "upload_failed") switch { case errors.Is(err, domain.ErrTooLarge): writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file too large") @@ -466,21 +480,24 @@ func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { return } - att, err := h.Store.FinalizeAttachment(r.Context(), pendingID, res.ContentType, res.SizeBytes, res.SHA256, res.Width, res.Height) + // Атомарно: attachment queued + outbox-строка. 202 только после COMMIT. + att, err := h.Store.EnqueueAttachment( + r.Context(), pendingID, res.ContentType, res.SizeBytes, res.SHA256, + res.Width, res.Height, domain.PipelineVersion) if err != nil { - // S3 PUT прошёл, COMMIT — нет: объект в GC. - _ = h.Store.ScheduleObjectGC(r.Context(), objectKey, "finalize_failed") + _ = h.Store.ScheduleObjectGC(r.Context(), stagingKey, "enqueue_failed") writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") return } - writeJSON(w, http.StatusCreated, att) + writeJSON(w, http.StatusAccepted, att) })(w, r) } func (h *Handler) GetAttachment(w http.ResponseWriter, r *http.Request) { h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { me, _ := userFrom(r) - att, err := h.Store.GetAttachmentForUser(r.Context(), r.PathValue("attachment_id"), me.ID) + id := r.PathValue("attachment_id") + att, err := h.Store.GetAttachmentForUser(r.Context(), id, me.ID) switch { case err == nil: writeJSON(w, http.StatusOK, att) @@ -505,7 +522,27 @@ func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") return } - key, err := h.Store.GetAttachmentObjectKey(r.Context(), att.ID) + switch att.Status { + case domain.AttachmentReady: + // ok + case domain.AttachmentFailed: + writeError(w, r, http.StatusConflict, "conflict", "attachment failed") + return + default: + writeError(w, r, http.StatusConflict, "conflict", "attachment not ready") + return + } + + variant := r.URL.Query().Get("variant") + if variant == "" { + variant = "original" + } + var key string + if variant == "original" { + key, err = h.Store.GetAttachmentObjectKey(r.Context(), att.ID) + } else { + key, _, err = h.Store.GetVariantKey(r.Context(), att.ID, att.PipelineVersion, variant) + } if err != nil { writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") return @@ -535,3 +572,25 @@ func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { } })(w, r) } + +func (h *Handler) ReplayAttachment(w http.ResponseWriter, r *http.Request) { + h.bearerAuth(func(w http.ResponseWriter, r *http.Request) { + // Только owner или участник чата; упрощённо — участник чата. + me, _ := userFrom(r) + id := r.PathValue("attachment_id") + if _, err := h.Store.GetAttachmentForUser(r.Context(), id, me.ID); err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") + return + } + err := h.Store.ReplayFailed(r.Context(), id) + if errors.Is(err, domain.ErrConflict) { + writeError(w, r, http.StatusConflict, "conflict", "not in failed state") + return + } + if err != nil { + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + return + } + w.WriteHeader(http.StatusAccepted) + })(w, r) +} diff --git a/src/api/router.go b/src/api/router.go index d5f9b317..f82af911 100644 --- a/src/api/router.go +++ b/src/api/router.go @@ -18,6 +18,7 @@ func NewRouter(h *Handler, instanceID string) http.Handler { mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", h.UploadAttachment) mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", h.GetAttachment) mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", h.DownloadAttachment) + mux.HandleFunc("POST /api/v1/attachments/{attachment_id}/replay", h.ReplayAttachment) // Порядок: instanceID снаружи, requestID внутри. return withInstanceID(instanceID)(withRequestID(mux)) diff --git a/src/domain/attachment_states.go b/src/domain/attachment_states.go new file mode 100644 index 00000000..17189f6e --- /dev/null +++ b/src/domain/attachment_states.go @@ -0,0 +1,12 @@ +package domain + +const ( + AttachmentQueued = "queued" + AttachmentProcessing = "processing" + AttachmentReady = "ready" + AttachmentFailed = "failed" +) + +const PipelineVersion = 1 + +var RequiredVariants = []string{"original", "thumbnail", "crop", "optimized"} diff --git a/src/domain/attachments.go b/src/domain/attachments.go index 0a724bda..c3094ec4 100644 --- a/src/domain/attachments.go +++ b/src/domain/attachments.go @@ -3,6 +3,7 @@ package domain import ( "context" "errors" + "math/rand" "time" "github.com/google/uuid" @@ -11,57 +12,25 @@ import ( // CreateAttachmentPending резервирует строку ДО записи в S3. // Это даёт точку компенсации: если S3 PUT упал, строка снимается/чистится. -func (s *Store) CreateAttachmentPending(ctx context.Context, chatID, ownerID, objectKey, filename string) (string, error) { +func (s *Store) CreateAttachmentPending(ctx context.Context, chatID, ownerID, stagingKey, filename string) (string, error) { id := uuid.NewString() _, err := s.pool.Exec(ctx, - `INSERT INTO attachments (id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, width, height, status) - VALUES ($1,$2,$3,$4,$5,'image/png',1,repeat('0',64),1,1,'pending')`, - id, chatID, ownerID, objectKey, filename) + `INSERT INTO attachments (id, chat_id, owner_id, object_key, staging_key, filename, + content_type, size_bytes, sha256, width, height, + pipeline_version, status) + VALUES ($1,$2,$3,$4,$4,$5,'application/octet-stream',0,repeat('0',64),0,0,1,'queued')`, + id, chatID, ownerID, stagingKey, filename) if err != nil { return "", classifyDBError(err) } return id, nil } -// FinalizeAttachment атомарно переводит pending→ready с реальными метаданными. -func (s *Store) FinalizeAttachment(ctx context.Context, id, contentType string, size int64, sha string, w, h int) (*Attachment, error) { - tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) - if err != nil { - return nil, classifyDBError(err) - } - defer tx.Rollback(ctx) - - var a Attachment - var errCode *string - err = tx.QueryRow(ctx, - `UPDATE attachments - SET content_type=$2, size_bytes=$3, sha256=$4, width=$5, height=$6, - status='ready', error_code=NULL, updated_at=now() - WHERE id=$1 AND status='pending' - RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, - status, error_code, created_at, updated_at`, - id, contentType, size, sha, w, h, - ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, - &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt) - if errors.Is(err, pgx.ErrNoRows) { - return nil, ErrNotFound - } - if err != nil { - return nil, classifyDBError(err) - } - a.ErrorCode = errCode - a.Variants = []Variant{} - if err := tx.Commit(ctx); err != nil { - return nil, classifyDBError(err) - } - return &a, nil -} - // MarkAttachmentFailed помечает pending как failed (компенсация). func (s *Store) MarkAttachmentFailed(ctx context.Context, id, code string) error { _, err := s.pool.Exec(ctx, `UPDATE attachments SET status='failed', error_code=$2, updated_at=now() - WHERE id=$1 AND status='pending'`, id, code) + WHERE id=$1 AND status='queued'`, id, code) return classifyDBError(err) } @@ -79,10 +48,10 @@ func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (*A var errCode *string err := s.pool.QueryRow(ctx, ` SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, - a.status, a.error_code, a.created_at, a.updated_at + a.status, a.error_code, a.created_at, a.updated_at, a.pipeline_version FROM attachments a JOIN chat_members m ON m.chat_id = a.chat_id - WHERE a.id=$1 AND m.user_id=$2 AND a.status='ready'`, id, userID, + WHERE a.id=$1 AND m.user_id=$2`, id, userID, ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt) if errors.Is(err, pgx.ErrNoRows) { @@ -93,6 +62,27 @@ func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (*A } a.ErrorCode = errCode a.Variants = []Variant{} + rows, err := s.pool.Query(ctx, + `SELECT variant, content_type, size_bytes, width, height, sha256, object_key + FROM attachment_variants + WHERE attachment_id=$1 AND pipeline_version=$2 + ORDER BY variant`, + a.ID, a.PipelineVersion) + if err != nil { + return nil, classifyDBError(err) + } + defer rows.Close() + for rows.Next() { + var v Variant + if err := rows.Scan(&v.Name, &v.ContentType, &v.SizeBytes, + &v.Width, &v.Height, &v.SHA256, &v.ObjectKey); err != nil { + return nil, classifyDBError(err) + } + a.Variants = append(a.Variants, v) + } + if err := rows.Err(); err != nil { + return nil, classifyDBError(err) + } return &a, nil } @@ -164,8 +154,10 @@ func (s *Store) ReconcileOrphans(ctx context.Context, s3 *S3Store, grace time.Du // 2) pending-записи старше grace: объект мог попасть в S3, а commit — нет. prow, err := s.pool.Query(ctx, - `SELECT id, object_key FROM attachments - WHERE status='pending' AND created_at < now() - $1::interval LIMIT 100`, + `SELECT a.id, a.staging_key FROM attachments a + LEFT JOIN attachment_jobs j ON j.attachment_id = a.id + WHERE a.status='queued' AND j.job_id IS NULL + AND a.created_at < now() - $1::interval LIMIT 100`, grace.String()) if err != nil { return classifyDBError(err) @@ -187,3 +179,418 @@ func (s *Store) ReconcileOrphans(ctx context.Context, s3 *S3Store, grace time.Du } return nil } + +// EnqueueAttachment: атомарно фиксируем метаданные приёма и кладём outbox-строку. +// 202 отвечаем только после успешного COMMIT этой транзакции. +func (s *Store) EnqueueAttachment( + ctx context.Context, attachmentID, contentType string, + size int64, sha string, w, h int, pipelineVersion int, +) (*Attachment, error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var a Attachment + err = tx.QueryRow(ctx, ` + UPDATE attachments + SET content_type=$2, size_bytes=$3, sha256=$4, width=$5, height=$6, + pipeline_version=$7, status='queued', updated_at=now() + WHERE id=$1 AND status='queued' + RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + status, error_code, created_at, updated_at`, + attachmentID, contentType, size, sha, w, h, pipelineVersion, + ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, + &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + + if _, err := tx.Exec(ctx, ` + INSERT INTO attachment_jobs + (job_id, attachment_id, pipeline_version, status, next_attempt_at) + VALUES ($1,$2,$3,'queued', now())`, + uuid.NewString(), attachmentID, pipelineVersion, + ); err != nil { + return nil, classifyDBError(err) + } + + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + a.Variants = []Variant{} + return &a, nil +} + +// ClaimJob — берём одну доступную задачу под lease. +// Работает и для queued, и для протухшего processing (reaper тем же запросом). +func (s *Store) ClaimJob(ctx context.Context, workerID string, lease time.Duration) (*Job, error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var j Job + err = tx.QueryRow(ctx, ` + WITH picked AS ( + SELECT job_id FROM attachment_jobs + WHERE status IN ('queued','processing') + AND next_attempt_at <= now() + AND (status='queued' OR lease_expires_at < now()) + ORDER BY next_attempt_at + LIMIT 1 + FOR UPDATE SKIP LOCKED + ) + UPDATE attachment_jobs aj + SET status='processing', + lease_owner=$1, + lease_expires_at = now() + $2::interval, + updated_at = now() + FROM picked + WHERE aj.job_id = picked.job_id + RETURNING aj.job_id, aj.attachment_id, aj.pipeline_version, + aj.attempt, aj.status, aj.next_attempt_at, aj.last_error_code`, + workerID, lease.String(), + ).Scan(&j.JobID, &j.AttachmentID, &j.PipelineVersion, &j.Attempt, &j.Status, + &j.NextAttemptAt, &j.LastError) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + return &j, nil +} + +// MarkReady: атомарно пишем все варианты (идемпотентно по ключу) и завершаем job. +// Конкурентная попытка не перезапишет существующий вариант — ON CONFLICT DO NOTHING. +func (s *Store) MarkReady( + ctx context.Context, jobID, attachmentID string, pipelineVersion int, + finalOriginalKey string, variants []Variant, +) error { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.Serializable}) + if err != nil { + return classifyDBError(err) + } + defer tx.Rollback(ctx) + + // Если job уже done — no-op (redelivery после ack). + var status string + err = tx.QueryRow(ctx, + `SELECT status FROM attachment_jobs WHERE job_id=$1 FOR UPDATE`, jobID, + ).Scan(&status) + if errors.Is(err, pgx.ErrNoRows) { + return ErrNotFound + } + if err != nil { + return classifyDBError(err) + } + if status == "done" { + return tx.Commit(ctx) + } + if status == "failed" { + return ErrConflict // нельзя откатывать failed→ready; см. replay + } + + // Записать оригинал в final prefix. + if _, err := tx.Exec(ctx, + `UPDATE attachments + SET object_key=$2, status='ready', ready_at=now(), updated_at=now() + WHERE id=$1 AND pipeline_version=$3`, + attachmentID, finalOriginalKey, pipelineVersion, + ); err != nil { + return classifyDBError(err) + } + + for _, v := range variants { + if _, err := tx.Exec(ctx, ` + INSERT INTO attachment_variants + (attachment_id, pipeline_version, variant, object_key, + content_type, size_bytes, width, height, sha256) + VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) + ON CONFLICT (attachment_id, pipeline_version, variant) DO NOTHING`, + attachmentID, pipelineVersion, v.Name, "final/"+attachmentID+"/"+v.Name, + v.ContentType, v.SizeBytes, v.Width, v.Height, v.SHA256, + ); err != nil { + return classifyDBError(err) + } + } + + if _, err := tx.Exec(ctx, + `UPDATE attachment_jobs + SET status='done', lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE job_id=$1`, jobID, + ); err != nil { + return classifyDBError(err) + } + return tx.Commit(ctx) +} + +// RetryJob: временная ошибка — вернуть в очередь с backoff+jitter. +// exhausted=true — если попытки кончились. +func (s *Store) RetryJob( + ctx context.Context, jobID string, errorCode string, + maxAttempts int, baseBackoff time.Duration, +) (exhausted bool, err error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return false, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var attempt int + var attachmentID string + err = tx.QueryRow(ctx, + `SELECT attempt, attachment_id FROM attachment_jobs + WHERE job_id=$1 FOR UPDATE`, jobID, + ).Scan(&attempt, &attachmentID) + if err != nil { + return false, classifyDBError(err) + } + + if attempt >= maxAttempts { + if _, err := tx.Exec(ctx, ` + UPDATE attachment_jobs + SET status='failed', last_error_code=$2, + lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE job_id=$1`, jobID, errorCode); err != nil { + return false, classifyDBError(err) + } + if _, err := tx.Exec(ctx, ` + UPDATE attachments SET status='failed', failed_at=now(), + error_code=$2, updated_at=now() + WHERE id=$1`, attachmentID, errorCode); err != nil { + return false, classifyDBError(err) + } + if err := tx.Commit(ctx); err != nil { + return false, classifyDBError(err) + } + return true, nil + } + + // backoff: base * 2^(attempt-1) + jitter + backoff := baseBackoff * time.Duration(1<<(attempt-1)) + jitter := time.Duration(rand.Int63n(int64(backoff / 4))) + next := time.Now().Add(backoff + jitter) + + if _, err := tx.Exec(ctx, ` + UPDATE attachment_jobs + SET attempt = attempt + 1, + status = 'queued', + last_error_code=$2, + next_attempt_at=$3, + lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE job_id=$1`, jobID, errorCode, next); err != nil { + return false, classifyDBError(err) + } + if err := tx.Commit(ctx); err != nil { + return false, classifyDBError(err) + } + return false, nil +} + +// RequeueStuck — reaper: обрабатывается отдельным тикером в worker/outbox. +func (s *Store) RequeueStuck(ctx context.Context) (int64, error) { + tag, err := s.pool.Exec(ctx, ` + UPDATE attachment_jobs + SET status='queued', lease_owner=NULL, lease_expires_at=NULL, + next_attempt_at = now(), updated_at = now() + WHERE status='processing' AND lease_expires_at < now()`) + if err != nil { + return 0, classifyDBError(err) + } + return tag.RowsAffected(), nil +} + +// ReplayFailed — операторский replay (уровень 4, CLI/endpoint). +func (s *Store) ReplayFailed(ctx context.Context, attachmentID string) error { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return classifyDBError(err) + } + defer tx.Rollback(ctx) + + tag, err := tx.Exec(ctx, ` + UPDATE attachment_jobs + SET status='queued', attempt=1, next_attempt_at=now(), + last_error_code=NULL, lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE attachment_id=$1 AND status='failed'`, attachmentID) + if err != nil { + return classifyDBError(err) + } + if tag.RowsAffected() == 0 { + return ErrConflict + } + + if _, err := tx.Exec(ctx, + `UPDATE attachments SET status='queued', error_code=NULL, failed_at=NULL, + updated_at=now() + WHERE id=$1 AND status='failed'`, attachmentID); err != nil { + return classifyDBError(err) + } + return tx.Commit(ctx) +} + +// ClaimJobByID — берёт конкретную job под lease. Нужен для redelivery: +// если worker упал после publish, повторно доставленное сообщение должно +// либо взять ту же работу (lease протух), либо быть no-op (status=done). +func (s *Store) ClaimJobByID(ctx context.Context, jobID, workerID string, lease time.Duration) (*Job, error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted}) + if err != nil { + return nil, classifyDBError(err) + } + defer tx.Rollback(ctx) + + var j Job + err = tx.QueryRow(ctx, ` + UPDATE attachment_jobs + SET status='processing', + lease_owner=$2, + lease_expires_at = now() + $3::interval, + updated_at = now() + WHERE job_id=$1 + AND status IN ('queued','processing') + AND (status='queued' OR lease_expires_at < now()) + RETURNING job_id, attachment_id, pipeline_version, attempt, + status, next_attempt_at, last_error_code`, + jobID, workerID, lease.String(), + ).Scan(&j.JobID, &j.AttachmentID, &j.PipelineVersion, &j.Attempt, + &j.Status, &j.NextAttemptAt, &j.LastError) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, classifyDBError(err) + } + + if err := tx.Commit(ctx); err != nil { + return nil, classifyDBError(err) + } + return &j, nil +} + +// GetStagingKey — доверенные метаданные для worker’а (не из сообщения брокера). +func (s *Store) GetStagingKey(ctx context.Context, attachmentID string) (string, string, error) { + var key, ct string + err := s.pool.QueryRow(ctx, + `SELECT staging_key, content_type FROM attachments WHERE id=$1`, attachmentID, + ).Scan(&key, &ct) + if errors.Is(err, pgx.ErrNoRows) { + return "", "", ErrNotFound + } + if err != nil { + return "", "", classifyDBError(err) + } + return key, ct, nil +} + +// VariantsExist — no-op-проверка на повторную доставку уже готовой работы. +func (s *Store) VariantsExist(ctx context.Context, attachmentID string, pv int) (bool, error) { + var n int + err := s.pool.QueryRow(ctx, + `SELECT count(*) FROM attachment_variants + WHERE attachment_id=$1 AND pipeline_version=$2`, + attachmentID, pv, + ).Scan(&n) + if err != nil { + return false, classifyDBError(err) + } + return n >= len(RequiredVariants), nil +} + +// MarkFailedPermanent — терминальный failed без retry (постоянная ошибка). +func (s *Store) MarkFailedPermanent(ctx context.Context, jobID, attachmentID, code string) error { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return classifyDBError(err) + } + defer tx.Rollback(ctx) + if _, err := tx.Exec(ctx, + `UPDATE attachment_jobs SET status='failed', last_error_code=$2, + lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE job_id=$1 AND status='processing'`, jobID, code); err != nil { + return classifyDBError(err) + } + if _, err := tx.Exec(ctx, + `UPDATE attachments SET status='failed', error_code=$2, + failed_at=now(), updated_at=now() + WHERE id=$1`, attachmentID, code); err != nil { + return classifyDBError(err) + } + return tx.Commit(ctx) +} + +type UnpublishedJob struct { + JobID string + AttachmentID string + PipelineVersion int + Attempt int +} + +// SelectUnpublishedJobs — выборка outbox’ом. Транзакция не нужна: +// published_at ставим отдельным UPDATE после XADD; повторная публикация +// допустима (worker идемпотентен). +func (s *Store) SelectUnpublishedJobs(ctx context.Context, limit int) ([]UnpublishedJob, error) { + rows, err := s.pool.Query(ctx, ` + SELECT job_id, attachment_id, pipeline_version, attempt + FROM attachment_jobs + WHERE published_at IS NULL AND status='queued' + AND next_attempt_at <= now() + ORDER BY next_attempt_at + LIMIT $1`, limit) + if err != nil { + return nil, classifyDBError(err) + } + defer rows.Close() + var out []UnpublishedJob + for rows.Next() { + var u UnpublishedJob + if err := rows.Scan(&u.JobID, &u.AttachmentID, &u.PipelineVersion, &u.Attempt); err != nil { + return nil, classifyDBError(err) + } + out = append(out, u) + } + return out, rows.Err() +} + +// MarkPublished — фиксируем факт XADD (publisher confirm). +func (s *Store) MarkPublished(ctx context.Context, jobID string) error { + _, err := s.pool.Exec(ctx, + `UPDATE attachment_jobs SET published_at=now(), + publish_attempts=publish_attempts+1, updated_at=now() + WHERE job_id=$1`, jobID) + return classifyDBError(err) +} + +// BumpPublishAttempt — XADD упал; фиксируем причину, повторим в следующем цикле. +func (s *Store) BumpPublishAttempt(ctx context.Context, jobID, code string) error { + _, err := s.pool.Exec(ctx, + `UPDATE attachment_jobs SET publish_attempts=publish_attempts+1, + last_error_code=$2, updated_at=now() + WHERE job_id=$1`, jobID, code) + return classifyDBError(err) +} + +func (s *Store) GetVariantKey(ctx context.Context, attachmentID string, pv int, variant string) (string, string, error) { + var key, ct string + err := s.pool.QueryRow(ctx, + `SELECT object_key, content_type FROM attachment_variants + WHERE attachment_id=$1 AND pipeline_version=$2 AND variant=$3`, + attachmentID, pv, variant).Scan(&key, &ct) + if errors.Is(err, pgx.ErrNoRows) { + return "", "", ErrNotFound + } + if err != nil { + return "", "", classifyDBError(err) + } + return key, ct, nil +} diff --git a/src/domain/broker.go b/src/domain/broker.go new file mode 100644 index 00000000..4e2b728d --- /dev/null +++ b/src/domain/broker.go @@ -0,0 +1,80 @@ +package domain + +import ( + "context" + "encoding/json" + "errors" + "strings" + "time" + + "github.com/redis/go-redis/v9" +) + +const ( + StreamName = "attachment.jobs" + ConsumerGroup = "workers" +) + +type JobMessage struct { + SchemaVersion int `json:"schema_version"` + JobID string `json:"job_id"` + Type string `json:"type"` + AttachmentID string `json:"attachment_id"` + PipelineVersion int `json:"pipeline_version"` + Attempt int `json:"attempt"` + CreatedAt string `json:"created_at"` + Traceparent string `json:"traceparent,omitempty"` +} + +type Broker struct{ rdb *redis.Client } + +func NewBroker(ctx context.Context, url string) (*Broker, error) { + opt, err := redis.ParseURL(url) + if err != nil { + return nil, err + } + rdb := redis.NewClient(opt) + if err := rdb.Ping(ctx).Err(); err != nil { + return nil, err + } + // Группа создаётся идемпотентно. + err = rdb.XGroupCreateMkStream(ctx, StreamName, ConsumerGroup, "0").Err() + if err != nil && !strings.Contains(err.Error(), "BUSYGROUP") { + return nil, err + } + return &Broker{rdb: rdb}, nil +} + +func (b *Broker) Publish(ctx context.Context, m JobMessage) (string, error) { + buf, err := json.Marshal(m) + if err != nil { + return "", err + } + return b.rdb.XAdd(ctx, &redis.XAddArgs{ + Stream: StreamName, + Values: map[string]any{"payload": buf}, + }).Result() +} + +// Consume — блокирующее чтение из consumer group; ack делает вызывающий. +func (b *Broker) Consume(ctx context.Context, consumer string) ([]redis.XMessage, error) { + res, err := b.rdb.XReadGroup(ctx, &redis.XReadGroupArgs{ + Group: ConsumerGroup, Consumer: consumer, + Streams: []string{StreamName, ">"}, + Count: 1, Block: 5 * time.Second, + }).Result() + if errors.Is(err, redis.Nil) { + return nil, nil + } + if err != nil { + return nil, err + } + if len(res) == 0 { + return nil, nil + } + return res[0].Messages, nil +} + +func (b *Broker) Ack(ctx context.Context, id string) error { + return b.rdb.XAck(ctx, StreamName, ConsumerGroup, id).Err() +} diff --git a/src/domain/jobs.go b/src/domain/jobs.go new file mode 100644 index 00000000..20da748d --- /dev/null +++ b/src/domain/jobs.go @@ -0,0 +1,13 @@ +package domain + +import "time" + +type Job struct { + JobID string + AttachmentID string + PipelineVersion int + Attempt int + Status string + NextAttemptAt time.Time + LastError *string +} diff --git a/src/domain/models.go b/src/domain/models.go index 9f427722..26be699d 100644 --- a/src/domain/models.go +++ b/src/domain/models.go @@ -62,21 +62,23 @@ type Variant struct { Width int `json:"width"` Height int `json:"height"` SHA256 string `json:"sha256"` + ObjectKey string `json:"-"` } type Attachment struct { - ID string `json:"id"` - ChatID string `json:"chat_id"` - OwnerID string `json:"owner_id"` - Filename string `json:"filename"` - ContentType string `json:"content_type"` - SizeBytes int64 `json:"size_bytes"` - SHA256 string `json:"sha256"` - Status string `json:"status"` - Variants []Variant `json:"variants"` - ErrorCode *string `json:"error_code"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` + ID string `json:"id"` + ChatID string `json:"chat_id"` + OwnerID string `json:"owner_id"` + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + Status string `json:"status"` + PipelineVersion int `json:"-"` + Variants []Variant `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` } var ( diff --git a/src/domain/s3.go b/src/domain/s3.go index 461c21fd..dff225ed 100644 --- a/src/domain/s3.go +++ b/src/domain/s3.go @@ -158,6 +158,51 @@ func (s *S3Store) PutValidatedImage(ctx context.Context, objectKey string, body }, nil } +const ( + StagingPrefix = "staging/" + FinalPrefix = "final/" +) + +// MoveToFinal: копирование staging→final и удаление staging. +// Используем CopyObject, чтобы не тянуть байты в память. Если MinIO не умеет +// server-side copy — используйте compose? MinIO умеет S3 CopyObject. +func (s *S3Store) MoveToFinal(ctx context.Context, stagingKey, finalKey string) error { + src := minio.CopySrcOptions{Bucket: s.bucket, Object: stagingKey} + dst := minio.CopyDestOptions{Bucket: s.bucket, Object: finalKey} + if _, err := s.client.CopyObject(ctx, dst, src); err != nil { + return err + } + return s.DeleteObject(ctx, stagingKey) +} + +func (s *S3Store) PutBytes(ctx context.Context, key, contentType string, data []byte) (string, error) { + h := sha256.Sum256(data) + _, err := s.client.PutObject(ctx, s.bucket, key, bytes.NewReader(data), int64(len(data)), + minio.PutObjectOptions{ContentType: contentType}) + if err != nil { + return "", err + } + return hex.EncodeToString(h[:]), nil +} + +// FetchStagingForProcessing — читает staging в память с жёстким лимитом. +// maxBytes гарантирует, что worker не съест RAM на «злом» файле. +func (s *S3Store) FetchStagingForProcessing(ctx context.Context, key string) ([]byte, string, error) { + rc, ct, size, err := s.GetObject(ctx, key) + if err != nil { + return nil, "", err + } + defer rc.Close() + if size > s.maxBytes { + return nil, "", ErrTooLarge + } + buf, err := io.ReadAll(rc) + if err != nil { + return nil, "", err + } + return buf, ct, nil +} + func (s *S3Store) GetObject(ctx context.Context, objectKey string) (io.ReadCloser, string, int64, error) { // Общий дедлайн на все попытки — 6 секунд. overallCtx, overallCancel := context.WithTimeout(ctx, 6*time.Second) -- 2.54.0 From c91ec7790fdeca7564ea908ec6c659119083c035 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D1=8F=20=D0=9C=D0=BE=D1=80=D0=BE=D0=B7?= <145702378+MiniLynx13@users.noreply.github.com> Date: Mon, 16 Nov 2026 20:30:12 +0300 Subject: [PATCH 3/3] feat:report --- Dockerfile | 5 +- Makefile | 23 ++- REPORT.md | 185 ++++++++++++++++-- cmd/worker/main.go | 3 +- cmd/worker/process.go | 52 +++-- compose.yaml | 9 + evidence/1_Healthcheck.png | Bin 0 -> 79034 bytes evidence/2_Tests_Passing.png | Bin 0 -> 96622 bytes evidence/my_tests_passing.txt | 56 ++++++ migrations/0001_core.sql | 58 ++++++ migrations/0001_init.sql | 31 --- migrations/0002_attachments.sql | 88 +++++++++ migrations/0002_sessions.sql | 9 - ...ql => 0003_messages_covering_optional.sql} | 2 +- migrations/0004_idempotency.sql | 14 -- migrations/0005_attachments.sql | 30 --- migrations/0006_attachment_jobs.sql | 49 ----- scripts/migrate.sh | 18 +- src/api/handlers.go | 9 +- src/domain/attachment_states.go | 2 +- src/domain/attachments.go | 63 +++--- src/domain/postgres.go | 17 +- student_tests/broker-payload.py | 25 +++ student_tests/common.py | 73 +++++++ student_tests/crash-before-ack.py | 41 ++++ student_tests/dlq.py | 25 +++ student_tests/failed.py | 29 +++ student_tests/jpeg_probe.py | 28 +++ student_tests/lease.py | 68 +++++++ student_tests/limits.py | 43 ++++ student_tests/outbox.py | 32 +++ student_tests/redelivery.py | 35 ++++ student_tests/replay.py | 33 ++++ student_tests/retry.py | 80 ++++++++ student_tests/staging-cleanup.py | 36 ++++ student_tests/states.py | 45 +++++ student_tests/variants.py | 52 +++++ 37 files changed, 1159 insertions(+), 209 deletions(-) create mode 100644 evidence/1_Healthcheck.png create mode 100644 evidence/2_Tests_Passing.png create mode 100644 evidence/my_tests_passing.txt create mode 100644 migrations/0001_core.sql delete mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_attachments.sql delete mode 100644 migrations/0002_sessions.sql rename migrations/{0003_messages_alt_index.sql => 0003_messages_covering_optional.sql} (70%) delete mode 100644 migrations/0004_idempotency.sql delete mode 100644 migrations/0005_attachments.sql delete mode 100644 migrations/0006_attachment_jobs.sql create mode 100644 student_tests/broker-payload.py create mode 100644 student_tests/common.py create mode 100644 student_tests/crash-before-ack.py create mode 100644 student_tests/dlq.py create mode 100644 student_tests/failed.py create mode 100644 student_tests/jpeg_probe.py create mode 100644 student_tests/lease.py create mode 100644 student_tests/limits.py create mode 100644 student_tests/outbox.py create mode 100644 student_tests/redelivery.py create mode 100644 student_tests/replay.py create mode 100644 student_tests/retry.py create mode 100644 student_tests/staging-cleanup.py create mode 100644 student_tests/states.py create mode 100644 student_tests/variants.py diff --git a/Dockerfile b/Dockerfile index 4ee7b168..d96d7124 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,5 @@ # --- build stage --- -FROM golang:1.22-alpine AS build +FROM golang:1.26-alpine AS build WORKDIR /src RUN apk add --no-cache ca-certificates @@ -29,7 +29,4 @@ RUN chmod +x /app/migrate.sh USER app EXPOSE 8080 -HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=5 \ - CMD wget -qO- http://127.0.0.1:8080/health/ready >/dev/null || exit 1 - ENTRYPOINT ["/app/messenger"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d171..943cf6ca 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover my_tests my_tests_quick my_tests_slow help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +28,24 @@ 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) + +# Быстрые (<1 мин): статусы, лимиты, варианты, payload, DLQ, staging. +my_tests_quick: + python3 student_tests/states.py + python3 student_tests/limits.py + python3 student_tests/variants.py + python3 student_tests/broker-payload.py + python3 student_tests/staging-cleanup.py + python3 student_tests/dlq.py + python3 student_tests/redelivery.py + +# Долгие (>2 мин): retry/backoff/failed/replay/outbox/lease/crash. +my_tests_slow: + python3 student_tests/outbox.py + python3 student_tests/failed.py + python3 student_tests/retry.py + python3 student_tests/replay.py + python3 student_tests/lease.py + python3 student_tests/crash-before-ack.py + +my_tests: my_tests_quick my_tests_slow \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e98f75e9..e32171da 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,184 @@ # Отчёт — лабораторная 5 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Морозова Ольга Андреевна, БВТ2303 +- Целевая оценка: **4** (треки на 5 не заявлены) - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники: [README.md](README.md), [COURSE.md](COURSE.md), [contracts/openapi.json](contracts/openapi.json), документация Go, MinIO (mc), PostgreSQL, Redis Streams, Nginx, Docker. +- Библиотеки: Go 1.26 (stdlib), github.com/google/uuid v1.6.0, github.com/jackc/pgx/v5 v5.5.5, github.com/redis/go-redis/v9 v9.5.1, golang.org/x/crypto v0.23.0, github.com/minio/minio-go/v7 v7.0.72, golang.org/x/image v0.48.0. Тесты — Python 3 (stdlib). +- Помощь ИИ: Deepseek — написание и проверка кода. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Команды выполнялись в WSL2 (Ubuntu) на Windows 11. Требования: Docker 24+ (Compose v2), Python 3.9+ (для тестов), `make`. + +Версии (фиксированные теги образов): + +- `golang:1.26-alpine` — build stage +- `alpine:3.20` — runtime stage +- `postgres:16.3-alpine` — база данных +- `redis:7.2.5-alpine` — кэш сессий и брокер (Redis Streams) +- `nginx:1.27.0-alpine` — балансировщик +- `pgsty/silo:RELEASE.2026-10-26T00-00-00Z` — S3-совместимое хранилище (MinIO-compatible) + +### Подготовка + +```sh +git clone https://gitea.privcloud.tech/MiniLynx/mtusi2026lab5-fork +cd mtusi2026lab5-fork + +# 1. Секреты (не входят в Git) +mkdir -p secrets +printf 'local-dev-postgres-password\n' > secrets/postgres_password.txt +printf 'postgres://messenger:local-dev-postgres-password@postgres:5432/messenger?sslmode=disable\n' > secrets/database_url.txt +printf 'redis://redis:6379/0\n' > secrets/cache_url.txt +printf 'minioadmin\n' > secrets/minio_root_user.txt +printf 'minioadmin-dev-password\n' > secrets/minio_root_password.txt +printf 'messenger-api\n' > secrets/s3_access_key_id.txt +printf 'messenger-api-dev-secret\n' > secrets/s3_secret_access_key.txt +chmod 600 secrets/*.txt + +# 2. Локальный .env +cp .env.example .env +# ВАЖНО: В .env нужно исправить S3_ENDPOINT на s3:9000 (без http://) +sed -i 's|S3_ENDPOINT=.*|S3_ENDPOINT=s3:9000|' .env + +# 3. Python для проверок +python3 -m venv .venv +source .venv/bin/activate +python -m pip install -r requirements-dev.txt + +# 4. Скрипты +chmod +x scripts/migrate.sh scripts/restart.sh scripts/stop-one.sh scripts/restore-api.sh +``` + +### Сборка и запуск + +```sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# Дождаться /health/ready +docker compose ps +``` + +Для запуска с другим количеством реплик добавить `API_REPLICAS=$n` перед `docker compose --env-file .env up -d --build`, где `$n` - желаемое количество реплик. + +### Тесты + +```sh +make check +make validate PYTHON=.venv/bin/python +make test + +# Persistence +make test-persistence ACTION_SCRIPT=scripts/restart.sh + +# Failover +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +./scripts/restore-api.sh + +# Собственные тесты (pipeline, сбои, лимиты) +make my_tests +``` + +## Остановка (с сохранением volumes) + +```sh +docker compose --env-file .env down --remove-orphans +``` + +### Намеренное удаление учебных данных + +```sh +docker compose --env-file .env down --remove-orphans -v +rm -f secrets/*.txt +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +HTTP-клиент → Nginx (8080) → API (Go, x2, stateless) + │ + ├──[S3 PUT]→ staging/ (S3, приватный bucket) + ├──[INSERT]→ Postgres: attachments (queued) + attachment_jobs (outbox) + └──[202 Accepted] + +Outbox (x1) ⇄ Postgres (attachment_jobs.published_at IS NULL) + │ + └──[XADD]→ Redis Streams (attachment.jobs) + +Worker (x2) ⇄ Redis Streams (consumer group) + ├──[SELECT ... FOR UPDATE SKIP LOCKED]→ Postgres (lease 60s) + ├──[GET]→ staging/ → resize (thumb 256, crop 128, opt) →[PUT]→ final/ + ├──[INSERT variants + UPDATE ready]→ Postgres (транзакция) + └──[XACK]→ Redis +``` + +- **Асинхронный приём (уровень 3):** `POST /api/v1/chats/{id}/attachments` возвращает **202 Accepted** сразу после того, как файл сохранён в staging, а в БД одной транзакцией записаны метаданные `attachments` (status=`queued`) и `attachment_jobs` (outbox). Это гарантирует, что после ответа 202 работа не потеряется при рестарте API. +- **Outbox (уровень 4):** отдельный процесс `cmd/outbox` читает `attachment_jobs WHERE published_at IS NULL` и публикует в брокер. `published_at` ставится только после `XADD`. Падение между COMMIT и publish приводит к повторной публикации при следующем цикле; worker идемпотентен. +- **Брокер:** Redis Streams (тот же Redis, AOF `--appendonly yes`). Consumer Group `workers`, `XACK` после durable-эффекта. В сообщении только `job_id`, `attachment_id`, `pipeline_version`, `attempt` (никаких URL или filename). +- **Worker (уровень 3-4):** отдельный процесс, реплики 2. Забирает job через `ClaimJobByID` (lease 60s). Пишет `original` (server-side copy staging→final), `thumbnail` (256×256, fit), `crop` (128×128, center-cover) и `optimized` (JPEG q=70). Всё в одной транзакции с `attachment_variants` и `status='ready'`. `XACK` только после COMMIT. +- **Идемпотентность:** ключ эффекта — `(attachment_id, pipeline_version, variant)`. Повторная доставка того же job_id: `MarkReady` — no-op (если `status='done'`), `attachment_variants` — `ON CONFLICT DO NOTHING`. Также `VariantsExist` перед Claim. +- **Retry:** `RetryJob` различает permanent (`invalid_image` → сразу failed) и transient (`storage_error` → backoff `base * 2^(n-1) + jitter`, max 5 попыток). Финальный `failed` с безопасным `error_code`. +- **Зависшие job:** `RequeueStuck` в outbox и worker, каждые 30с: `status='processing' AND lease_expires_at < now()` → `queued`, `published_at=NULL`. +- **Replay:** `POST /api/v1/attachments/{id}/replay` сбрасывает `attempt=1`, `status='queued'`, `published_at=NULL` для failed-задач. +- **Очистка:** `MoveToFinal` удаляет staging после CopyObject. `ReconcileOrphans` (в API) чистит `attachment_gc` и «зависшие» staging-объекты без job. + +### Что перенесено из lab4 + +- PostgreSQL, Argon2id, sessions (с кэшем в Redis), горизонтальное масштабирование, Nginx. +- Механизм идемпотентности `idempotency_keys` для сообщений. +- S3-хранилище и приватный bucket, `S3Store` с таймаутами и ретраями. + +### Что изменено + +- Миграция `0002_attachments.sql`: добавлены `attachment_variants`, `attachment_jobs` (outbox+lease), поля `staging_key`, `pipeline_version`, `ready_at`, `failed_at`. Таблица `attachments` теперь содержит `status IN ('queued','processing','ready','failed')`. +- `UploadAttachment` возвращает 202, статус `queued`; `DownloadAttachment` → 409 для не-ready. +- Добавлены `cmd/outbox`, `cmd/worker` (обработка изображений, `process.go`). +- `src/domain/broker.go` — обёртка Redis Streams. +- `compose.yaml`: сервисы `outbox` (1 реплика) и `worker` (2 реплики), миграции вынесены в отдельный сервис `migrate`. +- В `attachments.go`: `EnqueueAttachment`, `ClaimJob`, `ClaimJobByID`, `MarkReady`, `RetryJob`, `RequeueStuck`, `ReplayFailed`, `MarkFailedPermanent`, `GetVariantKey`, `SelectUnpublishedJobs`, `MarkPublished`. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| ----------------------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------ | +| Offline-структура и локальные refs | `make check` | PASS | [png](evidence/2_Tests_Passing.png) | +| Полная OpenAPI 3.1 и JSON Schema | `make validate PYTHON=.venv/bin/python` | PASS | [png](evidence/2_Tests_Passing.png) | +| Публичный smoke (lab5) | `make test` | PASS: 202, ready, thumbnail | [png](evidence/2_Tests_Passing.png) | +| Persistence: перезапуск API+БД+Redis+S3 | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS | [png](evidence/2_Tests_Passing.png) | +| Failover: остановка одной реплики API | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | `observed_instances_before: 2`, `successful_writes: 75`, `first_recovery: 5.371s` | [png](evidence/2_Tests_Passing.png) | +| **Ур. 3:** Upload → 202 → queued (worker не нужен) | `student_tests/states.py` | queued → ready, 3 варианта + original через `?variant=original` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** Broker и worker — отдельные процессы | `docker compose ps` | `outbox`, `worker-1`, `worker-2` | [png](evidence/1_Healthcheck.png) | +| **Ур. 3:** Статусы в API, лимиты и типы | `student_tests/limits.py` | 413, 415, 400 invalid_image | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** original неизменен, thumbnail по контракту | `student_tests/variants.py` | `byte-identical`, `thumbnail 256x160 (metadata matches)`, `crop 128x128` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** Broker payload без filename/URL | `student_tests/broker-payload.py` | только id/version/attempt | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** Очистка staging после ready | `student_tests/staging-cleanup.py` | `staging object removed after ready` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** Реестр failed (DLQ) | `student_tests/dlq.py` | `invalid_image\|1` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 3:** Идемпотентность при повторной доставке | `student_tests/redelivery.py` | `still 3 non-original variants` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Outbox закрывает разрыв COMMIT→publish | `student_tests/outbox.py` | `published_at IS NULL` при паузе outbox → ready после unpause | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Permanent error без retry | `student_tests/failed.py` | `attempt=1, invalid_image — not retried` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Transient error → retry → ready | `student_tests/retry.py` | `attempt=2`, `retry log lines: ... backoff=2s jitter=451ms` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Replay failed | `student_tests/replay.py` | `replay -> queued`, повторный permanent fail | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Lease / reaper зависших | `student_tests/lease.py` | `reaper requeued the stuck job` → `ready` | [txt](evidence/my_tests_passing.txt) | +| **Ур. 4:** Crash после side effect до ack | `student_tests/crash-before-ack.py` | `recovery produced exactly 3 variants, no duplicates` | [txt](evidence/my_tests_passing.txt) | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| ------------------------------------ | ----------------------------------------------------- | ---------------------------------------------------------- | ------------------------------------------- | +| Остановка одной реплики API | 0 потерянных подтверждённых записей, LB переключается | Failover PASS, 75 успешных сообщений | 5.371 с, потерь нет | +| Рестарт API/БД/Redis/S3 (volumes) | Вложение и сессия живы | Persistence PASS | ~30 с (запуск контейнеров), потерь нет | +| Отказ S3 | API возвращает 503, worker ретраит | `retry.py` PASS, `attempt=2`, backoff сработал | После восстановления S3 — ready | +| Пауза outbox (разрыв COMMIT→publish) | `published_at=NULL`, upload 202 | `outbox.py` PASS, job дошёл до ready после unpause | Задержка publish = период паузы, потерь нет | +| Пауза worker (зависший processing) | Lease истекает, reaper возвращает в queued | `lease.py` PASS, job вернулся в queued через ~60с + reaper | ~90 с, потерь нет | +| `SIGKILL` worker во время processing | Повторная доставка, без дублей вариантов | `crash-before-ack.py` PASS, 3 варианта, без дублей | ~100 с (lease + рестарт), потерь нет | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **At-least-once:** доставка Redis Streams + идемпотентный эффект ≠ exactly-once. При падении между XADD и MarkPublished возможна повторная публикация; повторный worker это корректно обрабатывает, но сообщение в Stream продублируется. +- **Replay** доступен через endpoint `POST /api/v1/attachments/{id}/replay` (расширение сверх OpenAPI). В отчёте зафиксировано, что это не меняет семантику обязательных путей. +- **Optimized** — JPEG q=70 вместо WebP (WebP-кодирование требует cgo-зависимостей, которых в alpine-сборке без CGO нет). Контракт допускает JPEG как «перекодированный» вариант; в отчёте явно указано. +- **Broker = Redis Streams** вместо RabbitMQ — обосновано тем, что Redis уже нужен для кэша сессий, AOF включён, это уменьшает количество контейнеров. Если Redis упадёт без AOF-реплики, неопубликованные задачи будут ждать в `attachment_jobs` (outbox) — они не потеряются. +- **DLQ** — пока реестр `attachment_jobs.status='failed'` + `last_error_code`, без отдельного UI. Для оператора — `SELECT` из БД и endpoint replay. +- **Не реализовано:** версионирование нескольких pipeline (трек 5), auto-scaling worker’а по queue lag (трек 1), fault-injection с версионированием (трек 2). Уровень 5 не заявлен. +- **Нагрузка** проверена только smoke + `make test`; полноценных замеров throughput/latency pipeline не делалось (не требуется для уровня 4). diff --git a/cmd/worker/main.go b/cmd/worker/main.go index 25e961d6..f16389b3 100644 --- a/cmd/worker/main.go +++ b/cmd/worker/main.go @@ -168,7 +168,8 @@ func handleOne(ctx context.Context, store *domain.Store, s3 *domain.S3Store, return } } else { - sum, err := s3.PutBytes(ctx, finalOriginalKey, v.ContentType, v.Data) + key := "final/" + j.AttachmentID + "/" + v.Name + sum, err := s3.PutBytes(ctx, key, v.ContentType, v.Data) if err != nil { _, _ = store.RetryJob(ctx, j.JobID, "storage_error", maxAttempts, baseBackoff) _ = broker.Ack(ctx, m.ID) diff --git a/cmd/worker/process.go b/cmd/worker/process.go index 58a05293..eb7500ea 100644 --- a/cmd/worker/process.go +++ b/cmd/worker/process.go @@ -6,6 +6,7 @@ import ( "encoding/hex" "image" "image/jpeg" + "math" "golang.org/x/image/draw" ) @@ -29,7 +30,7 @@ func encodeOptimizedJPEG(src image.Image, quality int) ([]byte, error) { // processImage возвращает 4 варианта. Оригинал — byte-identical с входом. // thumbnail 256x256 (fit, без искажения), crop 128x128 (center crop), -// optimized — WebP q=80 без метаданных. +// optimized — JPEG q=70 без метаданных (WebP оставлен на усмотрение; см. отчёт). func processImage(raw []byte, contentType string) ([]VariantSpec, error) { src, _, err := image.Decode(bytes.NewReader(raw)) if err != nil { @@ -46,14 +47,14 @@ func processImage(raw []byte, contentType string) ([]VariantSpec, error) { Data: raw, SHA256: hex.EncodeToString(sum[:]), }) - // thumbnail 256x256 (fit). + // thumbnail: fit в 256x160 с сохранением пропорций (для 16:10 — 256x160). th := resizeFit(src, 256, 256) if err := appendEncoded(&out, "thumbnail", "image/jpeg", th); err != nil { return nil, err } - // crop 128x128 (center crop). - cr := centerCrop(src, 128, 128) + // crop 128x128: центр-cover до меньшего квадрата. + cr := squareCover(src, 128) if err := appendEncoded(&out, "crop", "image/jpeg", cr); err != nil { return nil, err } @@ -96,28 +97,41 @@ func resizeFit(src image.Image, maxW, maxH int) image.Image { if scale > 1 { scale = 1 } - nw, nh := int(float64(w)*scale), int(float64(h)*scale) + nw := int(math.Round(float64(w) * scale)) + nh := int(math.Round(float64(h) * scale)) dst := image.NewRGBA(image.Rect(0, 0, nw, nh)) draw.CatmullRom.Scale(dst, dst.Bounds(), src, b, draw.Over, nil) return dst } -func centerCrop(src image.Image, w, h int) image.Image { +// squareCover масштабирует src так, чтобы покрыть квадрат size×size +// (min-масштаб по двум осям), затем центр-кроп до size×size. +// Результат — всегда ровно size×size. +func squareCover(src image.Image, size int) image.Image { b := src.Bounds() - sw, sh := b.Dx(), b.Dy() - cw, ch := w, h - if sw < cw { - cw = sw + w, h := b.Dx(), b.Dy() + // scale — больший из двух, чтобы покрыть квадрат + scale := float64(size) / float64(w) + if float64(size)/float64(h) > scale { + scale = float64(size) / float64(h) } - if sh < ch { - ch = sh + nw := int(math.Round(float64(w) * scale)) + nh := int(math.Round(float64(h) * scale)) + if nw < size { + nw = size } - x0 := (sw - cw) / 2 - y0 := (sh - ch) / 2 - dst := image.NewRGBA(image.Rect(0, 0, w, h)) - // масштабируем crop-область в целевой размер (иначе мелкие картинки не влезут). - draw.CatmullRom.Scale(dst, dst.Bounds(), - src, image.Rect(b.Min.X+x0, b.Min.Y+y0, b.Min.X+x0+cw, b.Min.Y+y0+ch), - draw.Over, nil) + if nh < size { + nh = size + } + + scaled := image.NewRGBA(image.Rect(0, 0, nw, nh)) + draw.CatmullRom.Scale(scaled, scaled.Bounds(), src, b, draw.Over, nil) + + // center-crop до size×size + x0 := (nw - size) / 2 + y0 := (nh - size) / 2 + dst := image.NewRGBA(image.Rect(0, 0, size, size)) + draw.Draw(dst, dst.Bounds(), scaled, + image.Pt(x0, y0), draw.Src) return dst } diff --git a/compose.yaml b/compose.yaml index 4b4939a1..3614cc85 100644 --- a/compose.yaml +++ b/compose.yaml @@ -10,6 +10,7 @@ x-api: &api redis: { condition: service_healthy } s3: { condition: service_healthy } s3-init: { condition: service_completed_successfully } + migrate: { condition: service_completed_successfully } networks: [backend] services: @@ -91,6 +92,12 @@ services: limits: cpus: "${API_CPU_PER_REPLICA:-0.5}" memory: "${API_MEM_PER_REPLICA:-128M}" + healthcheck: + test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8080/health/ready"] + interval: 10s + timeout: 3s + start_period: 20s + retries: 5 outbox: <<: *api @@ -98,6 +105,7 @@ services: depends_on: postgres: { condition: service_healthy } redis: { condition: service_healthy } + migrate: { condition: service_completed_successfully } deploy: replicas: 1 resources: @@ -110,6 +118,7 @@ services: postgres: { condition: service_healthy } redis: { condition: service_healthy } s3: { condition: service_healthy } + migrate: { condition: service_completed_successfully } deploy: replicas: 2 resources: diff --git a/evidence/1_Healthcheck.png b/evidence/1_Healthcheck.png new file mode 100644 index 0000000000000000000000000000000000000000..951815e3c0a8d5c5fb88599ec9386295c13d127c GIT binary patch literal 79034 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 literal 0 HcmV?d00001 diff --git a/evidence/2_Tests_Passing.png b/evidence/2_Tests_Passing.png new file mode 100644 index 0000000000000000000000000000000000000000..d1e3ffb249e9163dd9a0fdd9387fac130d505584 GIT binary patch literal 96622 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 literal 0 HcmV?d00001 diff --git a/evidence/my_tests_passing.txt b/evidence/my_tests_passing.txt new file mode 100644 index 00000000..1159c9d8 --- /dev/null +++ b/evidence/my_tests_passing.txt @@ -0,0 +1,56 @@ +(.venv) linux@DESKTOP-7TS8I4A:/mnt/c/MiniLynx/Forth/VP/lab5/mtusi2026lab5-fork$ make my_tests +python3 student_tests/states.py +upload -> queued +status stays queued while worker paused +ready with thumbnail/crop/optimized (original available via ?variant=original) +original served via ?variant=original (111817 bytes) +python3 student_tests/limits.py +413 payload_too_large +415 unsupported_media_type +415 mismatched content (client MIME not trusted) +400 invalid image (signature ok, header broken) +400 too many pixels +python3 student_tests/variants.py +original byte-identical +thumbnail 256x160 (metadata matches) +crop 128x128 JPEG +optimized present (4818 bytes) +python3 student_tests/broker-payload.py +stream sample: +1794848167433-0 +payload +{"schema_version":1,"job_id":"ee59551f-c85f-411a-b4d9-6076f31fde8f","type":"attachment.process.v1","attachment_id":"1175cf24-2984-4800-b84d-1aa702ecd7bd","pipeline_version":1,"attempt":1,"created_at":"2026-11-16T16:56:07Z"} +1794848176445-0 +payload +{"schema_version":1,"job_id":"b7792daf-6123-4c7a-9566-b2fc4a53a614","type":"attachment.process.v1","attachment_id":"05ef10e7-19c4-47ef-9c68-a2e09eb8338e","pipeline_version":1,"attempt":1,"created_at":"2026-11-16T16:56:16Z"} + +broker payload has only ids/version/attempt +python3 student_tests/staging-cleanup.py +staging object removed after ready (mc rc=1) +python3 student_tests/dlq.py +failed registry: +b1ccbeca-ae22-44f1-837c-868d2165889c|invalid_image|1 +python3 student_tests/redelivery.py +redelivery is no-op (still 3 non-original variants; original via object_key) +python3 student_tests/outbox.py +outbox paused: published_at IS NULL, upload accepted +after unpause: ready +python3 student_tests/failed.py +failed immediately (attempt=1), error_code=invalid_image — permanent, not retried +python3 student_tests/retry.py +transient error retried: attempt=2 +retry log lines: + worker-1 | 2026/11/16 16:56:48 retry job=64072f3d-6b9e-4101-b31b-7e9a2f51bac3 attempt=2 next_attempt=2026-11-16T16:56:50.964432673Z backoff=2s jitter=451.35473ms code=storage_error +recovered to ready after staging restored (attempt=2) +python3 student_tests/replay.py +failed reached +replay -> queued +replay reset attempt to 1; permanent error failed again — not retried +python3 student_tests/lease.py +worker stopped at processing (job=da0adcf7-64a7-427c-a50b-438e9d688bb7, lease_expires_at=2026-11-16 16:57:59.829609+00) +reaper requeued the stuck job +ready after unstuck +python3 student_tests/crash-before-ack.py +worker killed during processing +recovery produced exactly 3 non-original variants, no duplicates (original in object_key) +(.venv) linux@DESKTOP-7TS8I4A:/mnt/c/MiniLynx/Forth/VP/lab5/mtusi2026lab5-fork$ \ No newline at end of file diff --git a/migrations/0001_core.sql b/migrations/0001_core.sql new file mode 100644 index 00000000..3dd32330 --- /dev/null +++ b/migrations/0001_core.sql @@ -0,0 +1,58 @@ +-- ============================================================ +-- Core: users, sessions, chats, members, messages, idempotency +-- ============================================================ + +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions (user_id); +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions (expires_at); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS 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 TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Индекс истории: ровно под ORDER BY (created_at, id) и keyset-курсор. +CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id + ON messages (chat_id, created_at, id); + +CREATE TABLE IF NOT EXISTS 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, + status_code INTEGER NOT NULL, + response JSONB NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, key) +); +CREATE INDEX IF NOT EXISTS idx_idempotency_created + ON idempotency_keys (created_at); \ No newline at end of file diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql deleted file mode 100644 index 3925e4ac..00000000 --- a/migrations/0001_init.sql +++ /dev/null @@ -1,31 +0,0 @@ -CREATE TABLE IF NOT EXISTS users ( - id UUID PRIMARY KEY, - username TEXT NOT NULL UNIQUE, - display_name TEXT NOT NULL, - password_hash TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() -); - -CREATE TABLE IF NOT EXISTS chats ( - id UUID PRIMARY KEY, - title TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() -); - -CREATE TABLE IF NOT EXISTS 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 TABLE IF NOT EXISTS messages ( - id UUID PRIMARY KEY, - chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, - sender_id UUID NOT NULL REFERENCES users(id), - text TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() -); - --- Индекс истории: ровно под ORDER BY (created_at, id) и keyset-курсор. -CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id - ON messages (chat_id, created_at, id); \ No newline at end of file diff --git a/migrations/0002_attachments.sql b/migrations/0002_attachments.sql new file mode 100644 index 00000000..d3861270 --- /dev/null +++ b/migrations/0002_attachments.sql @@ -0,0 +1,88 @@ +-- ============================================================ +-- Attachments: metadata, variants, jobs/outbox, GC +-- ============================================================ + +CREATE TABLE IF NOT EXISTS 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 CASCADE, + object_key TEXT NOT NULL UNIQUE, + filename TEXT NOT NULL, + content_type TEXT NOT NULL, + size_bytes BIGINT NOT NULL CHECK (size_bytes >= 0 AND size_bytes <= 10485760), + sha256 TEXT NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + width INTEGER NOT NULL CHECK (width >= 0), + height INTEGER NOT NULL CHECK (height >= 0), + status TEXT NOT NULL DEFAULT 'queued' + CHECK (status IN ('queued','processing','ready','failed','pending')), + error_code TEXT, + -- поля из 0006 + pipeline_version INTEGER NOT NULL DEFAULT 1, + staging_key TEXT, + ready_at TIMESTAMPTZ, + failed_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments (chat_id, created_at, id); +CREATE INDEX IF NOT EXISTS idx_attachments_owner ON attachments (owner_id); +-- Для reconciler/поиска «зависших» pending-записей: +CREATE INDEX IF NOT EXISTS idx_attachments_pending + ON attachments (created_at) WHERE status <> 'ready'; + +-- Связь сообщение ↔ вложения. FK на элементы массива Postgres не умеет, +-- целостность — на уровне приложения (или триггера, если нужно). +ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids UUID[] NOT NULL DEFAULT '{}'; + +-- Журнал компенсации: объекты S3, которые могли остаться без метаданных. +CREATE TABLE IF NOT EXISTS attachment_gc ( + object_key TEXT PRIMARY KEY, + reason TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Idempotency эффекта: (attachment_id, pipeline_version, variant) +-- content_type без CHECK: варианты могут быть webp и т.п. +-- sha256 — text+CHECK, чтобы не ловить padding от char(64). +CREATE TABLE IF NOT EXISTS attachment_variants ( + attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, + pipeline_version INTEGER NOT NULL, + variant TEXT NOT NULL, + object_key TEXT NOT NULL, + content_type TEXT NOT NULL, + size_bytes BIGINT NOT NULL, + width INTEGER NOT NULL, + height INTEGER NOT NULL, + sha256 TEXT NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (attachment_id, pipeline_version, variant) +); + +-- Outbox + очередь job-ов +CREATE TABLE IF NOT EXISTS attachment_jobs ( + job_id UUID PRIMARY KEY, + attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, + pipeline_version INTEGER NOT NULL, + attempt INTEGER NOT NULL DEFAULT 1, + status TEXT NOT NULL DEFAULT 'queued' + CHECK (status IN ('queued','processing','done','failed')), + -- outbox + published_at TIMESTAMPTZ, + publish_attempts INTEGER NOT NULL DEFAULT 0, + -- lease + lease_owner TEXT, + lease_expires_at TIMESTAMPTZ, + -- retry + next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), + last_error_code TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + UNIQUE (attachment_id, pipeline_version) -- одна логическая работа на версию +); +CREATE INDEX IF NOT EXISTS idx_attachment_jobs_unpublished + ON attachment_jobs (next_attempt_at) + WHERE published_at IS NULL AND status = 'queued'; +CREATE INDEX IF NOT EXISTS idx_attachment_jobs_lease + ON attachment_jobs (lease_expires_at) + WHERE status = 'processing'; \ No newline at end of file diff --git a/migrations/0002_sessions.sql b/migrations/0002_sessions.sql deleted file mode 100644 index f77b30d7..00000000 --- a/migrations/0002_sessions.sql +++ /dev/null @@ -1,9 +0,0 @@ -CREATE TABLE IF NOT EXISTS sessions ( - token TEXT PRIMARY KEY, - user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, - expires_at TIMESTAMPTZ NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() -); - -CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions (user_id); -CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions (expires_at); \ No newline at end of file diff --git a/migrations/0003_messages_alt_index.sql b/migrations/0003_messages_covering_optional.sql similarity index 70% rename from migrations/0003_messages_alt_index.sql rename to migrations/0003_messages_covering_optional.sql index 12d58f11..dda6537d 100644 --- a/migrations/0003_messages_alt_index.sql +++ b/migrations/0003_messages_covering_optional.sql @@ -1,5 +1,5 @@ -- Индекс B для «стоимости записи»: -- покрывающий индекс, включающий text — растёт быстрее, помогает только --- покрывающим запросам. +-- покрывающим запросам. Накатывать отдельно, чтобы сравнить с индексом A. CREATE INDEX IF NOT EXISTS idx_messages_chat_covering ON messages (chat_id, created_at, id) INCLUDE (sender_id, text); \ No newline at end of file diff --git a/migrations/0004_idempotency.sql b/migrations/0004_idempotency.sql deleted file mode 100644 index da621207..00000000 --- a/migrations/0004_idempotency.sql +++ /dev/null @@ -1,14 +0,0 @@ -CREATE TABLE IF NOT EXISTS 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, - status_code INTEGER NOT NULL, - response JSONB NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now(), - PRIMARY KEY (user_id, method, path, key) -); - -CREATE INDEX IF NOT EXISTS idx_idempotency_created - ON idempotency_keys (created_at); \ No newline at end of file diff --git a/migrations/0005_attachments.sql b/migrations/0005_attachments.sql deleted file mode 100644 index d8765167..00000000 --- a/migrations/0005_attachments.sql +++ /dev/null @@ -1,30 +0,0 @@ -CREATE TABLE IF NOT EXISTS 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 CASCADE, - object_key TEXT NOT NULL UNIQUE, - filename TEXT NOT NULL, - content_type TEXT NOT NULL CHECK (content_type IN ('image/png','image/jpeg')), - size_bytes BIGINT NOT NULL CHECK (size_bytes > 0 AND size_bytes <= 10485760), - sha256 TEXT NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'), - width INTEGER NOT NULL CHECK (width > 0), - height INTEGER NOT NULL CHECK (height > 0), - status TEXT NOT NULL DEFAULT 'ready' CHECK (status IN ('pending','ready','failed')), - error_code TEXT, - created_at TIMESTAMPTZ NOT NULL DEFAULT now(), - updated_at TIMESTAMPTZ NOT NULL DEFAULT now() -); - -CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments (chat_id, created_at, id); -CREATE INDEX IF NOT EXISTS idx_attachments_owner ON attachments (owner_id); --- Для reconciler/поиска «зависших» pending-записей: -CREATE INDEX IF NOT EXISTS idx_attachments_pending ON attachments (created_at) WHERE status <> 'ready'; - -ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids UUID[] NOT NULL DEFAULT '{}'; - --- Журнал компенсации: объекты S3, которые могли остаться без метаданных. -CREATE TABLE IF NOT EXISTS attachment_gc ( - object_key TEXT PRIMARY KEY, - reason TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() -); \ No newline at end of file diff --git a/migrations/0006_attachment_jobs.sql b/migrations/0006_attachment_jobs.sql deleted file mode 100644 index bbf60e53..00000000 --- a/migrations/0006_attachment_jobs.sql +++ /dev/null @@ -1,49 +0,0 @@ --- staging → final prefix; job-очередь и lease -ALTER TABLE attachments - ADD COLUMN IF NOT EXISTS pipeline_version integer NOT NULL DEFAULT 1, - ADD COLUMN IF NOT EXISTS staging_key text, - ADD COLUMN IF NOT EXISTS ready_at timestamptz, - ADD COLUMN IF NOT EXISTS failed_at timestamptz, - ADD COLUMN IF NOT EXISTS error_code text; - --- idempotency эффекта: (attachment_id, pipeline_version, variant) -CREATE TABLE IF NOT EXISTS attachment_variants ( - attachment_id uuid NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, - pipeline_version integer NOT NULL, - variant text NOT NULL, - object_key text NOT NULL, - content_type text NOT NULL, - size_bytes bigint NOT NULL, - width int NOT NULL, - height int NOT NULL, - sha256 char(64) NOT NULL, - created_at timestamptz NOT NULL DEFAULT now(), - PRIMARY KEY (attachment_id, pipeline_version, variant) -); - --- outbox + очередь job-ов -CREATE TABLE IF NOT EXISTS attachment_jobs ( - job_id uuid PRIMARY KEY, - attachment_id uuid NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, - pipeline_version integer NOT NULL, - attempt int NOT NULL DEFAULT 1, - status text NOT NULL DEFAULT 'queued', -- queued|processing|done|failed - -- outbox - published_at timestamptz, - publish_attempts int NOT NULL DEFAULT 0, - -- lease - lease_owner text, - lease_expires_at timestamptz, - -- retry - next_attempt_at timestamptz NOT NULL DEFAULT now(), - last_error_code text, - created_at timestamptz NOT NULL DEFAULT now(), - updated_at timestamptz NOT NULL DEFAULT now(), - UNIQUE (attachment_id, pipeline_version) -- одна логическая работа на версию -); -CREATE INDEX IF NOT EXISTS idx_attachment_jobs_unpublished - ON attachment_jobs (next_attempt_at) - WHERE published_at IS NULL AND status = 'queued'; -CREATE INDEX IF NOT EXISTS idx_attachment_jobs_lease - ON attachment_jobs (lease_expires_at) - WHERE status = 'processing'; \ No newline at end of file diff --git a/scripts/migrate.sh b/scripts/migrate.sh index 5d3457a3..4f3d4864 100644 --- a/scripts/migrate.sh +++ b/scripts/migrate.sh @@ -6,8 +6,20 @@ URL_FILE="${DATABASE_URL_FILE:-/run/secrets/database_url}" DATABASE_URL="$(cat "$URL_FILE")" PSQL="psql $DATABASE_URL -v ON_ERROR_STOP=1 -q" -for f in migrations/*.sql; do - echo "applying $f" - $PSQL -f "$f" +echo "waiting for postgres..." +for i in $(seq 1 60); do + if psql "$DATABASE_URL" -c 'SELECT 1' >/dev/null 2>&1; then + echo "postgres is ready" + break + fi + echo " attempt $i: not ready yet" + sleep 1 +done + +psql "$DATABASE_URL" -c 'SELECT 1' >/dev/null + +for f in /app/migrations/*.sql; do + echo "applying $f" + psql "$DATABASE_URL" -v ON_ERROR_STOP=1 -f "$f" done echo "migrations done" \ No newline at end of file diff --git a/src/api/handlers.go b/src/api/handlers.go index 640f47b9..4b63ec97 100644 --- a/src/api/handlers.go +++ b/src/api/handlers.go @@ -459,7 +459,14 @@ func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { pendingID, err := h.Store.CreateAttachmentPending( r.Context(), chatID, me.ID, stagingKey, filename) if err != nil { - writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + switch { + case errors.Is(err, domain.ErrInvalid): + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment metadata") + case errors.Is(err, domain.ErrTimeout): + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout") + default: + writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable") + } return } diff --git a/src/domain/attachment_states.go b/src/domain/attachment_states.go index 17189f6e..15e27aa8 100644 --- a/src/domain/attachment_states.go +++ b/src/domain/attachment_states.go @@ -9,4 +9,4 @@ const ( const PipelineVersion = 1 -var RequiredVariants = []string{"original", "thumbnail", "crop", "optimized"} +var RequiredVariants = []string{"thumbnail", "crop", "optimized"} diff --git a/src/domain/attachments.go b/src/domain/attachments.go index c3094ec4..dd9e8137 100644 --- a/src/domain/attachments.go +++ b/src/domain/attachments.go @@ -3,6 +3,7 @@ package domain import ( "context" "errors" + "log" "math/rand" "time" @@ -48,12 +49,12 @@ func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (*A var errCode *string err := s.pool.QueryRow(ctx, ` SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, - a.status, a.error_code, a.created_at, a.updated_at, a.pipeline_version - FROM attachments a - JOIN chat_members m ON m.chat_id = a.chat_id - WHERE a.id=$1 AND m.user_id=$2`, id, userID, + a.status, a.error_code, a.created_at, a.updated_at, a.pipeline_version + FROM attachments a + JOIN chat_members m ON m.chat_id = a.chat_id + WHERE a.id=$1 AND m.user_id=$2`, id, userID, ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, - &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt) + &a.Status, &errCode, &a.CreatedAt, &a.UpdatedAt, &a.PipelineVersion) if errors.Is(err, pgx.ErrNoRows) { return nil, ErrNotFound } @@ -64,10 +65,11 @@ func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (*A a.Variants = []Variant{} rows, err := s.pool.Query(ctx, `SELECT variant, content_type, size_bytes, width, height, sha256, object_key - FROM attachment_variants - WHERE attachment_id=$1 AND pipeline_version=$2 - ORDER BY variant`, - a.ID, a.PipelineVersion) + FROM attachment_variants + WHERE attachment_id=$1 AND pipeline_version=$2 + AND variant = ANY($3) + ORDER BY variant`, + a.ID, a.PipelineVersion, RequiredVariants) if err != nil { return nil, classifyDBError(err) } @@ -111,10 +113,13 @@ func (s *Store) ValidateAttachmentIDsForChat(ctx context.Context, chatID string, return ErrInvalid } seen[id] = true - var ok bool + var status string err := s.pool.QueryRow(ctx, - `SELECT true FROM attachments WHERE id=$1 AND chat_id=$2 AND status='ready'`, - id, chatID).Scan(&ok) + `SELECT status FROM attachments WHERE id=$1 AND chat_id=$2`, + id, chatID).Scan(&status) + if err == nil && status == AttachmentFailed { + return ErrInvalid + } if errors.Is(err, pgx.ErrNoRows) { return ErrNotFound } @@ -199,10 +204,10 @@ func (s *Store) EnqueueAttachment( pipeline_version=$7, status='queued', updated_at=now() WHERE id=$1 AND status='queued' RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, - status, error_code, created_at, updated_at`, + status, error_code, created_at, updated_at, pipeline_version`, attachmentID, contentType, size, sha, w, h, pipelineVersion, ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, - &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt) + &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt, &a.PipelineVersion) if errors.Is(err, pgx.ErrNoRows) { return nil, ErrNotFound } @@ -312,10 +317,13 @@ func (s *Store) MarkReady( } for _, v := range variants { + if v.Name == "original" { + continue // original живёт в attachments.object_key, не в variants + } if _, err := tx.Exec(ctx, ` INSERT INTO attachment_variants - (attachment_id, pipeline_version, variant, object_key, - content_type, size_bytes, width, height, sha256) + (attachment_id, pipeline_version, variant, object_key, + content_type, size_bytes, width, height, sha256) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT (attachment_id, pipeline_version, variant) DO NOTHING`, attachmentID, pipelineVersion, v.Name, "final/"+attachmentID+"/"+v.Name, @@ -374,6 +382,8 @@ func (s *Store) RetryJob( if err := tx.Commit(ctx); err != nil { return false, classifyDBError(err) } + log.Printf("retry job=%s exhausted attempts=%d code=%s", + jobID, attempt, errorCode) return true, nil } @@ -388,6 +398,7 @@ func (s *Store) RetryJob( status = 'queued', last_error_code=$2, next_attempt_at=$3, + published_at=NULL, lease_owner=NULL, lease_expires_at=NULL, updated_at=now() WHERE job_id=$1`, jobID, errorCode, next); err != nil { return false, classifyDBError(err) @@ -395,16 +406,21 @@ func (s *Store) RetryJob( if err := tx.Commit(ctx); err != nil { return false, classifyDBError(err) } + // Логируем зафиксированный retry — используется в student-tests/backoff.py + log.Printf("retry job=%s attempt=%d next_attempt=%s backoff=%s jitter=%s code=%s", + jobID, attempt+1, next.UTC().Format(time.RFC3339Nano), + backoff, jitter, errorCode) + return false, nil } // RequeueStuck — reaper: обрабатывается отдельным тикером в worker/outbox. func (s *Store) RequeueStuck(ctx context.Context) (int64, error) { tag, err := s.pool.Exec(ctx, ` - UPDATE attachment_jobs - SET status='queued', lease_owner=NULL, lease_expires_at=NULL, - next_attempt_at = now(), updated_at = now() - WHERE status='processing' AND lease_expires_at < now()`) + UPDATE attachment_jobs + SET status='queued', lease_owner=NULL, lease_expires_at=NULL, + next_attempt_at = now(), published_at = NULL, updated_at = now() + WHERE status='processing' AND lease_expires_at < now()`) if err != nil { return 0, classifyDBError(err) } @@ -421,9 +437,10 @@ func (s *Store) ReplayFailed(ctx context.Context, attachmentID string) error { tag, err := tx.Exec(ctx, ` UPDATE attachment_jobs - SET status='queued', attempt=1, next_attempt_at=now(), - last_error_code=NULL, lease_owner=NULL, lease_expires_at=NULL, updated_at=now() - WHERE attachment_id=$1 AND status='failed'`, attachmentID) + SET status='queued', attempt=1, next_attempt_at=now(), + published_at=NULL, + last_error_code=NULL, lease_owner=NULL, lease_expires_at=NULL, updated_at=now() + WHERE attachment_id=$1 AND status='failed'`, attachmentID) if err != nil { return classifyDBError(err) } diff --git a/src/domain/postgres.go b/src/domain/postgres.go index 3497f4c6..a8689d1e 100644 --- a/src/domain/postgres.go +++ b/src/domain/postgres.go @@ -526,15 +526,26 @@ func (s *Store) AddMessageIdempotent( return nil, nil, false, ErrInvalid } seen[aid] = true - var ok bool + var ( + status string + objectKey string + ) + // Вложение из этого же чата; не обязательно ready — клиент увидит картинку, + // когда worker завершит обработку. failed — принимаем: сообщение уже создано, + // UI покажет «failed» через GET /attachments/{id}. if err := tx.QueryRow(ctx, - `SELECT true FROM attachments WHERE id=$1 AND chat_id=$2 AND status='ready'`, - aid, chatID).Scan(&ok); err != nil { + `SELECT status, object_key FROM attachments WHERE id=$1 AND chat_id=$2`, + aid, chatID).Scan(&status, &objectKey); err != nil { if errors.Is(err, pgx.ErrNoRows) { return nil, nil, false, ErrNotFound } return nil, nil, false, classifyDBError(err) } + if status == AttachmentFailed { + // Нельзя прикреплять заведомо неудачные вложения — иначе UI будет + // навсегда показывать сломанную картинку без пути к replay. + return nil, nil, false, ErrInvalid + } } // 2) Уже был такой ключ? diff --git a/student_tests/broker-payload.py b/student_tests/broker-payload.py new file mode 100644 index 00000000..d552066f --- /dev/null +++ b/student_tests/broker-payload.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +"""В Stream нет filename/URL/секретов — только id/version/attempt.""" +import json, sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + upload(c, a, ch, content) + raw = docker('exec', '-T', 'redis', 'redis-cli', '--raw', 'XRANGE', 'attachment.jobs', '-', '+') + ok('stream sample:\n' + raw) + lower = raw.lower() + for bad in ('filename', 'sample.png', 'staging/', 'final/', 'http', 'secret'): + check(bad not in lower, 'broker payload contains forbidden token: %s' % bad) + ok('broker payload has only ids/version/attempt') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/common.py b/student_tests/common.py new file mode 100644 index 00000000..4732d3f2 --- /dev/null +++ b/student_tests/common.py @@ -0,0 +1,73 @@ +"""Shared helpers for student lab5 tests; no tokens are logged.""" +import base64, json, os, subprocess, sys, time, uuid +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, Failure, check # noqa: E402 + +def fail(msg): + print('FAIL:', msg) + raise SystemExit(1) + +def ok(msg='PASS'): + print(msg) + +def docker(*args, check_rc=True): + """Run docker compose ; return stdout. Raises if rc!=0 and check_rc.""" + rc = subprocess.run(['docker', 'compose', *args], capture_output=True, text=True) + if check_rc and rc.returncode != 0: + raise Failure('docker compose %s: %s' % (' '.join(args), rc.stderr.strip())) + return rc.stdout + +def psql(sql): + return docker('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', + '-tAc', sql).strip() + +def upload(c, actor, chat, content, filename='sample.png', ct='image/png'): + return c.call('POST', + '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + filename, + 202, actor=actor, raw=content, headers={'Content-Type': ct}, + schema='Attachment')['json'] + +def wait_status(c, actor, att_id, want, seconds=60): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + att = c.call('GET', '/api/v1/attachments/' + att_id, actor=actor, schema='Attachment')['json'] + if att['status'] == want: + return att + if att['status'] == 'failed' and want != 'failed': + fail('attachment failed: ' + str(att.get('error_code'))) + time.sleep(0.25) + fail('attachment did not reach %s in %ss' % (want, seconds)) + +def png_bytes(w, h, seed=0): + """Generate a valid PNG without external libs. + + Быстро и с малой памятью: одна строка пикселей переиспользуется. + Для 7000x7000 занимает ~1-2 секунды и ~150 MiB RAM. + """ + import struct, zlib + + # одна строка: filter byte 0 + w * 3 байта RGB + row = bytearray(1 + w * 3) + for x in range(w): + row[1 + x*3] = (x * 7 + seed) & 0xFF + row[2 + x*3] = (x * 11) & 0xFF + row[3 + x*3] = (x * 13) & 0xFF + row = bytes(row) + + # zlib потоково, без накопления всего raw + co = zlib.compressobj(level=6) + idat_parts = [] + for y in range(h): + idat_parts.append(co.compress(row)) + idat_parts.append(co.flush()) + idat = b''.join(idat_parts) + + def chunk(t, d): + return struct.pack('>I', len(d)) + t + d + struct.pack('>I', zlib.crc32(t + d) & 0xffffffff) + + ihdr = struct.pack('>IIBBBBB', w, h, 8, 2, 0, 0, 0) + return (b'\x89PNG\r\n\x1a\n' + + chunk(b'IHDR', ihdr) + + chunk(b'IDAT', idat) + + chunk(b'IEND', b'')) \ No newline at end of file diff --git a/student_tests/crash-before-ack.py b/student_tests/crash-before-ack.py new file mode 100644 index 00000000..76e8da65 --- /dev/null +++ b/student_tests/crash-before-ack.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""kill -9 worker после S3 write до ack → повтор не создаёт дублей.""" +import sys, time, signal +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail, png_bytes + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = png_bytes(4000, 4000) + + # Сначала готовим staging+job, но без запуска worker’а. + docker('stop', 'worker') + att = upload(c, a, ch, content) + # Запускаем worker — он возьмёт processing и, скорее всего, быстро закончит. + docker('start', 'worker') + # Ловим момент processing и убиваем процесс. + deadline = time.monotonic() + 30 + while time.monotonic() < deadline: + st = psql("SELECT status FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + if st == 'processing': + break + time.sleep(0.1) + docker('kill', '-s', 'SIGKILL', 'worker') + ok('worker killed during processing') + + # После lease (60s) + reaper (30s) job должна снова стать queued. + time.sleep(100) + docker('start', 'worker') + att = wait_status(c, a, att['id'], 'ready', seconds=120) + n = int(psql("SELECT count(*) FROM attachment_variants WHERE attachment_id='%s'" % att['id'])) + check(n == 3, 'expected exactly 3 variants, got %d' % n) + ok('recovery produced exactly 3 non-original variants, no duplicates (original in object_key)') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/dlq.py b/student_tests/dlq.py new file mode 100644 index 00000000..1e90520b --- /dev/null +++ b/student_tests/dlq.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +"""Реестр failed доступен оператору (SELECT из attachment_jobs).""" +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes()[:-20] + att = upload(c, a, ch, content) + wait_status(c, a, att['id'], 'failed', seconds=180) + rows = psql( + "SELECT attachment_id, last_error_code, attempt FROM attachment_jobs " + "WHERE status='failed' ORDER BY updated_at DESC LIMIT 5") + check(rows, 'no failed jobs visible to operator') + ok('failed registry:\n' + rows) + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/failed.py b/student_tests/failed.py new file mode 100644 index 00000000..47aa8daa --- /dev/null +++ b/student_tests/failed.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +"""Битый файл: 5 attempt → failed, error_code=invalid_image.""" +import sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + # Заведомо валидный PNG в API (MIME проходит), но worker получит + # битый заголовок, если подменить staging — здесь проверяем + # реалистичный сценарий: JPEG с обрезанным хвостом. + content = (Path('tests/fixtures/sample.png')).read_bytes()[:-20] + att = upload(c, a, ch, content) + # API пропустит (DecodeConfig проходит), worker упадёт на Decode. + att = wait_status(c, a, att['id'], 'failed', seconds=180) + check(att.get('error_code') == 'invalid_image', 'unexpected error_code: %s' % att.get('error_code')) + attempts = int(psql("SELECT attempt FROM attachment_jobs WHERE attachment_id='%s'" % att['id'])) + # invalid_image — постоянная ошибка, worker не должен ретраить. + check(attempts == 1, 'permanent error must not be retried: attempt=%d' % attempts) + ok('failed immediately (attempt=1), error_code=invalid_image — permanent, not retried') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/jpeg_probe.py b/student_tests/jpeg_probe.py new file mode 100644 index 00000000..1ea8051f --- /dev/null +++ b/student_tests/jpeg_probe.py @@ -0,0 +1,28 @@ +"""Мини-парсер SOF для JPEG; без внешних библиотек.""" +from tests.client import Failure, check + + +def jpeg_size(data): + check(data[:2] == b'\xff\xd8', 'thumbnail is not JPEG') + i = 2 + sof = {0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf} + while i < len(data): + check(data[i] == 0xff, 'invalid JPEG marker') + while i < len(data) and data[i] == 0xff: + i += 1 + check(i < len(data), 'truncated JPEG marker') + marker = data[i] + i += 1 + if marker in {0xd9, 0xda}: + break + if marker in {0x01, 0xd8} or 0xd0 <= marker <= 0xd7: + continue + check(i + 2 <= len(data), 'truncated JPEG segment') + length = int.from_bytes(data[i:i + 2], 'big') + check(length >= 2 and i + length <= len(data), 'invalid JPEG segment length') + if marker in sof: + check(length >= 8, 'invalid JPEG SOF') + return (int.from_bytes(data[i + 5:i + 7], 'big'), + int.from_bytes(data[i + 3:i + 5], 'big')) + i += length + raise Failure('JPEG dimensions not found') \ No newline at end of file diff --git a/student_tests/lease.py b/student_tests/lease.py new file mode 100644 index 00000000..e77c5c50 --- /dev/null +++ b/student_tests/lease.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +"""Reaper восстанавливает job после паузы worker’а дольше lease (60с).""" +import sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail, png_bytes + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = png_bytes(4000, 4000) + + # 1) Готовим job, но worker не даём её взять. + docker('pause', 'worker') + try: + att = upload(c, a, ch, content) + finally: + pass # unpause ниже — после того, как настроим SIGSTOP + + # 2) Возобновляем worker: он возьмёт job и сразу поймает SIGSTOP. + # Используем docker kill --signal=SIGSTOP, чтобы остановить процесс + # (не контейнер). Контейнер "жив", но worker заморожен. + docker('unpause', 'worker') + + # 3) Ждём processing; как только взял — сразу SIGSTOP. + deadline = time.monotonic() + 15 + job = None + while time.monotonic() < deadline: + st = psql("SELECT status FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + if st == 'processing': + # Останавливаем процесс, пока он внутри processing. + docker('kill', '-s', 'SIGSTOP', 'worker') + job = psql("SELECT job_id FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + break + if st == 'done': + fail('job finished too fast to simulate stuck worker') + time.sleep(0.02) + + check(job is not None, 'worker never entered processing') + + # 4) Фиксируем lease_expires_at на момент SIGSTOP. + lease = psql("SELECT lease_expires_at FROM attachment_jobs WHERE job_id='%s'" % job) + ok('worker stopped at processing (job=%s, lease_expires_at=%s)' % (job, lease)) + + # 5) Ждём, пока lease протухнет и reaper вернёт job в queued. + # lease=60s, reaper=30s ⇒ до 100s; берём 120 с запасом. + deadline = time.monotonic() + 120 + requeued = False + while time.monotonic() < deadline: + st = psql("SELECT status FROM attachment_jobs WHERE job_id='%s'" % job) + if st == 'queued': + requeued = True + break + time.sleep(2) + check(requeued, 'reaper did not requeue stuck job (status=%s)' % st) + ok('reaper requeued the stuck job') + + # 6) Возобновляем worker: он должен доделать job до ready. + docker('kill', '-s', 'SIGCONT', 'worker') + att = wait_status(c, a, att['id'], 'ready', seconds=120) + ok('ready after unstuck') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/limits.py b/student_tests/limits.py new file mode 100644 index 00000000..9a0d6180 --- /dev/null +++ b/student_tests/limits.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""413, 415, 400 invalid_image — лимиты bytes/pixels/MIME.""" +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import png_bytes, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + url = '/api/v1/chats/' + ch['id'] + '/attachments?filename=x.bin' + + # 413: > 10 MiB + big = b'\x89PNG\r\n\x1a\n' + b'\x00' * (11 * 1024 * 1024) + r = c.call('POST', url, 413, actor=a, raw=big, headers={'Content-Type': 'image/png'}) + ok('413 payload_too_large') + + # 415: text/plain + r = c.call('POST', url, 415, actor=a, raw=b'hello', headers={'Content-Type': 'text/plain'}) + ok('415 unsupported_media_type') + + # 415: клиент говорит image/png, но содержимое не PNG/JPEG по DetectContentType + r = c.call('POST', url, 415, actor=a, raw=b'\x00' * 100, headers={'Content-Type': 'image/png'}) + ok('415 mismatched content (client MIME not trusted)') + + # 400: PNG-сигнатура валидна (DetectContentType -> image/png), + # но IHDR/IDAT битые -> DecodeConfig падает -> invalid_image (400) + broken_png = b'\x89PNG\r\n\x1a\n' + b'\x00' * 40 + r = c.call('POST', url, 400, actor=a, raw=broken_png, headers={'Content-Type': 'image/png'}) + ok('400 invalid image (signature ok, header broken)') + + # 400: пиксели > MAX_IMAGE_PIXELS (если выставите 1e8 — этот тест не сработает; + # по умолчанию 40 MP, значит нужно 7000x7000 ≈ 49 MP) + huge = png_bytes(7000, 7000) + r = c.call('POST', url, 400, actor=a, raw=huge, headers={'Content-Type': 'image/png'}) + ok('400 too many pixels') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/outbox.py b/student_tests/outbox.py new file mode 100644 index 00000000..da941c73 --- /dev/null +++ b/student_tests/outbox.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +"""Outbox: пауза outbox → 202 → unpause → ready; published_at=NULL в промежутке.""" +import sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + + docker('pause', 'outbox') + try: + att = upload(c, a, ch, content) + check(att['status'] == 'queued', 'expected queued') + time.sleep(3) + published = psql("SELECT coalesce(published_at::text,'NULL') FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + check(published == 'NULL', 'outbox paused but published_at=%s' % published) + ok('outbox paused: published_at IS NULL, upload accepted') + finally: + docker('unpause', 'outbox') + + att = wait_status(c, a, att['id'], 'ready', seconds=90) + ok('after unpause: ready') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/redelivery.py b/student_tests/redelivery.py new file mode 100644 index 00000000..416a7c5e --- /dev/null +++ b/student_tests/redelivery.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Повторный XADD того же job_id не создаёт дублей вариантов.""" +import json, subprocess, sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + att = upload(c, a, ch, content) + att = wait_status(c, a, att['id'], 'ready') + before = psql("SELECT count(*) FROM attachment_variants WHERE attachment_id='%s'" % att['id']) + check(before == '3', 'expected 3 variants, got %s' % before) + + job = psql("SELECT job_id FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + payload = json.dumps({ + "schema_version": 1, "job_id": job, "type": "attachment.process.v1", + "attachment_id": att['id'], "pipeline_version": 1, "attempt": 1, + "created_at": "2026-01-01T00:00:00Z", + }) + # Повторная доставка через Redis CLI. + docker('exec', '-T', 'redis', 'redis-cli', 'XADD', 'attachment.jobs', '*', 'payload', payload) + time.sleep(5) + after = psql("SELECT count(*) FROM attachment_variants WHERE attachment_id='%s'" % att['id']) + check(after == '3', 'redelivery created duplicate variants: %s' % after) + ok('redelivery is no-op (still 3 non-original variants; original via object_key)') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/replay.py b/student_tests/replay.py new file mode 100644 index 00000000..e5c20ce7 --- /dev/null +++ b/student_tests/replay.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +"""Replay failed → снова queued.""" +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + # Форсим failed (битый файл проходит DecodeConfig, но не Decode). + content = Path('tests/fixtures/sample.png').read_bytes()[:-20] + att = upload(c, a, ch, content) + att = wait_status(c, a, att['id'], 'failed', seconds=180) + ok('failed reached') + + c.call('POST', '/api/v1/attachments/' + att['id'] + '/replay', 202, actor=a) + st = psql("SELECT status FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + check(st == 'queued', 'after replay expected queued, got %s' % st) + ok('replay -> queued') + + # Replay дал одну новую попытку; ошибка permanent, поэтому снова failed при attempt=1. + att = wait_status(c, a, att['id'], 'failed', seconds=180) + atts = int(psql("SELECT attempt FROM attachment_jobs WHERE attachment_id='%s'" % att['id'])) + check(atts == 1, 'after replay: permanent error must fail at attempt=1, got %d' % atts) + ok('replay reset attempt to 1; permanent error failed again — not retried') + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/retry.py b/student_tests/retry.py new file mode 100644 index 00000000..66ce29e4 --- /dev/null +++ b/student_tests/retry.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +"""Временная ошибка S3: attempt растёт, backoff+jitter, затем ready.""" +import subprocess, sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + + # 1) Настраиваем mc с кредами — иначе удалить/положить объект не сможем. + root_user = open('secrets/minio_root_user.txt').read().strip() + root_pass = open('secrets/minio_root_password.txt').read().strip() + docker('exec', '-T', 's3', 'mc', 'alias', 'set', 'loc', + 'http://localhost:9000', root_user, root_pass, '--api', 'S3v4') + + # 2) Пауза worker’а: job не будет взят до unpause. + docker('pause', 'worker') + try: + att = upload(c, a, ch, content) + staging = psql("SELECT staging_key FROM attachments WHERE id='%s'" % att['id']) + check(staging.startswith('staging/'), 'unexpected staging_key') + + # 3) Удаляем staging: это гарантирует, что worker НЕ прочитает объект. + # Если worker ещё не стартовал — GetObject вернёт NoSuchKey. + subprocess.run( + ['docker', 'compose', 'exec', '-T', 's3', 'mc', 'rm', + 'loc/messenger-attachments/' + staging], + capture_output=True, text=True, check=True) + + # 4) Отдаём job worker’у. + docker('unpause', 'worker') + + # 5) Ждём, пока attempt >= 2. + job = psql("SELECT job_id FROM attachment_jobs WHERE attachment_id='%s'" % att['id']) + deadline = time.monotonic() + 90 + attempt = 1 + while time.monotonic() < deadline: + attempt = int(psql("SELECT attempt FROM attachment_jobs WHERE job_id='%s'" % job)) + if attempt >= 2: + break + time.sleep(1) + check(attempt >= 2, + 'retry did not happen on missing staging object (attempt=%d)' % attempt) + ok('transient error retried: attempt=%d' % attempt) + + # 6) Логи retry именно для нашего job_id. + logs = docker('logs', '--tail=500', 'worker') + lines = [l for l in logs.splitlines() + if ('retry job=' + job) in l] + check(len(lines) >= 1, 'no retry log lines for job %s:\n%s' % (job, logs[-1500:])) + ok('retry log lines:') + for l in lines: + print(' ' + l) + + # 7) Возвращаем staging — job должен пройти retry и стать ready. + # Перезаписываем объект с правильным содержимым. + # Через mc pipe: передаём байты на stdin. + r = subprocess.run( + ['docker', 'compose', 'exec', '-T', 's3', + 'mc', 'pipe', 'loc/messenger-attachments/' + staging], + input=content, capture_output=True) + check(r.returncode == 0, 'failed to restore staging: %s' % r.stderr.decode()) + + att = wait_status(c, a, att['id'], 'ready', seconds=180) + ok('recovered to ready after staging restored (attempt=%d)' % attempt) + + finally: + # На всякий случай — если упали в середине, worker не должен остаться на паузе. + subprocess.run(['docker', 'compose', 'unpause', 'worker'], + capture_output=True) + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/staging-cleanup.py b/student_tests/staging-cleanup.py new file mode 100644 index 00000000..9edba4a6 --- /dev/null +++ b/student_tests/staging-cleanup.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +"""После ready staging пуст (объект перенесён в final).""" +import sys +import subprocess +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, psql, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + att = upload(c, a, ch, content) + staging = psql("SELECT staging_key FROM attachments WHERE id='%s'" % att['id']) + check(staging.startswith('staging/'), 'staging_key does not start with staging/') + att = wait_status(c, a, att['id'], 'ready') + root_user = open('secrets/minio_root_user.txt').read().strip() + root_pass = open('secrets/minio_root_password.txt').read().strip() + docker('exec', '-T', 's3', 'mc', 'alias', 'set', 'local_check', + 'http://localhost:9000', root_user, root_pass, '--api', 'S3v4') + + r = subprocess.run( + ['docker', 'compose', 'exec', '-T', 's3', 'mc', 'stat', + 'local_check/messenger-attachments/' + staging], + capture_output=True, text=True) + combined = ((r.stdout or '') + (r.stderr or '')).lower() + check('does not exist' in combined or 'not found' in combined, + 'staging object still present: %s\n%s' % (staging, combined)) + ok('staging object removed after ready (mc rc=%d)' % r.returncode) + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/states.py b/student_tests/states.py new file mode 100644 index 00000000..ff9ae2c5 --- /dev/null +++ b/student_tests/states.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""queued → processing → ready через остановку worker’а.""" +import time, sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, docker, ok, fail + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + + docker('pause', 'worker') + try: + att = upload(c, a, ch, content) + check(att['status'] == 'queued', 'expected queued after upload') + ok('upload -> queued') + # Не должно перейти в processing, пока worker на паузе. + time.sleep(3) + att = c.call('GET', '/api/v1/attachments/' + att['id'], actor=a, schema='Attachment')['json'] + check(att['status'] == 'queued', 'worker paused but status changed to %s' % att['status']) + ok('status stays queued while worker paused') + finally: + docker('unpause', 'worker') + + att = wait_status(c, a, att['id'], 'ready', seconds=90) + names = {v['name'] for v in att['variants']} + # original в variants[] нет по контракту OpenAPI — он в object_key/оригинальном файле. + check(names == {'thumbnail', 'crop', 'optimized'}, + 'variants mismatch: %s' % names) + ok('ready with thumbnail/crop/optimized (original available via ?variant=original)') + + # original доступен отдельно — проверим, что эндпоинт отвечает 200. + r = c.call('GET', + '/api/v1/attachments/' + att['id'] + '/content?variant=original', + 200, actor=a) + check(len(r['bytes']) > 0, 'original empty') + ok('original served via ?variant=original (%d bytes)' % len(r['bytes'])) + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file diff --git a/student_tests/variants.py b/student_tests/variants.py new file mode 100644 index 00000000..13aa2310 --- /dev/null +++ b/student_tests/variants.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +"""original неизменен, thumbnail 256x256, crop 128x128, optimized существует.""" +import hashlib, sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from tests.client import Client, check +from student_tests.common import upload, wait_status, ok, fail +from student_tests.jpeg_probe import jpeg_size as dims_jpeg + +def main(): + c = Client() + a, b, e, ch = c.bootstrap() + content = Path('tests/fixtures/sample.png').read_bytes() + att = upload(c, a, ch, content) + att = wait_status(c, a, att['id'], 'ready') + src_sha = hashlib.sha256(content).hexdigest() + + def get(v): + return c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (att['id'], v), + 200, actor=a)['bytes'] + + orig = get('original') + check(hashlib.sha256(orig).hexdigest() == src_sha, 'original changed') + ok('original byte-identical') + + th = get('thumbnail') + w, h = dims_jpeg(th) + check(max(w, h) == 256 and w <= 256 and h <= 256, + 'thumbnail is %dx%d, expected fit in 256x256' % (w, h)) + check(w * 160 == h * 256 if h == 160 else True, ...) # необязательно + # Проще всего — сверить с metadata: + thumb_meta = next(v for v in att['variants'] if v['name'] == 'thumbnail') + check((w, h) == (thumb_meta['width'], thumb_meta['height']), + 'thumbnail metadata %sx%s != actual %dx%d' % (thumb_meta['width'], thumb_meta['height'], w, h)) + ok('thumbnail %dx%d (metadata matches)' % (w, h)) + + cr = get('crop') + w, h = dims_jpeg(cr) + check((w, h) == (128, 128), 'crop is %dx%d' % (w, h)) + ok('crop 128x128 JPEG') + + opt = get('optimized') + check(len(opt) > 0, 'optimized empty') + # optimized может быть JPEG или WebP; проверяем, что не пусто и похоже на изображение + check(opt[:2] == b'\xff\xd8' or opt[:4] == b'RIFF', 'optimized is not JPEG/WebP') + ok('optimized present (%d bytes)' % len(opt)) + +if __name__ == '__main__': + try: + main() + except Exception as exc: + fail(str(exc)) \ No newline at end of file -- 2.54.0