From 4f43336c186f8b00eea7a2cc70402fcc047810f4 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 17:49:28 +0300 Subject: [PATCH 01/15] chore: import lab3 baseline --- .dockerignore | 1 + .gitignore | 1 + Dockerfile | 38 ++ cmd/dependencycheck/main.go | 330 +++++++++++++ cmd/messenger/main.go | 132 ++++++ compose.yaml | 241 ++++++++++ go.mod | 43 ++ go.sum | 96 ++++ internal/config/config.go | 262 +++++++++++ internal/database/database.go | 93 ++++ internal/database/migrations.go | 150 ++++++ internal/logger/logger.go | 10 + internal/messenger/auth.go | 113 +++++ internal/messenger/errors.go | 60 +++ internal/messenger/handlers.go | 273 +++++++++++ internal/messenger/messenger_interface.go | 33 ++ internal/messenger/metrics.go | 83 ++++ internal/messenger/model.go | 29 ++ internal/messenger/request.go | 127 +++++ internal/messenger/routes.go | 41 ++ internal/messenger/server.go | 112 +++++ internal/messenger/server_test.go | 257 +++++++++++ internal/model/model.go | 82 ++++ internal/model/model_test.go | 24 + internal/password/password.go | 133 ++++++ internal/password/password_test.go | 44 ++ internal/postgres/errors.go | 11 + internal/postgres/idempotency.go | 285 ++++++++++++ internal/postgres/store.go | 435 ++++++++++++++++++ internal/postgres/store_integration_test.go | 310 +++++++++++++ internal/session/session.go | 161 +++++++ internal/session/session_integration_test.go | 72 +++ lab4.env.example | 79 ++++ migrations/0001_initial.sql | 50 ++ migrations/0002_message_idempotency.sql | 19 + migrations/embed.go | 8 + monitoring/grafana/dashboards/messenger.json | 99 ++++ .../provisioning/dashboards/messenger.yml | 10 + .../provisioning/datasources/prometheus.yml | 10 + monitoring/prometheus.yml | 23 + nginx/nginx.conf | 55 +++ scripts/restart.sh | 8 + scripts/rolling-update.sh | 57 +++ scripts/stop-one.sh | 16 + 44 files changed, 4516 insertions(+) create mode 100644 Dockerfile create mode 100644 cmd/dependencycheck/main.go 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 internal/config/config.go create mode 100644 internal/database/database.go create mode 100644 internal/database/migrations.go create mode 100644 internal/logger/logger.go create mode 100644 internal/messenger/auth.go create mode 100644 internal/messenger/errors.go create mode 100644 internal/messenger/handlers.go create mode 100644 internal/messenger/messenger_interface.go create mode 100644 internal/messenger/metrics.go create mode 100644 internal/messenger/model.go create mode 100644 internal/messenger/request.go create mode 100644 internal/messenger/routes.go create mode 100644 internal/messenger/server.go create mode 100644 internal/messenger/server_test.go create mode 100644 internal/model/model.go create mode 100644 internal/model/model_test.go create mode 100644 internal/password/password.go create mode 100644 internal/password/password_test.go create mode 100644 internal/postgres/errors.go create mode 100644 internal/postgres/idempotency.go create mode 100644 internal/postgres/store.go create mode 100644 internal/postgres/store_integration_test.go create mode 100644 internal/session/session.go create mode 100644 internal/session/session_integration_test.go create mode 100644 lab4.env.example create mode 100644 migrations/0001_initial.sql create mode 100644 migrations/0002_message_idempotency.sql create mode 100644 migrations/embed.go create mode 100644 monitoring/grafana/dashboards/messenger.json create mode 100644 monitoring/grafana/provisioning/dashboards/messenger.yml create mode 100644 monitoring/grafana/provisioning/datasources/prometheus.yml create mode 100644 monitoring/prometheus.yml create mode 100644 nginx/nginx.conf create mode 100755 scripts/restart.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh diff --git a/.dockerignore b/.dockerignore index bc16e556..ddd2c738 100644 --- a/.dockerignore +++ b/.dockerignore @@ -17,4 +17,5 @@ backups __pycache__ node_modules evidence +/messenger .DS_Store diff --git a/.gitignore b/.gitignore index b5a71896..37e0ed35 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,7 @@ dist/ build/ target/ bin/ +/messenger obj/ coverage/ *.log diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f602f140 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,38 @@ +FROM golang:1.26.5-alpine3.24 AS build + +WORKDIR /src +COPY . . +RUN go build -o /out/messenger ./cmd/messenger + +FROM build AS test + +CMD ["go", "test", "./internal/postgres", "./internal/session"] + +FROM swaggerapi/swagger-ui:v5.31.2 AS swagger + +COPY contracts/openapi.json /spec/openapi.json +ENV SWAGGER_JSON=/spec/openapi.json + +FROM prom/prometheus:v3.13.3 AS prometheus + +COPY monitoring/prometheus.yml /etc/prometheus/prometheus.yml + +FROM grafana/grafana:13.1.6 AS grafana + +COPY monitoring/grafana/provisioning /etc/grafana/provisioning +COPY monitoring/grafana/dashboards /etc/grafana/dashboards + +FROM nginx:1.30.5-alpine AS loadbalancer + +COPY nginx/nginx.conf /etc/nginx/nginx.conf + +FROM alpine:3.24.2 + +RUN addgroup -S app && adduser -S -G app -u 10001 app +COPY --from=build --chown=app:app /out/messenger /app/messenger + +USER app +WORKDIR /app +HEALTHCHECK --interval=10s --timeout=2s --start-period=5s --retries=3 \ + CMD wget -q -O /dev/null "http://127.0.0.1:${APP_PORT}/health/ready" || exit 1 +CMD ["/app/messenger"] diff --git a/cmd/dependencycheck/main.go b/cmd/dependencycheck/main.go new file mode 100644 index 00000000..eaa3d643 --- /dev/null +++ b/cmd/dependencycheck/main.go @@ -0,0 +1,330 @@ +package main + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "io" + "net/http" + "os" + "os/exec" + "strings" + "sync" + "time" + + "github.com/google/uuid" +) + +type apiClient struct { + baseURL string + client *http.Client + token string + userID string +} + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + fmt.Println("PASS: replica idempotency and dependency recovery") +} + +func run() error { + baseURL := flag.String("base-url", "http://localhost:8080", "API base URL") + flag.Parse() + client := &apiClient{baseURL: *baseURL, client: &http.Client{Timeout: 10 * time.Second}} + if err := client.registerAndLogin(); err != nil { + return err + } + if err := client.expect(http.MethodGet, "/api/v1/users/me", http.StatusOK, true); err != nil { + return err + } + if err := client.verifyConcurrentIdempotency(); err != nil { + return err + } + if err := verifyOutage(client, "valkey"); err != nil { + return err + } + return verifyOutage(client, "postgres") +} + +func (c *apiClient) registerAndLogin() error { + username := "dep_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16] + password := "T3st-" + uuid.NewString() + body := map[string]string{"username": username, "display_name": "Dependency check", "password": password} + payload, err := json.Marshal(body) + if err != nil { + return err + } + request, err := http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/users", bytes.NewReader(payload)) + if err != nil { + return err + } + request.Header.Set("Content-Type", "application/json") + response, err := c.client.Do(request) + if err != nil { + return fmt.Errorf("register: %w", err) + } + registrationBody := response.Body + defer func() { _ = registrationBody.Close() }() + if response.StatusCode != http.StatusCreated { + return fmt.Errorf("register status = %d", response.StatusCode) + } + var user struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&user); err != nil { + return fmt.Errorf("decode user: %w", err) + } + if user.ID == "" { + return fmt.Errorf("register returned an empty user id") + } + c.userID = user.ID + + request, err = http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/auth/sessions", nil) + if err != nil { + return err + } + request.SetBasicAuth(username, password) + response, err = c.client.Do(request) + if err != nil { + return fmt.Errorf("login: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return fmt.Errorf("login status = %d", response.StatusCode) + } + var session struct { + Token string `json:"token"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&session); err != nil { + return fmt.Errorf("decode session: %w", err) + } + if session.Token == "" { + return fmt.Errorf("login returned an empty token") + } + c.token = session.Token + return nil +} + +type messageResult struct { + messageID string + instanceID string + err error +} + +func (c *apiClient) verifyConcurrentIdempotency() error { + chatID, err := c.createChat() + if err != nil { + return err + } + + const workers = 16 + var ( + key = uuid.NewString() + start = make(chan struct{}) + results = make(chan messageResult, workers) + group sync.WaitGroup + instances = make(map[string]struct{}) + messageID string + ) + transport := &http.Transport{DisableKeepAlives: true, MaxConnsPerHost: workers} + client := &http.Client{Transport: transport, Timeout: 10 * time.Second} + defer transport.CloseIdleConnections() + + for range workers { + group.Add(1) + go func() { + defer group.Done() + <-start + id, instance, requestErr := c.createMessage(client, chatID, key, "concurrent message") + results <- messageResult{messageID: id, instanceID: instance, err: requestErr} + }() + } + close(start) + group.Wait() + close(results) + + for result := range results { + if result.err != nil { + return result.err + } + if result.instanceID == "" { + return fmt.Errorf("message response has an empty X-Instance-Id") + } + instances[result.instanceID] = struct{}{} + if messageID == "" { + messageID = result.messageID + } + if result.messageID != messageID { + return fmt.Errorf("idempotent responses returned different message ids") + } + } + if len(instances) < 2 { + return fmt.Errorf("requests reached %d API instance, want at least 2", len(instances)) + } + return c.verifyMessageHistory(chatID, messageID) +} + +func (c *apiClient) createChat() (string, error) { + payload, err := json.Marshal(map[string]any{ + "title": "Replica check", "member_ids": []string{c.userID}, + }) + if err != nil { + return "", err + } + request, err := http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/chats", bytes.NewReader(payload)) + if err != nil { + return "", err + } + request.Header.Set("Authorization", "Bearer "+c.token) + request.Header.Set("Content-Type", "application/json") + response, err := c.client.Do(request) + if err != nil { + return "", fmt.Errorf("create chat: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return "", fmt.Errorf("create chat status = %d", response.StatusCode) + } + var chat struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&chat); err != nil { + return "", fmt.Errorf("decode chat: %w", err) + } + return chat.ID, nil +} + +func (c *apiClient) createMessage(client *http.Client, chatID, key, text string) (string, string, error) { + payload, err := json.Marshal(map[string]string{"text": text}) + if err != nil { + return "", "", err + } + request, err := http.NewRequest( + http.MethodPost, c.baseURL+"/api/v1/chats/"+chatID+"/messages", bytes.NewReader(payload), + ) + if err != nil { + return "", "", err + } + request.Header.Set("Authorization", "Bearer "+c.token) + request.Header.Set("Content-Type", "application/json") + request.Header.Set("Idempotency-Key", key) + response, err := client.Do(request) + if err != nil { + return "", "", fmt.Errorf("create message: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return "", response.Header.Get("X-Instance-Id"), fmt.Errorf("create message status = %d", response.StatusCode) + } + var message struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&message); err != nil { + return "", response.Header.Get("X-Instance-Id"), fmt.Errorf("decode message: %w", err) + } + return message.ID, response.Header.Get("X-Instance-Id"), nil +} + +func (c *apiClient) verifyMessageHistory(chatID, messageID string) error { + request, err := http.NewRequest(http.MethodGet, c.baseURL+"/api/v1/chats/"+chatID+"/messages?limit=100", nil) + if err != nil { + return err + } + request.Header.Set("Authorization", "Bearer "+c.token) + response, err := c.client.Do(request) + if err != nil { + return fmt.Errorf("list messages: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusOK { + return fmt.Errorf("list messages status = %d", response.StatusCode) + } + var page struct { + Items []struct { + ID string `json:"id"` + } `json:"items"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&page); err != nil { + return fmt.Errorf("decode messages: %w", err) + } + if len(page.Items) != 1 || page.Items[0].ID != messageID { + return fmt.Errorf("message history contains %d items with an unexpected id", len(page.Items)) + } + return nil +} + +func verifyOutage(client *apiClient, service string) (returnErr error) { + if err := compose("stop", service); err != nil { + return err + } + defer func() { + if err := compose("up", "-d", "--wait", "--wait-timeout", "90", service); returnErr == nil && err != nil { + returnErr = err + } + }() + if err := client.expectEventually("/health/ready", http.StatusServiceUnavailable, false); err != nil { + return fmt.Errorf("%s readiness outage: %w", service, err) + } + if err := client.expectEventually("/api/v1/users/me", http.StatusServiceUnavailable, true); err != nil { + return fmt.Errorf("%s business outage: %w", service, err) + } + if err := compose("up", "-d", "--wait", "--wait-timeout", "90", service); err != nil { + return err + } + if err := client.expectEventually("/health/ready", http.StatusOK, false); err != nil { + return fmt.Errorf("%s readiness recovery: %w", service, err) + } + if err := client.expectEventually("/api/v1/users/me", http.StatusOK, true); err != nil { + return fmt.Errorf("%s session recovery: %w", service, err) + } + return nil +} + +func compose(arguments ...string) error { + command := exec.Command("docker", append([]string{"compose"}, arguments...)...) + if output, err := command.CombinedOutput(); err != nil { + return fmt.Errorf("docker compose %v: %w: %s", arguments, err, bytes.TrimSpace(output)) + } + return nil +} + +func (c *apiClient) expectEventually(path string, status int, authenticated bool) error { + deadline := time.Now().Add(20 * time.Second) + var lastErr error + for time.Now().Before(deadline) { + lastErr = c.expect(http.MethodGet, path, status, authenticated) + if lastErr == nil { + return nil + } + time.Sleep(200 * time.Millisecond) + } + return lastErr +} + +func (c *apiClient) expect(method, path string, status int, authenticated bool) error { + request, err := http.NewRequest(method, c.baseURL+path, nil) + if err != nil { + return err + } + if authenticated { + request.Header.Set("Authorization", "Bearer "+c.token) + } + response, err := c.client.Do(request) + if err != nil { + return err + } + return closeResponse(response, status) +} + +func closeResponse(response *http.Response, status int) error { + defer func() { _ = response.Body.Close() }() + _, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 1<<20)) + if response.StatusCode != status { + return fmt.Errorf("status = %d, want %d", response.StatusCode, status) + } + return nil +} diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go new file mode 100644 index 00000000..76ed2d19 --- /dev/null +++ b/cmd/messenger/main.go @@ -0,0 +1,132 @@ +package main + +import ( + "context" + "fmt" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "syscall" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/logger" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" +) + +func main() { + appLogger := logger.New() + if err := run(appLogger, os.Args[1:]); err != nil { + appLogger.Error("server stopped", "error", err) + os.Exit(1) + } +} + +func run(logger *slog.Logger, arguments []string) error { + if len(arguments) == 0 { + return runServer(logger) + } + if len(arguments) == 1 && arguments[0] == "migrate" { + return runMigrations() + } + return fmt.Errorf("usage: messenger [migrate]") +} + +func runServer(logger *slog.Logger) error { + settings, err := config.Load() + if err != nil { + return err + } + instanceID, err := os.Hostname() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + sessions, err := session.New(settings.CacheURL) + if err != nil { + return err + } + defer func() { _ = sessions.Close() }() + passwords, err := password.New(password.Config{ + MemoryKiB: settings.PasswordMemoryKiB, Iterations: settings.PasswordIterations, + Parallelism: settings.PasswordParallelism, SaltLength: settings.PasswordSaltLength, + KeyLength: settings.PasswordKeyLength, + }) + if err != nil { + return err + } + app := messenger.NewServer( + logger, + postgres.New(pool), + sessions, + passwords, + settings.SessionTTL, + settings.IdempotencyTTL, + settings.RequestTimeout, + instanceID, + settings.SwaggerPort, + ) + server := &http.Server{ + Addr: settings.Address, + Handler: app.Handler(), + ReadHeaderTimeout: settings.HTTPReadHeaderTimeout, + ReadTimeout: settings.HTTPReadTimeout, + WriteTimeout: settings.HTTPWriteTimeout, + IdleTimeout: settings.HTTPIdleTimeout, + } + listener, err := net.Listen("tcp", server.Addr) + if err != nil { + return err + } + serveResult := make(chan error, 1) + go func() { + serveResult <- server.Serve(listener) + }() + logger.Info("server started", "address", server.Addr) + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + select { + case err := <-serveResult: + return err + case <-ctx.Done(): + logger.Info("shutdown requested") + app.SetReady(false) + shutdownCtx, cancel := context.WithTimeout(context.Background(), settings.HTTPShutdownTimeout) + defer cancel() + if err := server.Shutdown(shutdownCtx); err != nil { + _ = server.Close() + return err + } + return nil + } +} + +func runMigrations() error { + settings, err := config.LoadMigration() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + return database.Migrate(context.Background(), pool, settings.MigrationTimeout) +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2192f643 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,241 @@ +services: + postgres: + image: postgres:17.6-alpine3.22 + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 20 + cpus: ${POSTGRES_CPUS} + mem_limit: ${POSTGRES_MEMORY} + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1.4-alpine + command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--requirepass", "${VALKEY_PASSWORD}"] + environment: + VALKEY_PASSWORD: ${VALKEY_PASSWORD} + volumes: + - valkey_data:/data + healthcheck: + test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$VALKEY_PASSWORD\" ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 20 + cpus: ${VALKEY_CPUS} + mem_limit: ${VALKEY_MEMORY} + restart: unless-stopped + + migrate: + image: ${API_IMAGE:-mtusi-messenger:lab4} + command: ["/app/messenger", "migrate"] + environment: + DATABASE_URL: ${DATABASE_URL} + DB_MIN_CONNS: ${DB_MIN_CONNS} + DB_MAX_CONNS: ${DB_MAX_CONNS} + DB_MAX_CONNECTION_AGE_SECONDS: ${DB_MAX_CONNECTION_AGE_SECONDS} + DB_MAX_CONNECTION_IDLE_SECONDS: ${DB_MAX_CONNECTION_IDLE_SECONDS} + DB_HEALTH_CHECK_SECONDS: ${DB_HEALTH_CHECK_SECONDS} + DEPENDENCY_TIMEOUT_SECONDS: ${DEPENDENCY_TIMEOUT_SECONDS} + MIGRATION_TIMEOUT_SECONDS: ${MIGRATION_TIMEOUT_SECONDS} + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + cpus: ${MIGRATE_CPUS} + mem_limit: ${MIGRATE_MEMORY} + restart: "no" + + api: + build: . + image: ${API_IMAGE:-mtusi-messenger:lab4} + environment: + APP_HOST: ${APP_HOST} + APP_PORT: ${APP_PORT} + DATABASE_URL: ${DATABASE_URL} + CACHE_URL: ${CACHE_URL} + SESSION_STORE: ${SESSION_STORE} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS} + DB_MIN_CONNS: ${DB_MIN_CONNS} + DB_MAX_CONNS: ${DB_MAX_CONNS} + DB_MAX_CONNECTION_AGE_SECONDS: ${DB_MAX_CONNECTION_AGE_SECONDS} + DB_MAX_CONNECTION_IDLE_SECONDS: ${DB_MAX_CONNECTION_IDLE_SECONDS} + DB_HEALTH_CHECK_SECONDS: ${DB_HEALTH_CHECK_SECONDS} + DEPENDENCY_TIMEOUT_SECONDS: ${DEPENDENCY_TIMEOUT_SECONDS} + REQUEST_TIMEOUT_SECONDS: ${REQUEST_TIMEOUT_SECONDS} + HTTP_READ_HEADER_TIMEOUT_SECONDS: ${HTTP_READ_HEADER_TIMEOUT_SECONDS} + HTTP_READ_TIMEOUT_SECONDS: ${HTTP_READ_TIMEOUT_SECONDS} + HTTP_WRITE_TIMEOUT_SECONDS: ${HTTP_WRITE_TIMEOUT_SECONDS} + HTTP_IDLE_TIMEOUT_SECONDS: ${HTTP_IDLE_TIMEOUT_SECONDS} + HTTP_SHUTDOWN_TIMEOUT_SECONDS: ${HTTP_SHUTDOWN_TIMEOUT_SECONDS} + PASSWORD_MEMORY_KIB: ${PASSWORD_MEMORY_KIB} + PASSWORD_ITERATIONS: ${PASSWORD_ITERATIONS} + PASSWORD_PARALLELISM: ${PASSWORD_PARALLELISM} + PASSWORD_SALT_LENGTH: ${PASSWORD_SALT_LENGTH} + PASSWORD_KEY_LENGTH: ${PASSWORD_KEY_LENGTH} + SWAGGER_PORT: ${SWAGGER_PORT} + expose: + - "8080" + depends_on: + migrate: + condition: service_completed_successfully + valkey: + condition: service_healthy + healthcheck: + test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:${APP_PORT}/health/ready || exit 1"] + interval: 2s + timeout: 1s + start_period: 5s + retries: 2 + deploy: + replicas: ${API_REPLICAS:-2} + cpus: ${API_CPUS} + mem_limit: ${API_MEMORY} + stop_grace_period: 8s + restart: unless-stopped + + nginx: + build: + context: . + target: loadbalancer + image: ${NGINX_IMAGE:-mtusi-nginx:lab4} + ports: + - "${API_BIND_ADDRESS}:8080" + depends_on: + api: + condition: service_healthy + healthcheck: + test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8081/stub_status || exit 1"] + interval: 2s + timeout: 1s + retries: 10 + cpus: ${NGINX_CPUS} + mem_limit: ${NGINX_MEMORY} + restart: unless-stopped + + swagger: + build: + context: . + target: swagger + image: ${SWAGGER_IMAGE:-mtusi-swagger:lab4} + ports: + - "${SWAGGER_BIND_ADDRESS}:8080" + depends_on: + nginx: + condition: service_healthy + cpus: ${SWAGGER_CPUS} + mem_limit: ${SWAGGER_MEMORY} + restart: unless-stopped + + tests: + profiles: ["tests"] + build: + context: . + target: test + environment: + TEST_DATABASE_URL: ${DATABASE_URL} + TEST_CACHE_URL: ${CACHE_URL} + depends_on: + migrate: + condition: service_completed_successfully + valkey: + condition: service_healthy + cpus: ${TEST_CPUS} + mem_limit: ${TEST_MEMORY} + + postgres-exporter: + image: quay.io/prometheuscommunity/postgres-exporter:v0.20.1 + environment: + DATA_SOURCE_URI: postgres:5432/${POSTGRES_DB}?sslmode=disable + DATA_SOURCE_USER: ${POSTGRES_USER} + DATA_SOURCE_PASS: ${POSTGRES_PASSWORD} + PG_EXPORTER_COLLECTION_TIMEOUT: 5s + depends_on: + postgres: + condition: service_healthy + cpus: ${EXPORTER_CPUS} + mem_limit: ${EXPORTER_MEMORY} + restart: unless-stopped + + valkey-exporter: + image: oliver006/redis_exporter:v1.89.0-alpine + environment: + REDIS_ADDR: redis://valkey:6379 + REDIS_USER: default + REDIS_PASSWORD: ${VALKEY_PASSWORD} + depends_on: + valkey: + condition: service_healthy + cpus: ${EXPORTER_CPUS} + mem_limit: ${EXPORTER_MEMORY} + restart: unless-stopped + + nginx-exporter: + image: nginx/nginx-prometheus-exporter:1.5.1 + command: ["--nginx.scrape-uri=http://nginx:8081/stub_status"] + depends_on: + nginx: + condition: service_healthy + cpus: ${EXPORTER_CPUS} + mem_limit: ${EXPORTER_MEMORY} + restart: unless-stopped + + prometheus: + build: + context: . + target: prometheus + image: ${PROMETHEUS_IMAGE:-mtusi-prometheus:lab4} + command: + - --config.file=/etc/prometheus/prometheus.yml + - --storage.tsdb.path=/prometheus + - --storage.tsdb.retention.time=7d + volumes: + - prometheus_data:/prometheus + ports: + - "${PROMETHEUS_BIND_ADDRESS}:9090" + healthcheck: + test: ["CMD", "promtool", "query", "instant", "http://127.0.0.1:9090", "up"] + interval: 5s + timeout: 3s + retries: 20 + depends_on: + - api + - nginx-exporter + - postgres-exporter + - valkey-exporter + cpus: ${PROMETHEUS_CPUS} + mem_limit: ${PROMETHEUS_MEMORY} + restart: unless-stopped + + grafana: + build: + context: . + target: grafana + image: ${GRAFANA_IMAGE:-mtusi-grafana:lab4} + environment: + GF_SECURITY_ADMIN_USER: admin + GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD} + GF_USERS_ALLOW_SIGN_UP: "false" + volumes: + - grafana_data:/var/lib/grafana + ports: + - "${GRAFANA_BIND_ADDRESS}:3000" + depends_on: + - prometheus + cpus: ${GRAFANA_CPUS} + mem_limit: ${GRAFANA_MEMORY} + restart: unless-stopped + +volumes: + postgres_data: + valkey_data: + prometheus_data: + grafana_data: diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..f498f1b3 --- /dev/null +++ b/go.mod @@ -0,0 +1,43 @@ +module gitea.privcloud.tech/dizi/mtusi2026lab4 + +go 1.26.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.11.0 + github.com/prometheus/client_golang v1.23.2 + github.com/spf13/viper v1.21.0 + github.com/stretchr/testify v1.11.1 + github.com/valkey-io/valkey-go v1.0.78 + golang.org/x/crypto v0.57.0 +) + +require ( + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/pelletier/go-toml/v2 v2.2.4 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.66.1 // indirect + github.com/prometheus/procfs v0.16.1 // indirect + github.com/sagikazarmark/locafero v0.11.0 // indirect + github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect + github.com/spf13/afero v1.15.0 // indirect + github.com/spf13/cast v1.10.0 // indirect + github.com/spf13/pflag v1.0.10 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/sync v0.23.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect + google.golang.org/protobuf v1.36.8 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..e55a574b --- /dev/null +++ b/go.sum @@ -0,0 +1,96 @@ +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I= +github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg= +github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= +github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= +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/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= +github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA= +github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= +github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= +github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= +github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc= +github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= +github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I= +github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= +github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= +github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= +github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= +github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU= +github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= +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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/valkey-io/valkey-go v1.0.78 h1:1Ce8hRaaNXpKfqmqZQRhnbVh1eW8MGR873pdXVvE4y8= +github.com/valkey-io/valkey-go v1.0.78/go.mod h1:gvC/r2m3eW4Hbj0YnjogTzNtFdPSM/D+NCqen+5OABM= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M= +golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc= +google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..44571418 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,262 @@ +package config + +import ( + "errors" + "fmt" + "net" + "strconv" + "strings" + "time" + + "github.com/spf13/viper" +) + +type Config struct { + Address string + DatabaseURL string + CacheURL string + SessionTTL time.Duration + IdempotencyTTL time.Duration + DBMaxConns int32 + DBMinConns int32 + DBMaxConnectionAge time.Duration + DBMaxConnectionIdle time.Duration + DBHealthCheckPeriod time.Duration + DependencyTimeout time.Duration + RequestTimeout time.Duration + HTTPReadHeaderTimeout time.Duration + HTTPReadTimeout time.Duration + HTTPWriteTimeout time.Duration + HTTPIdleTimeout time.Duration + HTTPShutdownTimeout time.Duration + PasswordMemoryKiB uint32 + PasswordIterations uint32 + PasswordParallelism uint8 + PasswordSaltLength uint32 + PasswordKeyLength uint32 + SwaggerPort string +} + +type MigrationConfig struct { + DatabaseURL string + DBMaxConns int32 + DBMinConns int32 + DBMaxConnectionAge time.Duration + DBMaxConnectionIdle time.Duration + DBHealthCheckPeriod time.Duration + DependencyTimeout time.Duration + MigrationTimeout time.Duration +} + +type databaseConfig struct { + url string + maxConns int + minConns int + maxConnectionAge time.Duration + maxConnectionIdle time.Duration + healthCheckPeriod time.Duration + dependencyTimeout time.Duration +} + +func Load() (Config, error) { + values := viper.New() + values.AutomaticEnv() + + host, err := requiredString(values, "APP_HOST") + if err != nil { + return Config{}, err + } + port, err := requiredPort(values, "APP_PORT") + if err != nil { + return Config{}, err + } + database, err := loadDatabaseConfig(values) + if err != nil { + return Config{}, err + } + cacheURL, err := requiredString(values, "CACHE_URL") + if err != nil { + return Config{}, err + } + store, err := requiredString(values, "SESSION_STORE") + if err != nil { + return Config{}, err + } + if store != "valkey" { + return Config{}, errors.New("SESSION_STORE must be valkey") + } + + sessionTTL, err := seconds(values, "SESSION_TTL_SECONDS", 1, 86400*30) + if err != nil { + return Config{}, err + } + idempotencyTTL, err := seconds(values, "IDEMPOTENCY_TTL_SECONDS", 86400, 86400*30) + if err != nil { + return Config{}, err + } + requestTimeout, err := seconds(values, "REQUEST_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + readHeaderTimeout, err := seconds(values, "HTTP_READ_HEADER_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + readTimeout, err := seconds(values, "HTTP_READ_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + writeTimeout, err := seconds(values, "HTTP_WRITE_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + idleTimeout, err := seconds(values, "HTTP_IDLE_TIMEOUT_SECONDS", 1, 3600) + if err != nil { + return Config{}, err + } + shutdownTimeout, err := seconds(values, "HTTP_SHUTDOWN_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + passwordMemory, err := integer(values, "PASSWORD_MEMORY_KIB", 8*1024, 1024*1024) + if err != nil { + return Config{}, err + } + passwordIterations, err := integer(values, "PASSWORD_ITERATIONS", 1, 20) + if err != nil { + return Config{}, err + } + passwordParallelism, err := integer(values, "PASSWORD_PARALLELISM", 1, 255) + if err != nil { + return Config{}, err + } + passwordSaltLength, err := integer(values, "PASSWORD_SALT_LENGTH", 8, 1024) + if err != nil { + return Config{}, err + } + passwordKeyLength, err := integer(values, "PASSWORD_KEY_LENGTH", 16, 1024) + if err != nil { + return Config{}, err + } + swaggerPort, err := requiredPort(values, "SWAGGER_PORT") + if err != nil { + return Config{}, err + } + + return Config{ + Address: net.JoinHostPort(host, port), DatabaseURL: database.url, CacheURL: cacheURL, + SessionTTL: sessionTTL, IdempotencyTTL: idempotencyTTL, + DBMaxConns: int32(database.maxConns), DBMinConns: int32(database.minConns), + DBMaxConnectionAge: database.maxConnectionAge, DBMaxConnectionIdle: database.maxConnectionIdle, + DBHealthCheckPeriod: database.healthCheckPeriod, DependencyTimeout: database.dependencyTimeout, + RequestTimeout: requestTimeout, + HTTPReadHeaderTimeout: readHeaderTimeout, HTTPReadTimeout: readTimeout, + HTTPWriteTimeout: writeTimeout, HTTPIdleTimeout: idleTimeout, + HTTPShutdownTimeout: shutdownTimeout, PasswordMemoryKiB: uint32(passwordMemory), + PasswordIterations: uint32(passwordIterations), PasswordParallelism: uint8(passwordParallelism), + PasswordSaltLength: uint32(passwordSaltLength), PasswordKeyLength: uint32(passwordKeyLength), + SwaggerPort: swaggerPort, + }, nil +} + +func LoadMigration() (MigrationConfig, error) { + values := viper.New() + values.AutomaticEnv() + database, err := loadDatabaseConfig(values) + if err != nil { + return MigrationConfig{}, err + } + migrationTimeout, err := seconds(values, "MIGRATION_TIMEOUT_SECONDS", 1, 600) + if err != nil { + return MigrationConfig{}, err + } + return MigrationConfig{ + DatabaseURL: database.url, DBMaxConns: int32(database.maxConns), DBMinConns: int32(database.minConns), + DBMaxConnectionAge: database.maxConnectionAge, DBMaxConnectionIdle: database.maxConnectionIdle, + DBHealthCheckPeriod: database.healthCheckPeriod, DependencyTimeout: database.dependencyTimeout, + MigrationTimeout: migrationTimeout, + }, nil +} + +func loadDatabaseConfig(values *viper.Viper) (databaseConfig, error) { + databaseURL, err := requiredString(values, "DATABASE_URL") + if err != nil { + return databaseConfig{}, err + } + maxConns, err := integer(values, "DB_MAX_CONNS", 1, 100) + if err != nil { + return databaseConfig{}, err + } + minConns, err := integer(values, "DB_MIN_CONNS", 0, maxConns) + if err != nil { + return databaseConfig{}, err + } + maxConnectionAge, err := seconds(values, "DB_MAX_CONNECTION_AGE_SECONDS", 1, 86400) + if err != nil { + return databaseConfig{}, err + } + maxConnectionIdle, err := seconds(values, "DB_MAX_CONNECTION_IDLE_SECONDS", 1, 86400) + if err != nil { + return databaseConfig{}, err + } + healthCheckPeriod, err := seconds(values, "DB_HEALTH_CHECK_SECONDS", 1, 3600) + if err != nil { + return databaseConfig{}, err + } + dependencyTimeout, err := seconds(values, "DEPENDENCY_TIMEOUT_SECONDS", 1, 60) + if err != nil { + return databaseConfig{}, err + } + return databaseConfig{ + url: databaseURL, maxConns: maxConns, minConns: minConns, + maxConnectionAge: maxConnectionAge, maxConnectionIdle: maxConnectionIdle, + healthCheckPeriod: healthCheckPeriod, dependencyTimeout: dependencyTimeout, + }, nil +} + +func requiredString(values *viper.Viper, name string) (string, error) { + value := strings.TrimSpace(values.GetString(name)) + if value == "" { + return "", fmt.Errorf("%s is required", name) + } + return value, nil +} + +func requiredPort(values *viper.Viper, name string) (string, error) { + value, err := requiredString(values, name) + if err != nil { + return "", err + } + if _, err := integerValue(value, 1, 65535); err != nil { + return "", fmt.Errorf("%s: %w", name, err) + } + return value, nil +} + +func seconds(values *viper.Viper, name string, minimum, maximum int) (time.Duration, error) { + value, err := integer(values, name, minimum, maximum) + if err != nil { + return 0, err + } + return time.Duration(value) * time.Second, nil +} + +func integer(values *viper.Viper, name string, minimum, maximum int) (int, error) { + value, err := requiredString(values, name) + if err != nil { + return 0, err + } + parsed, err := integerValue(value, minimum, maximum) + if err != nil { + return 0, fmt.Errorf("%s: %w", name, err) + } + return parsed, nil +} + +func integerValue(value string, minimum, maximum int) (int, error) { + parsed, err := strconv.Atoi(value) + if err != nil || parsed < minimum || parsed > maximum { + return 0, fmt.Errorf("must be between %d and %d", minimum, maximum) + } + return parsed, nil +} diff --git a/internal/database/database.go b/internal/database/database.go new file mode 100644 index 00000000..0aa4ff4b --- /dev/null +++ b/internal/database/database.go @@ -0,0 +1,93 @@ +package database + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/migrations" +) + +var ( + errURLRequired = errors.New("database URL is required") + errMinConnections = errors.New("minimum database connections must not be negative") + errMaxConnections = errors.New("maximum database connections must be positive") + errConnectionRange = errors.New("minimum database connections exceed maximum") + errMaxConnectionAge = errors.New("maximum database connection age must be positive") + errMaxConnectionIdle = errors.New("maximum database connection idle time must be positive") + errHealthCheckPeriod = errors.New("database health check period must be positive") + errConnectionTimeout = errors.New("database connection timeout must be positive") +) + +type Config struct { + URL string + MinConnections int32 + MaxConnections int32 + MaxConnectionAge time.Duration + MaxConnectionIdle time.Duration + HealthCheckPeriod time.Duration + ConnectTimeout time.Duration +} + +func Open(ctx context.Context, config Config) (*pgxpool.Pool, error) { + if err := validateConfig(config); err != nil { + return nil, err + } + poolConfig, err := pgxpool.ParseConfig(config.URL) + if err != nil { + return nil, fmt.Errorf("parse database configuration: %w", err) + } + poolConfig.MinConns = config.MinConnections + poolConfig.MaxConns = config.MaxConnections + poolConfig.MaxConnLifetime = config.MaxConnectionAge + poolConfig.MaxConnIdleTime = config.MaxConnectionIdle + poolConfig.HealthCheckPeriod = config.HealthCheckPeriod + + connectCtx, cancel := context.WithTimeout(ctx, config.ConnectTimeout) + defer cancel() + pool, err := pgxpool.NewWithConfig(connectCtx, poolConfig) + if err != nil { + return nil, fmt.Errorf("create database pool: %w", err) + } + if err := pool.Ping(connectCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping database: %w", err) + } + + return pool, nil +} + +func Migrate(ctx context.Context, pool *pgxpool.Pool, timeout time.Duration) error { + if timeout <= 0 { + return errors.New("database migration timeout must be positive") + } + migrationCtx, cancel := context.WithTimeout(ctx, timeout) + defer cancel() + return applyMigrations(migrationCtx, pool, migrations.FS) +} + +func validateConfig(config Config) error { + switch { + case config.URL == "": + return errURLRequired + case config.MinConnections < 0: + return errMinConnections + case config.MaxConnections < 1: + return errMaxConnections + case config.MinConnections > config.MaxConnections: + return errConnectionRange + case config.MaxConnectionAge <= 0: + return errMaxConnectionAge + case config.MaxConnectionIdle <= 0: + return errMaxConnectionIdle + case config.HealthCheckPeriod <= 0: + return errHealthCheckPeriod + case config.ConnectTimeout <= 0: + return errConnectionTimeout + default: + return nil + } +} diff --git a/internal/database/migrations.go b/internal/database/migrations.go new file mode 100644 index 00000000..095c93d1 --- /dev/null +++ b/internal/database/migrations.go @@ -0,0 +1,150 @@ +package database + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "io/fs" + "path/filepath" + "regexp" + "sort" + "strconv" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +const ( + migrationLockID int64 = 0x4d54555349324c42 + migrationUnlockTimeout = 5 * time.Second +) + +var migrationNamePattern = regexp.MustCompile(`^(\d+)_([a-z0-9_]+)\.sql$`) + +type migration struct { + version int64 + name string + checksum string + sql string +} + +func applyMigrations(ctx context.Context, pool *pgxpool.Pool, migrationFS fs.FS) (returnErr error) { + migrations, err := readMigrations(migrationFS) + if err != nil { + return err + } + connection, err := pool.Acquire(ctx) + if err != nil { + return fmt.Errorf("acquire connection for migrations: %w", err) + } + defer connection.Release() + if _, err := connection.Exec(ctx, "SELECT pg_advisory_lock($1)", migrationLockID); err != nil { + return fmt.Errorf("lock migrations: %w", err) + } + defer func() { + unlockCtx, cancel := context.WithTimeout(context.Background(), migrationUnlockTimeout) + defer cancel() + if _, err := connection.Exec(unlockCtx, "SELECT pg_advisory_unlock($1)", migrationLockID); err != nil { + _ = connection.Conn().Close(unlockCtx) + if returnErr == nil { + returnErr = fmt.Errorf("unlock migrations: %w", err) + } + } + }() + + if _, err := connection.Exec(ctx, ` +CREATE TABLE IF NOT EXISTS schema_migrations ( + version BIGINT PRIMARY KEY, + name TEXT NOT NULL, + checksum TEXT NOT NULL, + applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp() +)`); err != nil { + return fmt.Errorf("create migration history: %w", err) + } + for _, migration := range migrations { + if err := applyMigration(ctx, connection, migration); err != nil { + return err + } + } + return nil +} + +func readMigrations(migrationFS fs.FS) ([]migration, error) { + entries, err := fs.ReadDir(migrationFS, ".") + if err != nil { + return nil, fmt.Errorf("read embedded migrations: %w", err) + } + migrations := make([]migration, 0, len(entries)) + versions := make(map[int64]string) + for _, entry := range entries { + if entry.IsDir() || filepath.Ext(entry.Name()) != ".sql" { + continue + } + matches := migrationNamePattern.FindStringSubmatch(entry.Name()) + if matches == nil { + return nil, fmt.Errorf("invalid migration filename %q", entry.Name()) + } + version, err := strconv.ParseInt(matches[1], 10, 64) + if err != nil || version < 1 { + return nil, fmt.Errorf("invalid migration version in %q", entry.Name()) + } + if previous, exists := versions[version]; exists { + return nil, fmt.Errorf("migration version %d is used by %q and %q", version, previous, entry.Name()) + } + data, err := fs.ReadFile(migrationFS, entry.Name()) + if err != nil { + return nil, fmt.Errorf("read migration %q: %w", entry.Name(), err) + } + hash := sha256.Sum256(data) + versions[version] = entry.Name() + migrations = append(migrations, migration{ + version: version, + name: entry.Name(), + checksum: hex.EncodeToString(hash[:]), + sql: string(data), + }) + } + if len(migrations) == 0 { + return nil, errors.New("no database migrations found") + } + sort.Slice(migrations, func(i, j int) bool { + return migrations[i].version < migrations[j].version + }) + return migrations, nil +} + +func applyMigration(ctx context.Context, connection *pgxpool.Conn, migration migration) error { + var checksum string + err := connection.QueryRow(ctx, "SELECT checksum FROM schema_migrations WHERE version = $1", migration.version).Scan(&checksum) + switch { + case err == nil && checksum != migration.checksum: + return fmt.Errorf("migration %q checksum does not match applied version", migration.name) + case err == nil: + return nil + case !errors.Is(err, pgx.ErrNoRows): + return fmt.Errorf("read migration %q state: %w", migration.name, err) + } + + transaction, err := connection.Begin(ctx) + if err != nil { + return fmt.Errorf("begin migration %q: %w", migration.name, err) + } + defer func() { + _ = transaction.Rollback(context.WithoutCancel(ctx)) + }() + if _, err := transaction.Exec(ctx, migration.sql, pgx.QueryExecModeSimpleProtocol); err != nil { + return fmt.Errorf("apply migration %q: %w", migration.name, err) + } + if _, err := transaction.Exec(ctx, ` +INSERT INTO schema_migrations (version, name, checksum) +VALUES ($1, $2, $3)`, migration.version, migration.name, migration.checksum); err != nil { + return fmt.Errorf("record migration %q: %w", migration.name, err) + } + if err := transaction.Commit(ctx); err != nil { + return fmt.Errorf("commit migration %q: %w", migration.name, err) + } + return nil +} diff --git a/internal/logger/logger.go b/internal/logger/logger.go new file mode 100644 index 00000000..ab813660 --- /dev/null +++ b/internal/logger/logger.go @@ -0,0 +1,10 @@ +package logger + +import ( + "log/slog" + "os" +) + +func New() *slog.Logger { + return slog.New(slog.NewJSONHandler(os.Stdout, nil)) +} diff --git a/internal/messenger/auth.go b/internal/messenger/auth.go new file mode 100644 index 00000000..74132223 --- /dev/null +++ b/internal/messenger/auth.go @@ -0,0 +1,113 @@ +package messenger + +import ( + "errors" + "io" + "net/http" + "strings" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" +) + +func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + body, err := io.ReadAll(io.LimitReader(r.Body, 1)) + if err != nil || len(body) != 0 { + return invalidRequest() + } + username, passwordValue, ok := singleBasicAuth(r) + if !ok { + return unauthorized() + } + credentials, err := s.messengerStore.UserByUsername(r.Context(), username) + if errors.Is(err, postgres.ErrNotFound) { + if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil { + return internalError() + } + return unauthorized() + } + if err != nil { + return unavailable() + } + verified, err := s.passwords.Verify(passwordValue, credentials.PasswordHash) + if err != nil { + return internalError() + } + if !verified { + return unauthorized() + } + token, expiresAt, err := s.sessions.Create(r.Context(), credentials.ID, s.sessionTTL) + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User User `json:"user"` + }{token, "Bearer", model.FormatTime(expiresAt), credentials.User}) + return nil +} + +func singleBasicAuth(r *http.Request) (string, string, bool) { + if len(r.Header.Values("Authorization")) != 1 { + return "", "", false + } + username, passwordValue, ok := r.BasicAuth() + return username, passwordValue, ok && username != "" +} + +func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodDelete { + return methodNotAllowed(w, http.MethodDelete) + } + _, token, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if err := s.sessions.Delete(r.Context(), token); errors.Is(err, session.ErrNotFound) { + return unauthorized() + } else if err != nil { + return unavailable() + } + w.WriteHeader(http.StatusNoContent) + return nil +} + +func (s *Server) authenticate(r *http.Request) (User, string, *apiError) { + values := r.Header.Values("Authorization") + if len(values) != 1 { + return User{}, "", unauthorized() + } + scheme, token, found := strings.Cut(values[0], " ") + if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t\r\n") { + return User{}, "", unauthorized() + } + userID, err := s.sessions.UserID(r.Context(), token) + if errors.Is(err, session.ErrNotFound) || errors.Is(err, session.ErrInvalidToken) { + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + user, err := s.messengerStore.UserByID(r.Context(), userID) + if errors.Is(err, postgres.ErrNotFound) { + _ = s.sessions.Delete(r.Context(), token) + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + return user, token, nil +} + +func authenticationChallenge(r *http.Request) string { + if r.URL.Path == "/api/v1/auth/sessions" { + return `Basic realm="messenger", charset="UTF-8"` + } + return `Bearer realm="messenger"` +} diff --git a/internal/messenger/errors.go b/internal/messenger/errors.go new file mode 100644 index 00000000..88d29705 --- /dev/null +++ b/internal/messenger/errors.go @@ -0,0 +1,60 @@ +package messenger + +import ( + "encoding/json" + "net/http" +) + +const ( + errorCodeInvalidRequest = "invalid_request" + errorCodeUnauthorized = "unauthorized" + errorCodeNotFound = "not_found" + errorCodeInternal = "internal_error" + errorCodeUnsupportedMediaType = "unsupported_media_type" + errorCodePayloadTooLarge = "payload_too_large" + errorCodeUnavailable = "unavailable" + errorCodeConflict = "conflict" +) + +type apiError struct { + status int + code string + message string +} + +func methodNotAllowed(w http.ResponseWriter, allowed string) *apiError { + w.Header().Set("Allow", allowed) + return &apiError{http.StatusMethodNotAllowed, errorCodeInvalidRequest, "method not allowed"} +} + +func invalidRequest() *apiError { + return &apiError{http.StatusBadRequest, errorCodeInvalidRequest, "invalid request"} +} + +func unauthorized() *apiError { + return &apiError{http.StatusUnauthorized, errorCodeUnauthorized, "authentication required"} +} + +func notFound() *apiError { + return &apiError{http.StatusNotFound, errorCodeNotFound, "resource not found"} +} + +func internalError() *apiError { + return &apiError{http.StatusInternalServerError, errorCodeInternal, "internal server error"} +} + +func unavailable() *apiError { + return &apiError{http.StatusServiceUnavailable, errorCodeUnavailable, "service unavailable"} +} + +func writeError(w http.ResponseWriter, requestID string, err *apiError) { + writeJSON(w, err.status, map[string]any{"error": map[string]string{ + "code": err.code, "message": err.message, "request_id": requestID, + }}) +} + +func writeJSON(w http.ResponseWriter, status int, value any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(value) +} diff --git a/internal/messenger/handlers.go b/internal/messenger/handlers.go new file mode 100644 index 00000000..bedff654 --- /dev/null +++ b/internal/messenger/handlers.go @@ -0,0 +1,273 @@ +package messenger + +import ( + "context" + "errors" + "net/http" + "regexp" + "strings" + "time" + "unicode/utf8" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func (s *Server) live(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) + return nil +} + +func (s *Server) readiness(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + if !s.ready.Load() { + return unavailable() + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + if err := s.messengerStore.Ping(ctx); err != nil { + return unavailable() + } + if err := s.sessions.Ping(ctx); err != nil { + return unavailable() + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) + return nil +} + +func (s *Server) users(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + var input struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !usernamePattern.MatchString(input.Username) || !validText(input.DisplayName, 100) || !validPassword(input.Password) { + return invalidRequest() + } + passwordHash, err := s.passwords.Hash(input.Password) + if err != nil { + return internalError() + } + user, err := s.messengerStore.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) + if errors.Is(err, postgres.ErrConflict) { + return &apiError{http.StatusConflict, errorCodeConflict, "username already exists"} + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, user) + return nil +} + +func validPassword(value string) bool { + length := utf8.RuneCountInString(value) + return utf8.ValidString(value) && strings.TrimSpace(value) != "" && length >= 12 && length <= 128 +} + +func (s *Server) me(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, err := s.authenticate(r) + if err != nil { + return err + } + writeJSON(w, http.StatusOK, user) + return nil +} + +func (s *Server) chats(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost && r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet+", "+http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if r.Method == http.MethodGet { + return s.listChats(w, r, user) + } + var input struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !validText(input.Title, 100) || len(input.MemberIDs) < 1 || len(input.MemberIDs) > 100 { + return invalidRequest() + } + members := make(map[string]struct{}, len(input.MemberIDs)) + for i, memberID := range input.MemberIDs { + canonical, valid := canonicalID(memberID) + if !valid { + return invalidRequest() + } + if _, duplicate := members[canonical]; duplicate { + return invalidRequest() + } + members[canonical] = struct{}{} + input.MemberIDs[i] = canonical + } + if _, included := members[user.ID]; !included { + return invalidRequest() + } + chat, err := s.messengerStore.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) + if errors.Is(err, postgres.ErrInvalidMembers) { + return invalidRequest() + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, chat) + return nil +} + +func (s *Server) listChats(w http.ResponseWriter, r *http.Request, user User) *apiError { + limit, cursor, err := pageParams(r, "chat", user.ID) + if err != nil { + return err + } + items, hasNext, listErr := s.messengerStore.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, postgres.ErrInvalidCursor) { + return invalidRequest() + } + if listErr != nil { + return unavailable() + } + if items == nil { + items = []Chat{} + } + var next *string + if hasNext { + last := items[len(items)-1] + value := encodeCursor("chat", user.ID, last.CreatedAt, last.ID) + next = &value + } + writeJSON(w, http.StatusOK, struct { + Items []Chat `json:"items"` + NextCursor *string `json:"next_cursor"` + }{items, next}) + return nil +} + +func (s *Server) chat(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + chat, err := s.messengerStore.ChatForUser(r.Context(), chatID, user.ID) + if errors.Is(err, postgres.ErrNotFound) { + return notFound() + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusOK, chat) + return nil +} + +func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost && r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet+", "+http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + if r.Method == http.MethodGet { + return s.listMessages(w, r, user, chatID) + } + key, valid := idempotencyKey(r) + if !valid { + return invalidRequest() + } + var input struct { + Text string `json:"text"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !validText(input.Text, 4000) { + return invalidRequest() + } + message, replay, err := s.messengerStore.CreateMessage( + r.Context(), chatID, user.ID, input.Text, key, s.idempotencyTTL, + ) + if errors.Is(err, postgres.ErrNotFound) { + return notFound() + } + if errors.Is(err, postgres.ErrIdempotencyConflict) { + return &apiError{http.StatusConflict, errorCodeConflict, "idempotency key conflicts with previous request"} + } + if err != nil { + return unavailable() + } + if replay { + s.metrics.replays.Inc() + } + writeJSON(w, http.StatusCreated, message) + return nil +} + +func (s *Server) listMessages(w http.ResponseWriter, r *http.Request, user User, chatID string) *apiError { + limit, cursor, err := pageParams(r, "message", chatID) + if err != nil { + return err + } + items, hasNext, listErr := s.messengerStore.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, postgres.ErrNotFound) { + return notFound() + } + if errors.Is(listErr, postgres.ErrInvalidCursor) { + return invalidRequest() + } + if listErr != nil { + return unavailable() + } + if items == nil { + items = []Message{} + } + var next *string + if hasNext { + last := items[len(items)-1] + value := encodeCursor("message", chatID, last.CreatedAt, last.ID) + next = &value + } + writeJSON(w, http.StatusOK, struct { + Items []Message `json:"items"` + NextCursor *string `json:"next_cursor"` + }{items, next}) + return nil +} + +func cursorPosition(cursor *pageCursor) *model.Position { + if cursor == nil { + return nil + } + return &model.Position{CreatedAt: cursor.Time, ID: cursor.ID} +} diff --git a/internal/messenger/messenger_interface.go b/internal/messenger/messenger_interface.go new file mode 100644 index 00000000..14005ade --- /dev/null +++ b/internal/messenger/messenger_interface.go @@ -0,0 +1,33 @@ +package messenger + +import ( + "context" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +type MessengerStore interface { + Ping(context.Context) error + CreateUser(context.Context, string, string, string) (model.User, error) + UserByID(context.Context, string) (model.User, error) + UserByUsername(context.Context, string) (model.UserCredentials, error) + CreateChat(context.Context, string, []string, string) (model.Chat, error) + ChatForUser(context.Context, string, string) (model.Chat, error) + ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) + CreateMessage(context.Context, string, string, string, string, time.Duration) (model.Message, bool, error) + ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) +} + +type SessionStore interface { + Ping(context.Context) error + Create(context.Context, string, time.Duration) (string, time.Time, error) + UserID(context.Context, string) (string, error) + Delete(context.Context, string) error +} + +type PasswordService interface { + Hash(string) (string, error) + Verify(string, string) (bool, error) + DummyHash() string +} diff --git a/internal/messenger/metrics.go b/internal/messenger/metrics.go new file mode 100644 index 00000000..8073542e --- /dev/null +++ b/internal/messenger/metrics.go @@ -0,0 +1,83 @@ +package messenger + +import ( + "net/http" + "strconv" + "strings" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/collectors" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +type metrics struct { + requests *prometheus.CounterVec + duration *prometheus.HistogramVec + inFlight prometheus.Gauge + replays prometheus.Counter + handler http.Handler +} + +func newMetrics() *metrics { + registry := prometheus.NewRegistry() + result := &metrics{ + requests: prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "requests_total", + Help: "Completed HTTP requests.", + }, []string{"method", "route", "status_class"}), + duration: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "request_duration_seconds", + Help: "HTTP request duration in seconds.", + Buckets: prometheus.DefBuckets, + }, []string{"method", "route"}), + inFlight: prometheus.NewGauge(prometheus.GaugeOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "requests_in_flight", + Help: "HTTP requests currently being served.", + }), + replays: prometheus.NewCounter(prometheus.CounterOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "idempotency_replays_total", + Help: "Message requests served from an idempotency record.", + }), + } + registry.MustRegister( + result.requests, + result.duration, + result.inFlight, + result.replays, + collectors.NewGoCollector(), + collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}), + ) + result.handler = promhttp.HandlerFor(registry, promhttp.HandlerOpts{}) + return result +} + +func (m *metrics) observe(r *http.Request, status int, started time.Time) { + route := routeTemplate(r.URL.Path) + m.requests.WithLabelValues(r.Method, route, strconv.Itoa(status/100)+"xx").Inc() + m.duration.WithLabelValues(r.Method, route).Observe(time.Since(started).Seconds()) +} + +func routeTemplate(path string) string { + switch path { + case "/health/live", "/health/ready", "/metrics", "/api/v1/users", "/api/v1/users/me", + "/api/v1/auth/sessions", "/api/v1/auth/sessions/current", "/api/v1/chats": + return path + } + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" { + return "/api/v1/chats/{chat_id}" + } + if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { + return "/api/v1/chats/{chat_id}/messages" + } + return "unknown" +} diff --git a/internal/messenger/model.go b/internal/messenger/model.go new file mode 100644 index 00000000..ca5eefa2 --- /dev/null +++ b/internal/messenger/model.go @@ -0,0 +1,29 @@ +package messenger + +import ( + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "github.com/google/uuid" +) + +type User = model.User +type Chat = model.Chat +type Message = model.Message + +func newID() (string, error) { + id, err := uuid.NewRandom() + if err != nil { + return "", err + } + return id.String(), nil +} + +func canonicalID(value string) (string, bool) { + if len(value) != 36 { + return "", false + } + id, err := uuid.Parse(value) + if err != nil { + return "", false + } + return id.String(), true +} diff --git a/internal/messenger/request.go b/internal/messenger/request.go new file mode 100644 index 00000000..da264ece --- /dev/null +++ b/internal/messenger/request.go @@ -0,0 +1,127 @@ +package messenger + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "errors" + "io" + "mime" + "net/http" + "net/url" + "regexp" + "strconv" + "strings" + "time" + "unicode/utf8" +) + +const maxRequestBytes = 1 << 20 + +var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +func readJSON(w http.ResponseWriter, r *http.Request, target any) *apiError { + mediaType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || mediaType != "application/json" || (params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) { + return &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "expected application/json"} + } + r.Body = http.MaxBytesReader(w, r.Body, maxRequestBytes) + data, err := io.ReadAll(r.Body) + if err != nil { + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + return &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "request body too large"} + } + return invalidRequest() + } + if !utf8.Valid(data) { + return invalidRequest() + } + var object map[string]json.RawMessage + if err := json.Unmarshal(data, &object); err != nil || object == nil { + return invalidRequest() + } + normalized, err := json.Marshal(object) + if err != nil { + return invalidRequest() + } + decoder := json.NewDecoder(bytes.NewReader(normalized)) + decoder.DisallowUnknownFields() + if err := decoder.Decode(target); err != nil { + return invalidRequest() + } + return nil +} + +func validText(value string, maxRunes int) bool { + return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxRunes +} + +func idempotencyKey(r *http.Request) (string, bool) { + values := r.Header.Values("Idempotency-Key") + if len(values) != 1 || !idempotencyKeyPattern.MatchString(values[0]) { + return "", false + } + return values[0], true +} + +type pageCursor struct { + Kind string `json:"kind"` + Resource string `json:"resource"` + Time time.Time `json:"time"` + ID string `json:"id"` +} + +func pageParams(r *http.Request, kind, resource string) (int, *pageCursor, *apiError) { + query, err := url.ParseQuery(r.URL.RawQuery) + if err != nil { + return 0, nil, invalidRequest() + } + for key := range query { + if key != "limit" && key != "cursor" { + return 0, nil, invalidRequest() + } + if len(query[key]) != 1 { + return 0, nil, invalidRequest() + } + } + limit := 50 + if value, present := query["limit"]; present { + parsed, err := strconv.Atoi(value[0]) + if err != nil || parsed < 1 || parsed > 100 { + return 0, nil, invalidRequest() + } + limit = parsed + } + if value, present := query["cursor"]; present { + cursor, valid := decodeCursor(value[0], kind, resource) + if !valid { + return 0, nil, invalidRequest() + } + return limit, cursor, nil + } + return limit, nil, nil +} + +func encodeCursor(kind, resource string, createdAt time.Time, id string) string { + data, _ := json.Marshal(pageCursor{kind, resource, createdAt, id}) + return base64.RawURLEncoding.EncodeToString(data) +} + +func decodeCursor(value, kind, resource string) (*pageCursor, bool) { + data, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return nil, false + } + var cursor pageCursor + if err := json.Unmarshal(data, &cursor); err != nil || cursor.Kind != kind || cursor.Resource != resource { + return nil, false + } + if cursor.Time.IsZero() { + return nil, false + } + if _, valid := canonicalID(cursor.ID); !valid { + return nil, false + } + return &cursor, true +} diff --git a/internal/messenger/routes.go b/internal/messenger/routes.go new file mode 100644 index 00000000..bb698d0b --- /dev/null +++ b/internal/messenger/routes.go @@ -0,0 +1,41 @@ +package messenger + +import ( + "net/http" + "strings" +) + +type requestHandler func(http.ResponseWriter, *http.Request) *apiError + +func (s *Server) route(w http.ResponseWriter, r *http.Request) *apiError { + var handler requestHandler + switch r.URL.Path { + case "/health/live": + handler = s.live + case "/health/ready": + handler = s.readiness + case "/metrics": + s.metrics.handler.ServeHTTP(w, r) + return nil + case "/api/v1/users": + handler = s.users + case "/api/v1/users/me": + handler = s.me + case "/api/v1/auth/sessions": + handler = s.createSession + case "/api/v1/auth/sessions/current": + handler = s.revokeSession + case "/api/v1/chats": + handler = s.chats + default: + parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/") + if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" { + handler = s.chat + } else if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { + handler = s.messages + } else { + return notFound() + } + } + return handler(w, r) +} diff --git a/internal/messenger/server.go b/internal/messenger/server.go new file mode 100644 index 00000000..3cc2ba00 --- /dev/null +++ b/internal/messenger/server.go @@ -0,0 +1,112 @@ +package messenger + +import ( + "context" + "log/slog" + "net/http" + "sync/atomic" + "time" +) + +type Server struct { + messengerStore MessengerStore + sessions SessionStore + passwords PasswordService + sessionTTL time.Duration + idempotencyTTL time.Duration + requestTTL time.Duration + instanceID string + logger *slog.Logger + swaggerPort string + metrics *metrics + ready atomic.Bool +} + +type statusWriter struct { + http.ResponseWriter + status int +} + +func (w *statusWriter) WriteHeader(status int) { + w.status = status + w.ResponseWriter.WriteHeader(status) +} + +func NewServer( + logger *slog.Logger, + messages MessengerStore, + sessions SessionStore, + passwords PasswordService, + sessionTTL time.Duration, + idempotencyTTL time.Duration, + requestTTL time.Duration, + instanceID string, + swaggerPort string, +) *Server { + s := &Server{ + messengerStore: messages, sessions: sessions, passwords: passwords, + sessionTTL: sessionTTL, idempotencyTTL: idempotencyTTL, requestTTL: requestTTL, + instanceID: instanceID, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), + } + s.ready.Store(true) + return s +} + +func (s *Server) SetReady(ready bool) { + s.ready.Store(ready) +} + +func (s *Server) Handler() http.Handler { + return http.HandlerFunc(s.serve) +} + +func (s *Server) serve(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Instance-Id", s.instanceID) + requestID, err := newID() + if err != nil { + http.Error(w, "server unavailable", http.StatusServiceUnavailable) + return + } + w.Header().Set("X-Request-Id", requestID) + w.Header().Set("Cache-Control", "no-store") + wrapped := &statusWriter{ResponseWriter: w, status: http.StatusOK} + started := time.Now() + s.metrics.inFlight.Inc() + defer func() { + s.metrics.inFlight.Dec() + if recovered := recover(); recovered != nil { + s.logger.Error("request panic", "request_id", requestID, "method", r.Method, "path", r.URL.Path) + if wrapped.status == http.StatusOK { + writeError(wrapped, requestID, internalError()) + } + } + s.metrics.observe(r, wrapped.status, started) + s.logger.Info("request", "request_id", requestID, "method", r.Method, "path", r.URL.Path, "status", wrapped.status, "duration_ms", time.Since(started).Milliseconds()) + }() + if s.allowSwaggerOrigin(wrapped, r) && r.Method == http.MethodOptions && r.Header.Get("Access-Control-Request-Method") != "" { + wrapped.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS") + wrapped.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, Idempotency-Key") + wrapped.WriteHeader(http.StatusNoContent) + return + } + ctx, cancel := context.WithTimeout(r.Context(), s.requestTTL) + defer cancel() + r = r.WithContext(ctx) + if apiErr := s.route(wrapped, r); apiErr != nil { + if apiErr.status == http.StatusUnauthorized { + wrapped.Header().Set("WWW-Authenticate", authenticationChallenge(r)) + } + writeError(wrapped, requestID, apiErr) + } +} + +func (s *Server) allowSwaggerOrigin(w http.ResponseWriter, r *http.Request) bool { + origin := r.Header.Get("Origin") + if origin != "http://localhost:"+s.swaggerPort && origin != "http://127.0.0.1:"+s.swaggerPort { + return false + } + w.Header().Set("Access-Control-Allow-Origin", origin) + w.Header().Set("Access-Control-Expose-Headers", "X-Request-Id, X-Instance-Id") + w.Header().Add("Vary", "Origin") + return true +} diff --git a/internal/messenger/server_test.go b/internal/messenger/server_test.go new file mode 100644 index 00000000..c38aa0cd --- /dev/null +++ b/internal/messenger/server_test.go @@ -0,0 +1,257 @@ +package messenger + +import ( + "context" + "errors" + "fmt" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/suite" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" +) + +var errDependency = errors.New("dependency unavailable") + +type MessengerSuite struct { + suite.Suite + logger *slog.Logger +} + +func TestMessengerSuite(t *testing.T) { + suite.Run(t, new(MessengerSuite)) +} + +func (s *MessengerSuite) SetupTest() { + s.logger = slog.New(slog.NewTextHandler(io.Discard, nil)) +} + +type messengerStoreStub struct { + pingErr error + userByID model.User + userByIDErr error + credentials model.UserCredentials + credentialsErr error + message model.Message + messageReplay bool + messageErr error +} + +func (s messengerStoreStub) Ping(context.Context) error { return s.pingErr } +func (messengerStoreStub) CreateUser(context.Context, string, string, string) (model.User, error) { + return model.User{}, nil +} +func (s messengerStoreStub) UserByID(context.Context, string) (model.User, error) { + return s.userByID, s.userByIDErr +} +func (s messengerStoreStub) UserByUsername(context.Context, string) (model.UserCredentials, error) { + return s.credentials, s.credentialsErr +} +func (messengerStoreStub) CreateChat(context.Context, string, []string, string) (model.Chat, error) { + return model.Chat{}, nil +} +func (messengerStoreStub) ChatForUser(context.Context, string, string) (model.Chat, error) { + return model.Chat{}, nil +} +func (messengerStoreStub) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) { + return nil, false, nil +} +func (s messengerStoreStub) CreateMessage(context.Context, string, string, string, string, time.Duration) (model.Message, bool, error) { + return s.message, s.messageReplay, s.messageErr +} +func (messengerStoreStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { + return nil, false, nil +} + +type sessionStub struct { + pingErr error + userID string + userIDErr error +} + +func (s sessionStub) Ping(context.Context) error { return s.pingErr } +func (sessionStub) Create(context.Context, string, time.Duration) (string, time.Time, error) { + return "token", time.Now().Add(time.Hour), nil +} +func (s sessionStub) UserID(context.Context, string) (string, error) { return s.userID, s.userIDErr } +func (sessionStub) Delete(context.Context, string) error { return nil } + +type passwordsStub struct { + verified bool + err error +} + +func (passwordsStub) Hash(string) (string, error) { return "hash", nil } +func (passwordsStub) DummyHash() string { return "hash" } +func (s passwordsStub) Verify(string, string) (bool, error) { + return s.verified, s.err +} + +func (s *MessengerSuite) TestReadinessReturnsUnavailableForDependencyFailure() { + t := s.T() + tests := []struct { + name string + store messengerStoreStub + sessions sessionStub + }{ + {name: "postgres", store: messengerStoreStub{pingErr: errDependency}}, + {name: "valkey", sessions: sessionStub{pingErr: errDependency}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := s.newTestServer(tt.store, tt.sessions, passwordsStub{}) + response := serveRequest(server, http.MethodGet, "/health/ready", "") + if response.Code != http.StatusServiceUnavailable { + t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) + } + }) + } +} + +func (s *MessengerSuite) TestBusinessRequestReturnsUnavailableForDependencyFailure() { + t := s.T() + tests := []struct { + name string + store messengerStoreStub + sessions sessionStub + }{ + {name: "valkey", sessions: sessionStub{userIDErr: errDependency}}, + {name: "postgres", store: messengerStoreStub{userByIDErr: errDependency}, sessions: sessionStub{userID: "user-id"}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := s.newTestServer(tt.store, tt.sessions, passwordsStub{}) + request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil) + request.Header.Set("Authorization", "Bearer valid-token") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusServiceUnavailable { + t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) + } + }) + } +} + +func (s *MessengerSuite) TestAuthenticationChallenges() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) + bearer := serveRequest(server, http.MethodGet, "/api/v1/users/me", "") + if bearer.Code != http.StatusUnauthorized || bearer.Header().Get("WWW-Authenticate") != `Bearer realm="messenger"` { + t.Fatalf("business challenge = %d %q", bearer.Code, bearer.Header().Get("WWW-Authenticate")) + } + + store := messengerStoreStub{credentials: model.UserCredentials{PasswordHash: "hash"}} + server = s.newTestServer(store, sessionStub{}, passwordsStub{verified: false}) + request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", nil) + request.SetBasicAuth("user", "wrong-password") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusUnauthorized || response.Header().Get("WWW-Authenticate") != `Basic realm="messenger", charset="UTF-8"` { + t.Fatalf("session challenge = %d %q", response.Code, response.Header().Get("WWW-Authenticate")) + } +} + +func (s *MessengerSuite) TestSessionCreationRejectsChunkedBody() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) + request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", strings.NewReader("{}")) + request.ContentLength = -1 + request.SetBasicAuth("user", "password") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusBadRequest { + t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) + } +} + +func (s *MessengerSuite) TestRegistrationRejectsWhitespacePassword() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) + response := serveRequest(server, http.MethodPost, "/api/v1/users", `{"username":"student","display_name":"Student","password":" "}`) + if response.Code != http.StatusBadRequest { + t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) + } +} + +func (s *MessengerSuite) TestInstanceHeaderIsSetOnSuccessAndError() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) + for _, response := range []*httptest.ResponseRecorder{ + serveRequest(server, http.MethodGet, "/health/live", ""), + serveRequest(server, http.MethodGet, "/api/v1/users/me", ""), + } { + if value := response.Header().Get("X-Instance-Id"); value != "test-instance" { + t.Fatalf("X-Instance-Id = %q, want test-instance", value) + } + } +} + +func (s *MessengerSuite) TestMessageCreationValidatesIdempotencyKey() { + t := s.T() + store := messengerStoreStub{userByID: model.User{ID: "user-id"}} + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) + tests := []struct { + name string + key string + }{ + {name: "missing"}, + {name: "invalid", key: "invalid key"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + request := httptest.NewRequest(http.MethodPost, "/api/v1/chats/00000000-0000-0000-0000-000000000001/messages", strings.NewReader(`{"text":"message"}`)) + request.Header.Set("Authorization", "Bearer valid-token") + request.Header.Set("Content-Type", "application/json") + if tt.key != "" { + request.Header.Set("Idempotency-Key", tt.key) + } + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusBadRequest { + t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) + } + }) + } +} + +func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody() { + t := s.T() + store := messengerStoreStub{ + userByID: model.User{ID: "user-id"}, + messageErr: fmt.Errorf("create message: %w", postgres.ErrIdempotencyConflict), + } + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) + request := httptest.NewRequest(http.MethodPost, "/api/v1/chats/00000000-0000-0000-0000-000000000001/messages", strings.NewReader(`{"text":"different"}`)) + request.Header.Set("Authorization", "Bearer valid-token") + request.Header.Set("Content-Type", "application/json") + request.Header.Set("Idempotency-Key", "same-key") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusConflict { + t.Fatalf("status = %d, want %d", response.Code, http.StatusConflict) + } +} + +func (s *MessengerSuite) newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { + return NewServer(s.logger, messages, sessions, passwords, time.Hour, 24*time.Hour, time.Second, "test-instance", "8081") +} + +func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { + request := httptest.NewRequest(method, path, strings.NewReader(body)) + if body != "" { + request.Header.Set("Content-Type", "application/json") + } + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + return response +} diff --git a/internal/model/model.go b/internal/model/model.go new file mode 100644 index 00000000..57a247e8 --- /dev/null +++ b/internal/model/model.go @@ -0,0 +1,82 @@ +package model + +import ( + "encoding/json" + "time" +) + +const timestampLayout = "2006-01-02T15:04:05.000000Z" + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +type UserCredentials struct { + User + PasswordHash string `json:"-"` +} + +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"` +} + +type Position struct { + CreatedAt time.Time + ID string +} + +type userJSON struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +type chatJSON struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type messageJSON struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` +} + +func (u User) MarshalJSON() ([]byte, error) { + return json.Marshal(userJSON{u.ID, u.Username, u.DisplayName, formatTime(u.CreatedAt)}) +} + +func (c Chat) MarshalJSON() ([]byte, error) { + return json.Marshal(chatJSON{c.ID, c.Title, c.MemberIDs, formatTime(c.CreatedAt)}) +} + +func (m Message) MarshalJSON() ([]byte, error) { + return json.Marshal(messageJSON{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt)}) +} + +func FormatTime(value time.Time) string { + return formatTime(value) +} + +func formatTime(value time.Time) string { + return value.UTC().Format(timestampLayout) +} diff --git a/internal/model/model_test.go b/internal/model/model_test.go new file mode 100644 index 00000000..d3a54d9c --- /dev/null +++ b/internal/model/model_test.go @@ -0,0 +1,24 @@ +package model + +import ( + "encoding/json" + "testing" + "time" + + "github.com/stretchr/testify/suite" +) + +type ModelSuite struct { + suite.Suite +} + +func TestModelSuite(t *testing.T) { + suite.Run(t, new(ModelSuite)) +} + +func (s *ModelSuite) TestUserTimestampHasFixedMicroseconds() { + createdAt := time.Date(2026, time.September, 23, 21, 28, 15, 423030000, time.UTC) + data, err := json.Marshal(User{ID: "id", Username: "user", DisplayName: "User", CreatedAt: createdAt}) + s.Require().NoError(err) + s.Equal(`{"id":"id","username":"user","display_name":"User","created_at":"2026-09-23T21:28:15.423030Z"}`, string(data)) +} diff --git a/internal/password/password.go b/internal/password/password.go new file mode 100644 index 00000000..5dd8b1b1 --- /dev/null +++ b/internal/password/password.go @@ -0,0 +1,133 @@ +package password + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "errors" + "fmt" + "strconv" + "strings" + + "golang.org/x/crypto/argon2" +) + +var ( + ErrInvalidConfig = errors.New("invalid password configuration") + ErrInvalidHash = errors.New("invalid password hash") +) + +type Config struct { + MemoryKiB uint32 + Iterations uint32 + Parallelism uint8 + SaltLength uint32 + KeyLength uint32 +} + +type Hasher struct { + config Config + dummyHash string +} + +func New(config Config) (*Hasher, error) { + if err := validateConfig(config); err != nil { + return nil, err + } + salt := make([]byte, config.SaltLength) + digest := argon2.IDKey([]byte("invalid-user-password"), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength) + return &Hasher{config: config, dummyHash: encode(config, salt, digest)}, nil +} + +func validateConfig(config Config) error { + if config.MemoryKiB < 8*1024 || config.MemoryKiB > 1024*1024 || + config.Iterations < 1 || config.Iterations > 20 || + config.Parallelism < 1 || + config.SaltLength < 8 || config.SaltLength > 1024 || + config.KeyLength < 16 || config.KeyLength > 1024 { + return ErrInvalidConfig + } + return nil +} + +func (h *Hasher) Hash(value string) (string, error) { + salt := make([]byte, h.config.SaltLength) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("generate password salt: %w", err) + } + digest := argon2.IDKey([]byte(value), salt, h.config.Iterations, h.config.MemoryKiB, h.config.Parallelism, h.config.KeyLength) + return encode(h.config, salt, digest), nil +} + +func (h *Hasher) Verify(value, encodedHash string) (bool, error) { + config, salt, digest, err := decode(encodedHash) + if err != nil { + return false, err + } + actual := argon2.IDKey([]byte(value), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength) + return subtle.ConstantTimeCompare(actual, digest) == 1, nil +} + +func (h *Hasher) DummyHash() string { + return h.dummyHash +} + +func encode(config Config, salt, digest []byte) string { + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, + config.MemoryKiB, + config.Iterations, + config.Parallelism, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(digest), + ) +} + +func decode(encodedHash string) (Config, []byte, []byte, error) { + parts := strings.Split(encodedHash, "$") + if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" || parts[2] != fmt.Sprintf("v=%d", argon2.Version) { + return Config{}, nil, nil, ErrInvalidHash + } + + parameters := strings.Split(parts[3], ",") + if len(parameters) != 3 { + return Config{}, nil, nil, ErrInvalidHash + } + memory, err := parameter(parameters[0], "m=", 32) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + iterations, err := parameter(parameters[1], "t=", 32) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + parallelism, err := parameter(parameters[2], "p=", 8) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + + salt, err := base64.RawStdEncoding.Strict().DecodeString(parts[4]) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + digest, err := base64.RawStdEncoding.Strict().DecodeString(parts[5]) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + config := Config{ + MemoryKiB: uint32(memory), Iterations: uint32(iterations), Parallelism: uint8(parallelism), + SaltLength: uint32(len(salt)), KeyLength: uint32(len(digest)), + } + if err := validateConfig(config); err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + return config, salt, digest, nil +} + +func parameter(value, prefix string, bitSize int) (uint64, error) { + if !strings.HasPrefix(value, prefix) { + return 0, ErrInvalidHash + } + return strconv.ParseUint(strings.TrimPrefix(value, prefix), 10, bitSize) +} diff --git a/internal/password/password_test.go b/internal/password/password_test.go new file mode 100644 index 00000000..8e88875a --- /dev/null +++ b/internal/password/password_test.go @@ -0,0 +1,44 @@ +package password + +import ( + "testing" + + "github.com/stretchr/testify/suite" +) + +type PasswordSuite struct { + suite.Suite + hasher *Hasher +} + +func TestPasswordSuite(t *testing.T) { + suite.Run(t, new(PasswordSuite)) +} + +func (s *PasswordSuite) SetupTest() { + hasher, err := New(testConfig()) + s.Require().NoError(err) + s.hasher = hasher +} + +func (s *PasswordSuite) TestHasher() { + hash, err := s.hasher.Hash("T3st-password-123") + s.Require().NoError(err) + + verified, err := s.hasher.Verify("T3st-password-123", hash) + s.Require().NoError(err) + s.True(verified) + + verified, err = s.hasher.Verify("wrong-password", hash) + s.Require().NoError(err) + s.False(verified) +} + +func (s *PasswordSuite) TestVerifyRejectsMalformedHash() { + _, err := s.hasher.Verify("password", "invalid") + s.Error(err) +} + +func testConfig() Config { + return Config{MemoryKiB: 8 * 1024, Iterations: 1, Parallelism: 1, SaltLength: 16, KeyLength: 32} +} diff --git a/internal/postgres/errors.go b/internal/postgres/errors.go new file mode 100644 index 00000000..4e0c3780 --- /dev/null +++ b/internal/postgres/errors.go @@ -0,0 +1,11 @@ +package postgres + +import "errors" + +var ( + ErrConflict = errors.New("conflict") + ErrNotFound = errors.New("not found") + ErrInvalidMembers = errors.New("invalid members") + ErrInvalidCursor = errors.New("invalid cursor") + ErrIdempotencyConflict = errors.New("idempotency conflict") +) diff --git a/internal/postgres/idempotency.go b/internal/postgres/idempotency.go new file mode 100644 index 00000000..a95ab99a --- /dev/null +++ b/internal/postgres/idempotency.go @@ -0,0 +1,285 @@ +package postgres + +import ( + "bytes" + "context" + "crypto/sha256" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +const expiredIdempotencyCleanupBatch = 100 + +func (s *Store) CreateMessage( + ctx context.Context, + chatID string, + senderID string, + text string, + idempotencyKey string, + idempotencyTTL time.Duration, +) (model.Message, bool, error) { + var ( + tx pgx.Tx + err error + visible bool + requestHash [sha256.Size]byte + message model.Message + replay bool + ) + + tx, err = s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err) + } + defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() + + visible, err = chatVisibleInTransaction(ctx, tx, chatID, senderID) + if err != nil { + return model.Message{}, false, err + } + if !visible { + return model.Message{}, false, ErrNotFound + } + if err = deleteExpiredIdempotencyRecords(ctx, tx, expiredIdempotencyCleanupBatch); err != nil { + return model.Message{}, false, err + } + + requestHash = sha256.Sum256([]byte(text)) + message, replay, err = createIdempotentMessage( + ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL, + ) + if err != nil { + return model.Message{}, false, err + } + if err := tx.Commit(ctx); err != nil { + return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err) + } + return message, replay, nil +} + +func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $1 AND user_id = $2 + )` + + var visible bool + if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil { + return false, fmt.Errorf("check chat visibility: %w", err) + } + return visible, nil +} + +func createIdempotentMessage( + ctx context.Context, + tx pgx.Tx, + chatID string, + senderID string, + text string, + idempotencyKey string, + requestHash []byte, + idempotencyTTL time.Duration, +) (model.Message, bool, error) { + for { + var ( + record idempotencyRecord + found bool + err error + messageID string + reserved bool + message model.Message + ) + + record, found, err = lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey) + if err != nil { + return model.Message{}, false, err + } + if found && record.active { + if !bytes.Equal(record.requestHash, requestHash) { + return model.Message{}, false, ErrIdempotencyConflict + } + message, err = messageByID(ctx, tx, record.messageID) + return message, true, err + } + if found { + if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil { + return model.Message{}, false, err + } + } + + messageID = uuid.NewString() + reserved, err = reserveIdempotencyKey( + ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL, + ) + if err != nil { + return model.Message{}, false, err + } + if !reserved { + continue + } + + message, err = insertMessage(ctx, tx, messageID, chatID, senderID, text) + return message, false, err + } +} + +func deleteExpiredIdempotencyRecords(ctx context.Context, tx pgx.Tx, limit int) error { + const query = ` + WITH expired AS ( + SELECT ctid + FROM message_idempotency + WHERE expires_at <= statement_timestamp() + ORDER BY expires_at + LIMIT $1 + FOR UPDATE SKIP LOCKED + ) + DELETE FROM message_idempotency records + USING expired + WHERE records.ctid = expired.ctid` + + if _, err := tx.Exec(ctx, query, limit); err != nil { + return fmt.Errorf("delete expired idempotency records: %w", err) + } + return nil +} + +type idempotencyRecord struct { + requestHash []byte + messageID string + active bool +} + +func lockIdempotencyRecord( + ctx context.Context, + tx pgx.Tx, + userID string, + chatID string, + key string, +) (idempotencyRecord, bool, error) { + const query = ` + SELECT request_hash, message_id, expires_at > statement_timestamp() + FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3 + FOR UPDATE` + + var ( + record idempotencyRecord + err error + ) + err = tx.QueryRow(ctx, query, userID, chatID, key).Scan( + &record.requestHash, + &record.messageID, + &record.active, + ) + if errors.Is(err, pgx.ErrNoRows) { + return idempotencyRecord{}, false, nil + } + if err != nil { + return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err) + } + return record, true, nil +} + +func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error { + const query = ` + DELETE FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3` + if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil { + return fmt.Errorf("delete expired idempotency key: %w", err) + } + return nil +} + +func reserveIdempotencyKey( + ctx context.Context, + tx pgx.Tx, + userID string, + chatID string, + key string, + requestHash []byte, + messageID string, + ttl time.Duration, +) (bool, error) { + const query = ` + INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at) + VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second') + ON CONFLICT (user_id, chat_id, key) DO NOTHING + RETURNING true` + + var ( + inserted bool + err error + ) + err = tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted) + if errors.Is(err, pgx.ErrNoRows) { + return false, nil + } + if err != nil { + return false, fmt.Errorf("reserve idempotency key: %w", err) + } + return inserted, nil +} + +func insertMessage( + ctx context.Context, + tx pgx.Tx, + messageID string, + chatID string, + senderID string, + text string, +) (model.Message, error) { + const query = ` + INSERT INTO messages (id, chat_id, sender_id, text) + VALUES ($1, $2, $3, $4) + RETURNING id, chat_id, sender_id, text, created_at` + + var ( + message model.Message + err error + ) + err = tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if err != nil { + return model.Message{}, fmt.Errorf("insert message: %w", err) + } + return message, nil +} + +func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) { + const query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE id = $1` + + var ( + message model.Message + err error + ) + err = tx.QueryRow(ctx, query, messageID).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Message{}, fmt.Errorf("idempotency result message not found") + } + if err != nil { + return model.Message{}, fmt.Errorf("get idempotency result message: %w", err) + } + return message, nil +} diff --git a/internal/postgres/store.go b/internal/postgres/store.go new file mode 100644 index 00000000..f8b3fccd --- /dev/null +++ b/internal/postgres/store.go @@ -0,0 +1,435 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +type Store struct { + pool *pgxpool.Pool +} + +func New(pool *pgxpool.Pool) *Store { + return &Store{pool: pool} +} + +func (s *Store) Ping(ctx context.Context) error { + return s.pool.Ping(ctx) +} + +func (s *Store) CreateUser( + ctx context.Context, + username string, + displayName string, + passwordHash string, +) (model.User, error) { + const query = ` + INSERT INTO users (id, username, display_name, password_hash) + VALUES ($1, $2, $3, $4) + RETURNING id, username, display_name, created_at` + + var user model.User + err := s.pool.QueryRow(ctx, query, uuid.NewString(), username, displayName, passwordHash).Scan( + &user.ID, + &user.Username, + &user.DisplayName, + &user.CreatedAt, + ) + if isUniqueViolation(err) { + return model.User{}, ErrConflict + } + if err != nil { + return model.User{}, fmt.Errorf("create user: %w", err) + } + + return user, nil +} + +func (s *Store) UserByID(ctx context.Context, id string) (model.User, error) { + const query = ` + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1` + + var user model.User + err := s.pool.QueryRow(ctx, query, id).Scan( + &user.ID, + &user.Username, + &user.DisplayName, + &user.CreatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.User{}, ErrNotFound + } + if err != nil { + return model.User{}, fmt.Errorf("get user by id: %w", err) + } + + return user, nil +} + +func (s *Store) UserByUsername(ctx context.Context, username string) (model.UserCredentials, error) { + const query = ` + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1` + + var credentials model.UserCredentials + err := s.pool.QueryRow(ctx, query, username).Scan( + &credentials.ID, + &credentials.Username, + &credentials.DisplayName, + &credentials.CreatedAt, + &credentials.PasswordHash, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.UserCredentials{}, ErrNotFound + } + if err != nil { + return model.UserCredentials{}, fmt.Errorf("get user by username: %w", err) + } + + return credentials, nil +} + +func (s *Store) CreateChat( + ctx context.Context, + title string, + memberIDs []string, + callerID string, +) (model.Chat, error) { + if !validMembers(memberIDs, callerID) { + return model.Chat{}, ErrInvalidMembers + } + + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return model.Chat{}, fmt.Errorf("begin create chat transaction: %w", err) + } + defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() + + valid, err := allUsersExist(ctx, tx, memberIDs) + if err != nil { + return model.Chat{}, err + } + if !valid { + return model.Chat{}, ErrInvalidMembers + } + + chat, err := insertChat(ctx, tx, title) + if err != nil { + return model.Chat{}, err + } + if err := insertMembers(ctx, tx, chat.ID, memberIDs); err != nil { + return model.Chat{}, err + } + if err := tx.Commit(ctx); err != nil { + return model.Chat{}, fmt.Errorf("commit create chat transaction: %w", err) + } + + chat.MemberIDs = append([]string(nil), memberIDs...) + return chat, nil +} + +func validMembers(memberIDs []string, callerID string) bool { + callerUUID, err := uuid.Parse(callerID) + if err != nil { + return false + } + + seen := make(map[uuid.UUID]struct{}, len(memberIDs)) + callerIncluded := false + for _, memberID := range memberIDs { + memberUUID, err := uuid.Parse(memberID) + if err != nil { + return false + } + if _, exists := seen[memberUUID]; exists { + return false + } + + seen[memberUUID] = struct{}{} + callerIncluded = callerIncluded || memberUUID == callerUUID + } + + return callerIncluded +} + +func allUsersExist(ctx context.Context, tx pgx.Tx, memberIDs []string) (bool, error) { + const query = ` + SELECT count(*) + FROM users + WHERE id::text = ANY($1)` + + var count int + if err := tx.QueryRow(ctx, query, memberIDs).Scan(&count); err != nil { + return false, fmt.Errorf("check chat members: %w", err) + } + + return count == len(memberIDs), nil +} + +func insertChat(ctx context.Context, tx pgx.Tx, title string) (model.Chat, error) { + const query = ` + INSERT INTO chats (id, title) + VALUES ($1, $2) + RETURNING id, title, created_at` + + var chat model.Chat + if err := tx.QueryRow(ctx, query, uuid.NewString(), title).Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil { + return model.Chat{}, fmt.Errorf("insert chat: %w", err) + } + + return chat, nil +} + +func insertMembers(ctx context.Context, tx pgx.Tx, chatID string, memberIDs []string) error { + const query = ` + INSERT INTO chat_members (chat_id, user_id, position) + VALUES ($1, $2, $3)` + + batch := &pgx.Batch{} + for position, memberID := range memberIDs { + batch.Queue(query, chatID, memberID, position) + } + + results := tx.SendBatch(ctx, batch) + defer func() { _ = results.Close() }() + for range memberIDs { + if _, err := results.Exec(); err != nil { + return fmt.Errorf("insert chat member: %w", err) + } + } + if err := results.Close(); err != nil { + return fmt.Errorf("close chat members batch: %w", err) + } + + return nil +} + +func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (model.Chat, error) { + const query = ` + SELECT c.id, c.title, c.created_at, + array_agg(cm.user_id::text ORDER BY cm.position) + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE c.id = $1 + AND EXISTS ( + SELECT 1 + FROM chat_members visible + WHERE visible.chat_id = c.id AND visible.user_id = $2 + ) + GROUP BY c.id, c.title, c.created_at` + + var chat model.Chat + err := s.pool.QueryRow(ctx, query, chatID, userID).Scan( + &chat.ID, + &chat.Title, + &chat.CreatedAt, + &chat.MemberIDs, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Chat{}, ErrNotFound + } + if err != nil { + return model.Chat{}, fmt.Errorf("get chat for user: %w", err) + } + + return chat, nil +} + +func (s *Store) ListChats( + ctx context.Context, + userID string, + after *model.Position, + limit int, +) ([]model.Chat, bool, error) { + if after != nil { + valid, err := s.visibleChatPositionExists(ctx, userID, *after) + if err != nil { + return nil, false, err + } + if !valid { + return nil, false, ErrInvalidCursor + } + } + + const query = ` + SELECT c.id, c.title, c.created_at, + array_agg(all_members.user_id::text ORDER BY all_members.position) + FROM chats c + JOIN chat_members visible ON visible.chat_id = c.id AND visible.user_id = $1 + JOIN chat_members all_members ON all_members.chat_id = c.id + WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid)) + GROUP BY c.id, c.title, c.created_at + ORDER BY c.created_at, c.id + LIMIT $4` + + var afterTime any + var afterID any + if after != nil { + afterTime = after.CreatedAt + afterID = after.ID + } + + rows, err := s.pool.Query(ctx, query, userID, afterTime, afterID, limit+1) + if err != nil { + return nil, false, fmt.Errorf("list chats: %w", err) + } + defer rows.Close() + + chats, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Chat](func(row pgx.CollectableRow) (model.Chat, error) { + var chat model.Chat + err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs) + return chat, err + })) + if err != nil { + return nil, false, fmt.Errorf("scan chats: %w", err) + } + + return page(chats, limit) +} + +func (s *Store) visibleChatPositionExists( + ctx context.Context, + userID string, + position model.Position, +) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 AND c.created_at = $2 AND c.id = $3 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, userID, position.CreatedAt, position.ID).Scan(&exists); err != nil { + return false, fmt.Errorf("validate chat cursor: %w", err) + } + + return exists, nil +} + +func (s *Store) ListMessages( + ctx context.Context, + chatID string, + userID string, + after *model.Position, + limit int, +) ([]model.Message, bool, error) { + visible, err := s.chatVisible(ctx, chatID, userID) + if err != nil { + return nil, false, err + } + if !visible { + return nil, false, ErrNotFound + } + if after != nil { + valid, err := s.messagePositionExists(ctx, chatID, *after) + if err != nil { + return nil, false, err + } + if !valid { + return nil, false, ErrInvalidCursor + } + } + + const query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3::uuid)) + ORDER BY created_at, id + LIMIT $4` + + var afterTime any + var afterID any + if after != nil { + afterTime = after.CreatedAt + afterID = after.ID + } + + rows, err := s.pool.Query(ctx, query, chatID, afterTime, afterID, limit+1) + if err != nil { + return nil, false, fmt.Errorf("list messages: %w", err) + } + defer rows.Close() + + messages, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Message](func(row pgx.CollectableRow) (model.Message, error) { + var message model.Message + err := row.Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + return message, err + })) + if err != nil { + return nil, false, fmt.Errorf("scan messages: %w", err) + } + + return page(messages, limit) +} + +func (s *Store) chatVisible(ctx context.Context, chatID, userID string) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $1 AND user_id = $2 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(&exists); err != nil { + return false, fmt.Errorf("check chat visibility: %w", err) + } + + return exists, nil +} + +func (s *Store) messagePositionExists( + ctx context.Context, + chatID string, + position model.Position, +) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM messages + WHERE chat_id = $1 AND created_at = $2 AND id = $3 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, chatID, position.CreatedAt, position.ID).Scan(&exists); err != nil { + return false, fmt.Errorf("validate message cursor: %w", err) + } + + return exists, nil +} + +func page[T any](items []T, limit int) ([]T, bool, error) { + if limit < 1 { + return nil, false, fmt.Errorf("limit must be positive") + } + if len(items) <= limit { + return items, false, nil + } + + return items[:limit], true, nil +} + +func isUniqueViolation(err error) bool { + var postgresError *pgconn.PgError + return errors.As(err, &postgresError) && postgresError.Code == "23505" +} diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go new file mode 100644 index 00000000..461c5394 --- /dev/null +++ b/internal/postgres/store_integration_test.go @@ -0,0 +1,310 @@ +package postgres_test + +import ( + "context" + "errors" + "os" + "strings" + "sync" + "testing" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/stretchr/testify/suite" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" +) + +type PostgresSuite struct { + suite.Suite + pool *pgxpool.Pool + store *postgres.Store +} + +func TestPostgresSuite(t *testing.T) { + suite.Run(t, new(PostgresSuite)) +} + +func (s *PostgresSuite) SetupSuite() { + s.pool = openTestDatabase(s.T()) + s.store = postgres.New(s.pool) +} + +func (s *PostgresSuite) TearDownSuite() { + if s.pool != nil { + s.pool.Close() + } +} + +func (s *PostgresSuite) TestConcurrentUsernameCreation() { + t := s.T() + store := s.store + username := "race_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16] + + const workers = 8 + results := make(chan error, workers) + var group sync.WaitGroup + for range workers { + group.Add(1) + go func() { + defer group.Done() + _, err := store.CreateUser(context.Background(), username, "Race user", "password-hash") + results <- err + }() + } + group.Wait() + close(results) + + var created, conflicts int + for err := range results { + switch { + case err == nil: + created++ + case errors.Is(err, postgres.ErrConflict): + conflicts++ + default: + t.Fatalf("CreateUser() error = %v", err) + } + } + if created != 1 || conflicts != workers-1 { + t.Fatalf("created = %d, conflicts = %d", created, conflicts) + } +} + +func (s *PostgresSuite) TestCreateChatRollsBackForUnknownMember() { + t := s.T() + pool := s.pool + store := s.store + owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash") + if err != nil { + t.Fatalf("CreateUser() error = %v", err) + } + + before := chatCount(t, pool) + _, err = store.CreateChat(context.Background(), "Invalid chat", []string{owner.ID, uuid.NewString()}, owner.ID) + if !errors.Is(err, postgres.ErrInvalidMembers) { + t.Fatalf("CreateChat() error = %v, want ErrInvalidMembers", err) + } + if after := chatCount(t, pool); after != before { + t.Fatalf("chat count changed from %d to %d", before, after) + } +} + +func (s *PostgresSuite) TestMessageIdempotencyReplayAndConflict() { + t := s.T() + pool := s.pool + store := s.store + owner, chatID := createOwnerAndChat(t, store) + key := uuid.NewString() + + first, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour) + if err != nil || replay { + t.Fatalf("first CreateMessage() = (%v, %t, %v)", first, replay, err) + } + second, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour) + if err != nil || !replay { + t.Fatalf("replay CreateMessage() = (%v, %t, %v)", second, replay, err) + } + if first != second { + t.Fatalf("replay message = %v, want %v", second, first) + } + if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "different body", key, 24*time.Hour); !errors.Is(err, postgres.ErrIdempotencyConflict) { + t.Fatalf("conflicting CreateMessage() error = %v, want ErrIdempotencyConflict", err) + } + if count := messageCount(t, pool, chatID); count != 1 { + t.Fatalf("message count = %d, want 1", count) + } +} + +func (s *PostgresSuite) TestConcurrentMessageIdempotency() { + t := s.T() + pool := s.pool + stores := []*postgres.Store{postgres.New(pool), postgres.New(pool)} + owner, chatID := createOwnerAndChat(t, stores[0]) + key := uuid.NewString() + + const workers = 8 + type result struct { + message model.Message + replay bool + err error + } + results := make(chan result, workers) + var group sync.WaitGroup + for worker := range workers { + group.Add(1) + go func() { + defer group.Done() + message, replay, err := stores[worker%len(stores)].CreateMessage( + context.Background(), chatID, owner.ID, "concurrent body", key, 24*time.Hour, + ) + results <- result{message: message, replay: replay, err: err} + }() + } + group.Wait() + close(results) + + var messageID string + var created int + for result := range results { + if result.err != nil { + t.Fatalf("CreateMessage() error = %v", result.err) + } + if messageID == "" { + messageID = result.message.ID + } + if result.message.ID != messageID { + t.Fatalf("message ID = %s, want %s", result.message.ID, messageID) + } + if !result.replay { + created++ + } + } + if created != 1 { + t.Fatalf("new message results = %d, want 1", created) + } + if count := messageCount(t, pool, chatID); count != 1 { + t.Fatalf("message count = %d, want 1", count) + } +} + +func (s *PostgresSuite) TestMessageIdempotencyScopeAndExpiry() { + t := s.T() + pool := s.pool + store := s.store + owner, chatID := createOwnerAndChat(t, store) + second, err := store.CreateUser(context.Background(), uniqueUsername(), "Second", "password-hash") + if err != nil { + t.Fatalf("CreateUser() error = %v", err) + } + chat, err := store.CreateChat(context.Background(), "Shared", []string{owner.ID, second.ID}, owner.ID) + if err != nil { + t.Fatalf("CreateChat() error = %v", err) + } + key := uuid.NewString() + + if _, _, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "owner", key, 24*time.Hour); err != nil { + t.Fatalf("owner CreateMessage() error = %v", err) + } + if _, _, err := store.CreateMessage(context.Background(), chat.ID, second.ID, "second", key, 24*time.Hour); err != nil { + t.Fatalf("second user CreateMessage() error = %v", err) + } + if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "other chat", key, 24*time.Hour); err != nil { + t.Fatalf("other chat CreateMessage() error = %v", err) + } + if _, err := pool.Exec(context.Background(), ` + UPDATE message_idempotency + SET created_at = clock_timestamp() - INTERVAL '2 days', + expires_at = clock_timestamp() - INTERVAL '1 day' + WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chat.ID, key); err != nil { + t.Fatalf("expire idempotency key: %v", err) + } + message, replay, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "after expiry", key, 24*time.Hour) + if err != nil || replay || message.Text != "after expiry" { + t.Fatalf("expired CreateMessage() = (%v, %t, %v)", message, replay, err) + } +} + +func (s *PostgresSuite) TestExpiredIdempotencyRecordsAreCleanedOnNewMessages() { + t := s.T() + owner, chatID := createOwnerAndChat(t, s.store) + expiredKey := uuid.NewString() + if _, _, err := s.store.CreateMessage(context.Background(), chatID, owner.ID, "expired", expiredKey, 24*time.Hour); err != nil { + t.Fatalf("create expired message: %v", err) + } + if _, err := s.pool.Exec(context.Background(), ` + UPDATE message_idempotency + SET created_at = clock_timestamp() - INTERVAL '2 days', + expires_at = clock_timestamp() - INTERVAL '1 day' + WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey); err != nil { + t.Fatalf("expire idempotency key: %v", err) + } + if _, _, err := s.store.CreateMessage( + context.Background(), chatID, owner.ID, "new message", uuid.NewString(), 24*time.Hour, + ); err != nil { + t.Fatalf("create new message: %v", err) + } + + var remaining int + if err := s.pool.QueryRow(context.Background(), ` + SELECT count(*) + FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey).Scan(&remaining); err != nil { + t.Fatalf("count expired idempotency records: %v", err) + } + if remaining != 0 { + t.Fatalf("expired idempotency records = %d, want 0", remaining) + } +} + +func createOwnerAndChat(t *testing.T, store *postgres.Store) (model.User, string) { + t.Helper() + owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash") + if err != nil { + t.Fatalf("CreateUser() error = %v", err) + } + chat, err := store.CreateChat(context.Background(), "Chat", []string{owner.ID}, owner.ID) + if err != nil { + t.Fatalf("CreateChat() error = %v", err) + } + return owner, chat.ID +} + +func messageCount(t *testing.T, pool *pgxpool.Pool, chatID string) int { + t.Helper() + var count int + if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM messages WHERE chat_id = $1", chatID).Scan(&count); err != nil { + t.Fatalf("count messages: %v", err) + } + return count +} + +func openTestDatabase(t *testing.T) *pgxpool.Pool { + t.Helper() + url := testSecret(t, "TEST_DATABASE_URL", "TEST_DATABASE_URL_FILE") + pool, err := database.Open(context.Background(), database.Config{ + URL: url, MinConnections: 0, MaxConnections: 10, + MaxConnectionAge: time.Minute, MaxConnectionIdle: time.Minute, + HealthCheckPeriod: time.Minute, ConnectTimeout: 5 * time.Second, + }) + if err != nil { + t.Fatalf("database.Open() error = %v", err) + } + if err := database.Migrate(context.Background(), pool, 30*time.Second); err != nil { + pool.Close() + t.Fatalf("database.Migrate() error = %v", err) + } + return pool +} + +func testSecret(t *testing.T, valueName, fileName string) string { + t.Helper() + if value := strings.TrimSpace(os.Getenv(valueName)); value != "" { + return value + } + path := strings.TrimSpace(os.Getenv(fileName)) + if path == "" { + t.Skipf("set %s or %s to run integration tests", valueName, fileName) + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatalf("read %s: %v", fileName, err) + } + return strings.TrimSpace(string(data)) +} + +func uniqueUsername() string { + return "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:20] +} + +func chatCount(t *testing.T, pool *pgxpool.Pool) int { + t.Helper() + var count int + if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM chats").Scan(&count); err != nil { + t.Fatalf("count chats: %v", err) + } + return count +} diff --git a/internal/session/session.go b/internal/session/session.go new file mode 100644 index 00000000..4f40fc53 --- /dev/null +++ b/internal/session/session.go @@ -0,0 +1,161 @@ +package session + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "strings" + "time" + + "github.com/valkey-io/valkey-go" +) + +const ( + tokenLength = 32 + keyPrefix = "session:" +) + +var ( + ErrNotFound = errors.New("session not found") + ErrInvalidToken = errors.New("invalid session token") + ErrInvalidRecord = errors.New("invalid session record") + ErrInvalidTTL = errors.New("invalid session TTL") + ErrTokenGeneration = errors.New("session token generation failed") + ErrStore = errors.New("session store failure") +) + +type record struct { + UserID string `json:"user_id"` + ExpiresAt time.Time `json:"expires_at"` +} + +type Store struct { + client valkey.Client +} + +func New(rawURL string) (*Store, error) { + option, err := valkey.ParseURL(rawURL) + if err != nil { + return nil, fmt.Errorf("%w: parse Valkey URL: %w", ErrStore, err) + } + + client, err := valkey.NewClient(option) + if err != nil { + return nil, fmt.Errorf("%w: create Valkey client: %w", ErrStore, err) + } + + return &Store{client: client}, nil +} + +func (s *Store) Create(ctx context.Context, userID string, ttl time.Duration) (string, time.Time, error) { + if strings.TrimSpace(userID) == "" { + return "", time.Time{}, ErrInvalidRecord + } + if ttl < time.Second { + return "", time.Time{}, ErrInvalidTTL + } + + token, err := newToken() + if err != nil { + return "", time.Time{}, err + } + + record := record{ + UserID: userID, + ExpiresAt: time.Now().UTC().Add(ttl).Truncate(time.Microsecond), + } + payload, err := json.Marshal(record) + if err != nil { + return "", time.Time{}, fmt.Errorf("%w: encode session: %w", ErrStore, err) + } + + command := s.client.B().Set().Key(s.key(token)).Value(valkey.BinaryString(payload)).Ex(ttl).Build() + if err := s.client.Do(ctx, command).Error(); err != nil { + return "", time.Time{}, fmt.Errorf("%w: create session: %w", ErrStore, err) + } + + return token, record.ExpiresAt, nil +} + +func newToken() (string, error) { + random := make([]byte, tokenLength) + if _, err := rand.Read(random); err != nil { + return "", fmt.Errorf("%w: %v", ErrTokenGeneration, err) + } + return base64.RawURLEncoding.EncodeToString(random), nil +} + +func (s *Store) UserID(ctx context.Context, token string) (string, error) { + key, err := s.sessionKey(token) + if err != nil { + return "", err + } + + payload, err := s.client.Do(ctx, s.client.B().Get().Key(key).Build()).AsBytes() + if valkey.IsValkeyNil(err) { + return "", ErrNotFound + } + if err != nil { + return "", fmt.Errorf("%w: get session: %w", ErrStore, err) + } + + var record record + if err := json.Unmarshal(payload, &record); err != nil { + return "", fmt.Errorf("%w: decode session: %w", ErrStore, err) + } + if strings.TrimSpace(record.UserID) == "" || record.ExpiresAt.IsZero() { + return "", fmt.Errorf("%w: %w", ErrStore, ErrInvalidRecord) + } + if !record.ExpiresAt.After(time.Now()) { + return "", ErrNotFound + } + + return record.UserID, nil +} + +func (s *Store) Delete(ctx context.Context, token string) error { + key, err := s.sessionKey(token) + if err != nil { + return err + } + + deleted, err := s.client.Do(ctx, s.client.B().Del().Key(key).Build()).AsInt64() + if err != nil { + return fmt.Errorf("%w: delete session: %w", ErrStore, err) + } + if deleted == 0 { + return ErrNotFound + } + + return nil +} + +func (s *Store) Ping(ctx context.Context) error { + if err := s.client.Do(ctx, s.client.B().Ping().Build()).Error(); err != nil { + return fmt.Errorf("%w: ping Valkey: %w", ErrStore, err) + } + return nil +} + +func (s *Store) Close() error { + s.client.Close() + return nil +} + +func (s *Store) sessionKey(token string) (string, error) { + decoded, err := base64.RawURLEncoding.Strict().DecodeString(token) + if err != nil || len(decoded) != tokenLength { + return "", ErrInvalidToken + } + return s.key(token), nil +} + +func (s *Store) key(token string) string { + digest := sha256.Sum256([]byte(token)) + return keyPrefix + hex.EncodeToString(digest[:]) +} diff --git a/internal/session/session_integration_test.go b/internal/session/session_integration_test.go new file mode 100644 index 00000000..9d73e665 --- /dev/null +++ b/internal/session/session_integration_test.go @@ -0,0 +1,72 @@ +package session_test + +import ( + "context" + "errors" + "os" + "strings" + "testing" + "time" + + "github.com/google/uuid" + "github.com/stretchr/testify/suite" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" +) + +type SessionSuite struct { + suite.Suite + store *session.Store +} + +func TestSessionSuite(t *testing.T) { + suite.Run(t, new(SessionSuite)) +} + +func (s *SessionSuite) SetupSuite() { + rawURL := strings.TrimSpace(os.Getenv("TEST_CACHE_URL")) + if rawURL == "" { + path := strings.TrimSpace(os.Getenv("TEST_CACHE_URL_FILE")) + if path == "" { + s.T().Skip("set TEST_CACHE_URL or TEST_CACHE_URL_FILE to run integration tests") + } + data, err := os.ReadFile(path) + s.Require().NoError(err) + rawURL = strings.TrimSpace(string(data)) + } + store, err := session.New(rawURL) + s.Require().NoError(err) + s.store = store +} + +func (s *SessionSuite) TearDownSuite() { + if s.store != nil { + s.Require().NoError(s.store.Close()) + } +} + +func (s *SessionSuite) TestSessionLifecycle() { + userID := uuid.NewString() + token, expiresAt, err := s.store.Create(context.Background(), userID, time.Minute) + s.Require().NoError(err) + s.NotEmpty(token) + s.True(expiresAt.After(time.Now())) + + actualUserID, err := s.store.UserID(context.Background(), token) + s.Require().NoError(err) + s.Equal(userID, actualUserID) + s.Require().NoError(s.store.Delete(context.Background(), token)) + + _, err = s.store.UserID(context.Background(), token) + s.ErrorIs(err, session.ErrNotFound) +} + +func (s *SessionSuite) TestSessionExpires() { + token, _, err := s.store.Create(context.Background(), uuid.NewString(), time.Second) + s.Require().NoError(err) + + s.Eventually(func() bool { + _, err = s.store.UserID(context.Background(), token) + return errors.Is(err, session.ErrNotFound) + }, 3*time.Second, 50*time.Millisecond) +} diff --git a/lab4.env.example b/lab4.env.example new file mode 100644 index 00000000..447b3b72 --- /dev/null +++ b/lab4.env.example @@ -0,0 +1,79 @@ +# Адрес и внутренний порт HTTP-сервера. +APP_HOST=0.0.0.0 +APP_PORT=8080 + +# Адреса публикации сервисов на локальной машине. +API_BIND_ADDRESS=127.0.0.1:8080 +SWAGGER_BIND_ADDRESS=127.0.0.1:8081 +PROMETHEUS_BIND_ADDRESS=127.0.0.1:9090 +GRAFANA_BIND_ADDRESS=127.0.0.1:3000 + +# Время жизни сессии, идемпотентности и используемое хранилище. +SESSION_TTL_SECONDS=3600 +IDEMPOTENCY_TTL_SECONDS=86400 +SESSION_STORE=valkey + +# Число API-реплик за Nginx. +API_REPLICAS=2 + +# Учётные данные локального PostgreSQL и строка подключения API. +POSTGRES_USER=messenger +POSTGRES_DB=messenger +POSTGRES_PASSWORD=local-postgres-password +DATABASE_URL=postgres://messenger:local-postgres-password@postgres:5432/messenger?sslmode=disable + +# Пароль локального Valkey и строка подключения API. +VALKEY_PASSWORD=local-valkey-password +CACHE_URL=redis://default:local-valkey-password@valkey:6379/0 + +# Размер пула и обслуживание соединений PostgreSQL. +DB_MIN_CONNS=1 +DB_MAX_CONNS=10 +DB_MAX_CONNECTION_AGE_SECONDS=1800 +DB_MAX_CONNECTION_IDLE_SECONDS=300 +DB_HEALTH_CHECK_SECONDS=30 + +# Таймауты зависимостей, миграций и HTTP-запросов. +DEPENDENCY_TIMEOUT_SECONDS=5 +MIGRATION_TIMEOUT_SECONDS=30 +REQUEST_TIMEOUT_SECONDS=5 +HTTP_READ_HEADER_TIMEOUT_SECONDS=5 +HTTP_READ_TIMEOUT_SECONDS=10 +HTTP_WRITE_TIMEOUT_SECONDS=10 +HTTP_IDLE_TIMEOUT_SECONDS=60 +HTTP_SHUTDOWN_TIMEOUT_SECONDS=5 + +# Параметры Argon2id для новых хешей паролей. +PASSWORD_MEMORY_KIB=65536 +PASSWORD_ITERATIONS=3 +PASSWORD_PARALLELISM=2 +PASSWORD_SALT_LENGTH=16 +PASSWORD_KEY_LENGTH=32 + +# Порт Swagger внутри конфигурации CORS API. +SWAGGER_PORT=8081 + +# Ограничения ресурсов контейнеров. +API_CPUS=1 +API_MEMORY=256m +MIGRATE_CPUS=0.5 +MIGRATE_MEMORY=128m +NGINX_CPUS=0.5 +NGINX_MEMORY=128m +SWAGGER_CPUS=0.25 +SWAGGER_MEMORY=128m +TEST_CPUS=2 +TEST_MEMORY=512m +EXPORTER_CPUS=0.25 +EXPORTER_MEMORY=128m +PROMETHEUS_CPUS=1 +PROMETHEUS_MEMORY=512m +GRAFANA_CPUS=0.5 +GRAFANA_MEMORY=256m +POSTGRES_CPUS=2 +POSTGRES_MEMORY=1g +VALKEY_CPUS=1 +VALKEY_MEMORY=256m + +# Пароль локального администратора Grafana. +GRAFANA_ADMIN_PASSWORD=local-grafana-password diff --git a/migrations/0001_initial.sql b/migrations/0001_initial.sql new file mode 100644 index 00000000..2f9b90b4 --- /dev/null +++ b/migrations/0001_initial.sql @@ -0,0 +1,50 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_length CHECK (char_length(display_name) BETWEEN 1 AND 100), + CONSTRAINT users_display_name_not_blank CHECK (display_name ~ '[^[:space:]]'), + CONSTRAINT users_password_hash_length CHECK (char_length(password_hash) BETWEEN 1 AND 1024), + CONSTRAINT users_password_hash_not_blank CHECK (password_hash ~ '[^[:space:]]') +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_length CHECK (char_length(title) BETWEEN 1 AND 100), + CONSTRAINT chats_title_not_blank CHECK (title ~ '[^[:space:]]') +); + +CREATE INDEX chats_created_at_id_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL, + user_id UUID NOT NULL, + position SMALLINT NOT NULL, + CONSTRAINT chat_members_pk PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_chat_position_unique UNIQUE (chat_id, position), + CONSTRAINT chat_members_position_range CHECK (position BETWEEN 0 AND 99), + CONSTRAINT chat_members_chat_fk FOREIGN KEY (chat_id) REFERENCES chats (id) ON DELETE CASCADE, + CONSTRAINT chat_members_user_fk FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE +); + +CREATE INDEX chat_members_user_id_chat_id_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL, + sender_id UUID NOT NULL, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT messages_text_length CHECK (char_length(text) BETWEEN 1 AND 4000), + CONSTRAINT messages_text_not_blank CHECK (text ~ '[^[:space:]]'), + CONSTRAINT messages_sender_membership_fk FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE CASCADE +); + +CREATE INDEX messages_chat_id_created_at_id_idx ON messages (chat_id, created_at, id); diff --git a/migrations/0002_message_idempotency.sql b/migrations/0002_message_idempotency.sql new file mode 100644 index 00000000..91443a48 --- /dev/null +++ b/migrations/0002_message_idempotency.sql @@ -0,0 +1,19 @@ +CREATE TABLE message_idempotency ( + user_id UUID NOT NULL, + chat_id UUID NOT NULL, + key TEXT NOT NULL, + request_hash BYTEA NOT NULL, + message_id UUID NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + expires_at TIMESTAMPTZ NOT NULL, + CONSTRAINT message_idempotency_pk PRIMARY KEY (user_id, chat_id, key), + CONSTRAINT message_idempotency_user_fk FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE, + CONSTRAINT message_idempotency_chat_fk FOREIGN KEY (chat_id) REFERENCES chats (id) ON DELETE CASCADE, + CONSTRAINT message_idempotency_message_fk FOREIGN KEY (message_id) REFERENCES messages (id) + ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, + CONSTRAINT message_idempotency_key_format CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'), + CONSTRAINT message_idempotency_request_hash_length CHECK (octet_length(request_hash) = 32), + CONSTRAINT message_idempotency_expiry CHECK (expires_at > created_at) +); + +CREATE INDEX message_idempotency_expires_at_idx ON message_idempotency (expires_at); diff --git a/migrations/embed.go b/migrations/embed.go new file mode 100644 index 00000000..08bbf60c --- /dev/null +++ b/migrations/embed.go @@ -0,0 +1,8 @@ +package migrations + +import "embed" + +// FS contains database migrations applied by the application at startup. +// +//go:embed *.sql +var FS embed.FS diff --git a/monitoring/grafana/dashboards/messenger.json b/monitoring/grafana/dashboards/messenger.json new file mode 100644 index 00000000..f6af0cd2 --- /dev/null +++ b/monitoring/grafana/dashboards/messenger.json @@ -0,0 +1,99 @@ +{ + "annotations": {"list": []}, + "editable": false, + "graphTooltip": 1, + "panels": [ + { + "type": "timeseries", "title": "API requests per second", "id": 1, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 0}, + "targets": [{"expr": "sum(rate(messenger_http_requests_total[1m]))", "legendFormat": "total", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API RPS by replica", "id": 2, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 0}, + "targets": [{"expr": "sum by (instance) (rate(messenger_http_requests_total[1m]))", "legendFormat": "{{instance}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API responses by status class", "id": 3, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 8}, + "targets": [{"expr": "sum by (status_class) (rate(messenger_http_requests_total[1m]))", "legendFormat": "{{status_class}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Healthy API replicas", "id": 4, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 8}, + "targets": [{"expr": "sum(up{job=\"messenger\"})", "legendFormat": "replicas", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API latency p95 by replica and route", "id": 5, + "gridPos": {"h": 8, "w": 24, "x": 0, "y": 16}, + "fieldConfig": {"defaults": {"unit": "s"}, "overrides": []}, + "targets": [{"expr": "histogram_quantile(0.95, sum by (le, instance, route) (rate(messenger_http_request_duration_seconds_bucket[5m])))", "legendFormat": "{{instance}} {{route}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API in flight", "id": 6, + "gridPos": {"h": 8, "w": 8, "x": 0, "y": 24}, + "targets": [{"expr": "messenger_http_requests_in_flight", "legendFormat": "{{instance}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Go heap by replica", "id": 7, + "gridPos": {"h": 8, "w": 8, "x": 8, "y": 24}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "go_memstats_heap_alloc_bytes{job=\"messenger\"}", "legendFormat": "{{instance}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Idempotency replays", "id": 8, + "gridPos": {"h": 8, "w": 8, "x": 16, "y": 24}, + "targets": [{"expr": "sum(rate(messenger_http_idempotency_replays_total[1m]))", "legendFormat": "replays/s", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Nginx connections and requests", "id": 9, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 32}, + "targets": [ + {"expr": "nginx_connections_active", "legendFormat": "active connections", "refId": "A"}, + {"expr": "rate(nginx_http_requests_total[1m])", "legendFormat": "requests/s", "refId": "B"} + ] + }, + { + "type": "timeseries", "title": "PostgreSQL connections", "id": 10, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 32}, + "targets": [{"expr": "sum(pg_stat_activity_count{datname=\"messenger\"})", "legendFormat": "connections", "refId": "A"}] + }, + { + "type": "timeseries", "title": "PostgreSQL transactions", "id": 11, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 40}, + "targets": [ + {"expr": "rate(pg_stat_database_xact_commit{datname=\"messenger\"}[1m])", "legendFormat": "commit/s", "refId": "A"}, + {"expr": "rate(pg_stat_database_xact_rollback{datname=\"messenger\"}[1m])", "legendFormat": "rollback/s", "refId": "B"} + ] + }, + { + "type": "timeseries", "title": "PostgreSQL database size", "id": 12, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 40}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "pg_database_size_bytes{datname=\"messenger\"}", "legendFormat": "database", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Valkey memory", "id": 13, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 48}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "redis_memory_used_bytes", "legendFormat": "used", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Valkey keys and commands", "id": 14, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 48}, + "targets": [ + {"expr": "sum(redis_db_keys)", "legendFormat": "keys", "refId": "A"}, + {"expr": "rate(redis_commands_processed_total[1m])", "legendFormat": "commands/s", "refId": "B"} + ] + } + ], + "refresh": "5s", + "schemaVersion": 41, + "tags": ["highload", "lab4", "nginx", "failover"], + "templating": {"list": []}, + "time": {"from": "now-15m", "to": "now"}, + "timezone": "browser", + "title": "Messenger lab3 overview", + "uid": "messenger-overview", + "version": 2 +} diff --git a/monitoring/grafana/provisioning/dashboards/messenger.yml b/monitoring/grafana/provisioning/dashboards/messenger.yml new file mode 100644 index 00000000..fa7934cb --- /dev/null +++ b/monitoring/grafana/provisioning/dashboards/messenger.yml @@ -0,0 +1,10 @@ +apiVersion: 1 + +providers: + - name: Messenger + folder: Highload + type: file + disableDeletion: true + editable: false + options: + path: /etc/grafana/dashboards diff --git a/monitoring/grafana/provisioning/datasources/prometheus.yml b/monitoring/grafana/provisioning/datasources/prometheus.yml new file mode 100644 index 00000000..8704d9e5 --- /dev/null +++ b/monitoring/grafana/provisioning/datasources/prometheus.yml @@ -0,0 +1,10 @@ +apiVersion: 1 + +datasources: + - name: Prometheus + type: prometheus + uid: prometheus + access: proxy + url: http://prometheus:9090 + isDefault: true + editable: false diff --git a/monitoring/prometheus.yml b/monitoring/prometheus.yml new file mode 100644 index 00000000..2c0881ea --- /dev/null +++ b/monitoring/prometheus.yml @@ -0,0 +1,23 @@ +global: + scrape_interval: 5s + evaluation_interval: 5s + +scrape_configs: + - job_name: messenger + dns_sd_configs: + - names: ["api"] + type: A + port: 8080 + refresh_interval: 2s + + - job_name: nginx + static_configs: + - targets: ["nginx-exporter:9113"] + + - job_name: postgres + static_configs: + - targets: ["postgres-exporter:9187"] + + - job_name: valkey + static_configs: + - targets: ["valkey-exporter:9121"] diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..9dcebe8f --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,55 @@ +user nginx; +worker_processes auto; +error_log /dev/stderr notice; +pid /var/run/nginx.pid; + +events { + worker_connections 1024; +} + +http { + resolver 127.0.0.11 valid=2s ipv6=off; + + log_format structured escape=json + '{"time":"$time_iso8601","request_id":"$http_x_request_id",' + '"method":"$request_method","uri":"$request_uri","status":$status,' + '"request_time":$request_time,"upstream":"$upstream_addr",' + '"upstream_status":"$upstream_status","upstream_time":"$upstream_response_time"}'; + + access_log /dev/stdout structured; + + upstream messenger { + zone messenger 64k; + server api:8080 resolve max_fails=1 fail_timeout=3s; + keepalive 32; + } + + server { + listen 8080; + + location / { + proxy_pass http://messenger; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + proxy_connect_timeout 1s; + proxy_send_timeout 10s; + proxy_read_timeout 10s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + proxy_next_upstream_timeout 3s; + } + } + + server { + listen 8081; + access_log off; + + location = /stub_status { + stub_status; + } + } +} diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..cacb5215 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +set -eu + +docker compose stop nginx api valkey postgres +docker compose start postgres valkey +docker compose run --rm migrate +docker compose up -d --wait --wait-timeout 90 diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..e32e2973 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,57 @@ +#!/bin/sh + +set -eu + +wait_for_replicas() { + expected=$1 + deadline=$(($(date +%s) + 90)) + + while [ "$(date +%s)" -lt "$deadline" ]; do + containers=$(docker compose ps -q api) + count=0 + healthy=0 + for container in $containers; do + count=$((count + 1)) + status=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$container") + if [ "$status" = "healthy" ]; then + healthy=$((healthy + 1)) + fi + done + if [ "$count" -eq "$expected" ] && [ "$healthy" -eq "$expected" ]; then + return 0 + fi + sleep 1 + done + + printf '%s\n' "API replicas did not become healthy: expected $expected" >&2 + return 1 +} + +old_containers=$(docker compose ps -q api) +old_count=0 +for container in $old_containers; do + old_count=$((old_count + 1)) +done + +docker compose build +docker compose up -d postgres valkey +docker compose run --rm migrate + +if [ "$old_count" -lt 2 ]; then + docker compose up -d --scale api=2 --wait --wait-timeout 120 + exit 0 +fi + +docker compose up -d --no-deps --no-recreate --scale api=3 api +wait_for_replicas 3 + +for container in $old_containers; do + docker stop --time 6 "$container" >/dev/null + docker rm "$container" >/dev/null + docker compose up -d --no-deps --no-recreate --scale api=3 api + wait_for_replicas 3 +done + +docker compose up -d --no-deps --no-recreate --scale api=2 api +wait_for_replicas 2 +docker compose up -d --no-build --scale api=2 --wait --wait-timeout 120 diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..5327251e --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +set -eu + +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}" + +for container in $(docker compose ps -q api); do + instance=$(docker inspect --format '{{.Config.Hostname}}' "$container") + if [ "$instance" = "$TARGET_INSTANCE_ID" ]; then + docker stop --time 6 "$container" >/dev/null + exit 0 + fi +done + +printf '%s\n' "API instance not found: $TARGET_INSTANCE_ID" >&2 +exit 1 -- 2.54.0 From ec0e6707b8d90bb964ff5d278897421a9516b17b Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 19:41:26 +0300 Subject: [PATCH 02/15] feat: add S3 attachments and reconciliation --- cmd/messenger/main.go | 85 ++++++- go.mod | 14 +- go.sum | 25 +- internal/config/config.go | 117 +++++++-- internal/messenger/attachments.go | 260 ++++++++++++++++++++ internal/messenger/errors.go | 1 + internal/messenger/handlers.go | 36 ++- internal/messenger/messenger_interface.go | 13 +- internal/messenger/metrics.go | 41 ++- internal/messenger/model.go | 1 + internal/messenger/routes.go | 6 + internal/messenger/server.go | 16 +- internal/messenger/server_test.go | 221 ++++++++++++++++- internal/model/model.go | 79 +++++- internal/objectstore/store.go | 180 ++++++++++++++ internal/postgres/attachments.go | 155 ++++++++++++ internal/postgres/idempotency.go | 82 +++++- internal/postgres/store.go | 17 +- internal/postgres/store_integration_test.go | 80 +++++- internal/reconcile/reconcile.go | 236 ++++++++++++++++++ migrations/0003_attachments.sql | 47 ++++ 21 files changed, 1627 insertions(+), 85 deletions(-) create mode 100644 internal/messenger/attachments.go create mode 100644 internal/objectstore/store.go create mode 100644 internal/postgres/attachments.go create mode 100644 internal/reconcile/reconcile.go create mode 100644 migrations/0003_attachments.sql diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 76ed2d19..90f25b60 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -2,20 +2,26 @@ package main import ( "context" + "encoding/json" + "flag" "fmt" + "io" "log/slog" "net" "net/http" "os" "os/signal" "syscall" + "time" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/logger" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" ) @@ -34,7 +40,10 @@ func run(logger *slog.Logger, arguments []string) error { if len(arguments) == 1 && arguments[0] == "migrate" { return runMigrations() } - return fmt.Errorf("usage: messenger [migrate]") + if len(arguments) > 0 && arguments[0] == "reconcile-attachments" { + return runAttachmentReconciliation(arguments[1:], os.Stdout) + } + return fmt.Errorf("usage: messenger [migrate|reconcile-attachments]") } func runServer(logger *slog.Logger) error { @@ -68,16 +77,28 @@ func runServer(logger *slog.Logger) error { if err != nil { return err } + objects, err := objectstore.New(objectstore.Config{ + Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, + AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, + UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, + }) + if err != nil { + return err + } app := messenger.NewServer( logger, postgres.New(pool), sessions, passwords, + objects, settings.SessionTTL, settings.IdempotencyTTL, settings.RequestTimeout, instanceID, settings.SwaggerPort, + settings.AttachmentMaxBytes, + settings.AttachmentMaxPixels, + settings.AttachmentDecodeMemory, ) server := &http.Server{ Addr: settings.Address, @@ -130,3 +151,65 @@ func runMigrations() error { defer pool.Close() return database.Migrate(context.Background(), pool, settings.MigrationTimeout) } + +type reconciliationOutput struct { + Mode string `json:"mode"` + GracePeriod string `json:"grace_period"` + PageSize int `json:"page_size"` + DurationMillis int64 `json:"duration_ms"` + Report reconcile.Report `json:"report"` +} + +func runAttachmentReconciliation(arguments []string, output io.Writer) error { + flags := flag.NewFlagSet("reconcile-attachments", flag.ContinueOnError) + flags.SetOutput(io.Discard) + apply := flags.Bool("apply", false, "apply safe repairs") + gracePeriod := flags.Duration("grace-period", time.Hour, "minimum anomaly age") + pageSize := flags.Int("page-size", 500, "S3 and PostgreSQL page size") + if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { + return fmt.Errorf("usage: messenger reconcile-attachments [--apply] [--grace-period=1h] [--page-size=500]") + } + + settings, err := config.Load() + if err != nil { + return err + } + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + pool, err := database.Open(ctx, database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + objects, err := objectstore.New(objectstore.Config{ + Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, + AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, + UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, + }) + if err != nil { + return err + } + reconciler, err := reconcile.New(postgres.New(pool), objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, GraceTime: *gracePeriod, Apply: *apply, + }) + if err != nil { + return err + } + started := time.Now() + report, err := reconciler.Run(ctx) + if err != nil { + return err + } + mode := "dry-run" + if *apply { + mode = "apply" + } + return json.NewEncoder(output).Encode(reconciliationOutput{ + Mode: mode, GracePeriod: gracePeriod.String(), PageSize: *pageSize, + DurationMillis: time.Since(started).Milliseconds(), Report: report, + }) +} diff --git a/go.mod b/go.mod index f498f1b3..b3de9ffb 100644 --- a/go.mod +++ b/go.mod @@ -5,37 +5,49 @@ go 1.26.0 require ( github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.11.0 + github.com/minio/minio-go/v7 v7.0.99 github.com/prometheus/client_golang v1.23.2 github.com/spf13/viper v1.21.0 github.com/stretchr/testify v1.11.1 github.com/valkey-io/valkey-go v1.0.78 golang.org/x/crypto v0.57.0 + golang.org/x/sync v0.23.0 ) require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/go-ini/ini v1.67.0 // indirect github.com/go-viper/mapstructure/v2 v2.4.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/klauspost/compress v1.18.2 // indirect + github.com/klauspost/cpuid/v2 v2.2.11 // indirect + github.com/klauspost/crc32 v1.3.0 // indirect + github.com/minio/crc64nvme v1.1.1 // indirect + github.com/minio/md5-simd v1.1.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect + github.com/philhofer/fwd v1.2.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.66.1 // indirect github.com/prometheus/procfs v0.16.1 // indirect + github.com/rs/xid v1.6.0 // indirect github.com/sagikazarmark/locafero v0.11.0 // indirect github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect github.com/spf13/afero v1.15.0 // indirect github.com/spf13/cast v1.10.0 // indirect github.com/spf13/pflag v1.0.10 // indirect github.com/subosito/gotenv v1.6.0 // indirect + github.com/tinylib/msgp v1.6.1 // indirect go.yaml.in/yaml/v2 v2.4.2 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/sync v0.23.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.48.0 // indirect golang.org/x/text v0.42.0 // indirect google.golang.org/protobuf v1.36.8 // indirect diff --git a/go.sum b/go.sum index e55a574b..5aa456c6 100644 --- a/go.sum +++ b/go.sum @@ -5,10 +5,14 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= +github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= @@ -23,20 +27,33 @@ github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= -github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= -github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk= +github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU= +github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM= +github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI= +github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.99 h1:2vH/byrwUkIpFQFOilvTfaUpvAX3fEFhEzO+DR3DlCE= +github.com/minio/minio-go/v7 v7.0.99/go.mod h1:EtGNKtlX20iL2yaYnxEigaIvj0G0GwSDnifnG8ClIdw= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I= github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= +github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= +github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= 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/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= @@ -49,6 +66,8 @@ github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzM github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc= github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik= github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= @@ -68,6 +87,8 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/tinylib/msgp v1.6.1 h1:ESRv8eL3u+DNHUoSAAQRE50Hm162zqAnBoGv9PzScPY= +github.com/tinylib/msgp v1.6.1/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= github.com/valkey-io/valkey-go v1.0.78 h1:1Ce8hRaaNXpKfqmqZQRhnbVh1eW8MGR873pdXVvE4y8= github.com/valkey-io/valkey-go v1.0.78/go.mod h1:gvC/r2m3eW4Hbj0YnjogTzNtFdPSM/D+NCqen+5OABM= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= diff --git a/internal/config/config.go b/internal/config/config.go index 44571418..2fcfab32 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -12,29 +12,39 @@ import ( ) type Config struct { - Address string - DatabaseURL string - CacheURL string - SessionTTL time.Duration - IdempotencyTTL time.Duration - DBMaxConns int32 - DBMinConns int32 - DBMaxConnectionAge time.Duration - DBMaxConnectionIdle time.Duration - DBHealthCheckPeriod time.Duration - DependencyTimeout time.Duration - RequestTimeout time.Duration - HTTPReadHeaderTimeout time.Duration - HTTPReadTimeout time.Duration - HTTPWriteTimeout time.Duration - HTTPIdleTimeout time.Duration - HTTPShutdownTimeout time.Duration - PasswordMemoryKiB uint32 - PasswordIterations uint32 - PasswordParallelism uint8 - PasswordSaltLength uint32 - PasswordKeyLength uint32 - SwaggerPort string + Address string + DatabaseURL string + CacheURL string + SessionTTL time.Duration + IdempotencyTTL time.Duration + DBMaxConns int32 + DBMinConns int32 + DBMaxConnectionAge time.Duration + DBMaxConnectionIdle time.Duration + DBHealthCheckPeriod time.Duration + DependencyTimeout time.Duration + RequestTimeout time.Duration + HTTPReadHeaderTimeout time.Duration + HTTPReadTimeout time.Duration + HTTPWriteTimeout time.Duration + HTTPIdleTimeout time.Duration + HTTPShutdownTimeout time.Duration + PasswordMemoryKiB uint32 + PasswordIterations uint32 + PasswordParallelism uint8 + PasswordSaltLength uint32 + PasswordKeyLength uint32 + SwaggerPort string + S3Endpoint string + S3Region string + S3Bucket string + S3AccessKey string + S3SecretKey string + S3UseTLS bool + S3Timeout time.Duration + AttachmentMaxBytes int64 + AttachmentMaxPixels int64 + AttachmentDecodeMemory int64 } type MigrationConfig struct { @@ -142,6 +152,50 @@ func Load() (Config, error) { if err != nil { return Config{}, err } + s3Endpoint, err := requiredString(values, "S3_ENDPOINT") + if err != nil { + return Config{}, err + } + s3Region, err := requiredString(values, "S3_REGION") + if err != nil { + return Config{}, err + } + s3Bucket, err := requiredString(values, "S3_BUCKET") + if err != nil { + return Config{}, err + } + s3AccessKey, err := requiredString(values, "S3_ACCESS_KEY") + if err != nil { + return Config{}, err + } + s3SecretKey, err := requiredString(values, "S3_SECRET_KEY") + if err != nil { + return Config{}, err + } + s3UseTLS, err := boolean(values, "S3_USE_TLS") + if err != nil { + return Config{}, err + } + s3Timeout, err := seconds(values, "S3_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + attachmentMaxBytes, err := integer(values, "ATTACHMENT_MAX_BYTES", 1, 10*1024*1024) + if err != nil { + return Config{}, err + } + attachmentMaxPixels, err := integer(values, "ATTACHMENT_MAX_PIXELS", 1, 40_000_000) + if err != nil { + return Config{}, err + } + attachmentDecodeMemory, err := integer(values, "ATTACHMENT_DECODE_MEMORY_BYTES", 1, 1024*1024*1024) + if err != nil { + return Config{}, err + } + minimumDecodeMemory := int64(attachmentMaxBytes) + int64(attachmentMaxPixels)*8 + if int64(attachmentDecodeMemory) < minimumDecodeMemory { + return Config{}, fmt.Errorf("ATTACHMENT_DECODE_MEMORY_BYTES: must be at least %d", minimumDecodeMemory) + } return Config{ Address: net.JoinHostPort(host, port), DatabaseURL: database.url, CacheURL: cacheURL, @@ -155,7 +209,10 @@ func Load() (Config, error) { HTTPShutdownTimeout: shutdownTimeout, PasswordMemoryKiB: uint32(passwordMemory), PasswordIterations: uint32(passwordIterations), PasswordParallelism: uint8(passwordParallelism), PasswordSaltLength: uint32(passwordSaltLength), PasswordKeyLength: uint32(passwordKeyLength), - SwaggerPort: swaggerPort, + SwaggerPort: swaggerPort, S3Endpoint: s3Endpoint, S3Region: s3Region, S3Bucket: s3Bucket, + S3AccessKey: s3AccessKey, S3SecretKey: s3SecretKey, S3UseTLS: s3UseTLS, S3Timeout: s3Timeout, + AttachmentMaxBytes: int64(attachmentMaxBytes), AttachmentMaxPixels: int64(attachmentMaxPixels), + AttachmentDecodeMemory: int64(attachmentDecodeMemory), }, nil } @@ -260,3 +317,15 @@ func integerValue(value string, minimum, maximum int) (int, error) { } return parsed, nil } + +func boolean(values *viper.Viper, name string) (bool, error) { + value, err := requiredString(values, name) + if err != nil { + return false, err + } + parsed, err := strconv.ParseBool(value) + if err != nil { + return false, fmt.Errorf("%s: must be true or false", name) + } + return parsed, nil +} diff --git a/internal/messenger/attachments.go b/internal/messenger/attachments.go new file mode 100644 index 00000000..f69a5067 --- /dev/null +++ b/internal/messenger/attachments.go @@ -0,0 +1,260 @@ +package messenger + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "mime" + "net/http" + "net/url" + "strconv" + "strings" + "time" + "unicode" + "unicode/utf8" + + "golang.org/x/sync/semaphore" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" +) + +func (s *Server) uploadAttachment(w http.ResponseWriter, r *http.Request) *apiError { + started := time.Now() + result := "client_error" + defer func() { + s.metrics.attachmentUploads.WithLabelValues(result).Inc() + s.metrics.attachmentDuration.Observe(time.Since(started).Seconds()) + }() + + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + filename, valid := attachmentFilename(r.URL.Query()) + if !valid { + return invalidRequest() + } + if _, err := s.messengerStore.ChatForUser(r.Context(), chatID, user.ID); errors.Is(err, postgres.ErrNotFound) { + return notFound() + } else if err != nil { + result = "dependency_error" + return unavailable() + } + data, contentType, readErr := readImage(w, r, s.maxUploadBytes, s.maxImagePixels, s.decodeMemory) + if readErr != nil { + return readErr + } + + attachmentID, err := newID() + if err != nil { + result = "dependency_error" + return internalError() + } + objectID, err := newID() + if err != nil { + result = "dependency_error" + return internalError() + } + objectKey := "attachments/" + objectID + "/original" + if err := s.objects.Put(r.Context(), objectKey, contentType, data); err != nil { + result = "dependency_error" + return unavailable() + } + digest := sha256.Sum256(data) + attachment, err := s.messengerStore.CreateAttachment(r.Context(), model.Attachment{ + ID: attachmentID, ChatID: chatID, OwnerID: user.ID, Filename: filename, + ContentType: contentType, SizeBytes: int64(len(data)), SHA256: hex.EncodeToString(digest[:]), ObjectKey: objectKey, + }) + if err != nil { + result = "dependency_error" + cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), s.requestTTL) + defer cancel() + stored, lookupErr := s.messengerStore.AttachmentByStorage(cleanupCtx, attachmentID, objectKey) + if lookupErr == nil { + result = "success" + s.metrics.attachmentBytes.Add(float64(len(data))) + writeJSON(w, http.StatusCreated, stored) + return nil + } + if !errors.Is(lookupErr, postgres.ErrNotFound) { + s.logger.Error("attachment outcome is unknown", "attachment_id", attachmentID, "error", lookupErr) + return unavailable() + } + if cleanupErr := s.objects.Delete(cleanupCtx, objectKey); cleanupErr != nil { + s.logger.Error("attachment compensation failed", "object_key", objectKey, "error", cleanupErr) + } + if errors.Is(err, postgres.ErrNotFound) { + return notFound() + } + return unavailable() + } + result = "success" + s.metrics.attachmentBytes.Add(float64(len(data))) + writeJSON(w, http.StatusCreated, attachment) + return nil +} + +func attachmentFilename(query url.Values) (string, bool) { + if len(query) != 1 || len(query["filename"]) != 1 { + return "", false + } + filename := query["filename"][0] + length := utf8.RuneCountInString(filename) + if !utf8.ValidString(filename) || strings.TrimSpace(filename) == "" || length < 1 || length > 255 { + return "", false + } + for _, char := range filename { + if char == '/' || char == '\\' || char == 0 || unicode.IsControl(char) { + return "", false + } + } + return filename, true +} + +func readImage( + w http.ResponseWriter, + r *http.Request, + maxBytes int64, + maxPixels int64, + decodeMemory *semaphore.Weighted, +) ([]byte, string, *apiError) { + mediaType, parameters, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || len(parameters) != 0 || mediaType != "image/png" && mediaType != "image/jpeg" { + return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "unsupported image type"} + } + if r.ContentLength > maxBytes { + return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image is too large"} + } + r.Body = http.MaxBytesReader(w, r.Body, maxBytes) + data, err := io.ReadAll(r.Body) + if err != nil { + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image is too large"} + } + return nil, "", invalidRequest() + } + if len(data) == 0 { + return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} + } + detected := http.DetectContentType(data) + if detected != mediaType { + return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "content type does not match image"} + } + imageConfig, format, err := image.DecodeConfig(bytes.NewReader(data)) + if err != nil || imageContentType(format) != mediaType { + return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} + } + pixels := int64(imageConfig.Width) * int64(imageConfig.Height) + if imageConfig.Width < 1 || imageConfig.Height < 1 || pixels > maxPixels { + return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image dimensions are too large"} + } + decodeBytes := pixels*8 + int64(len(data)) + if !decodeMemory.TryAcquire(decodeBytes) { + w.Header().Set("Retry-After", "1") + return nil, "", &apiError{http.StatusTooManyRequests, errorCodeRateLimited, "image capacity is temporarily exhausted"} + } + defer decodeMemory.Release(decodeBytes) + if _, format, err := image.Decode(bytes.NewReader(data)); err != nil || imageContentType(format) != mediaType { + return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} + } + return data, mediaType, nil +} + +func imageContentType(format string) string { + switch format { + case "png": + return "image/png" + case "jpeg": + return "image/jpeg" + default: + return "" + } +} + +func (s *Server) attachmentMetadata(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + attachment, apiErr := s.attachmentForUser(r, user.ID) + if apiErr != nil { + return apiErr + } + writeJSON(w, http.StatusOK, attachment) + return nil +} + +func (s *Server) attachmentContent(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if !originalVariant(r.URL.Query()) { + return invalidRequest() + } + attachment, apiErr := s.attachmentForUser(r, user.ID) + if apiErr != nil { + return apiErr + } + content, err := s.objects.Get(r.Context(), attachment.ObjectKey) + if errors.Is(err, objectstore.ErrNotFound) { + return unavailable() + } + if err != nil { + return unavailable() + } + defer func() { _ = content.Close() }() + w.Header().Set("Content-Type", attachment.ContentType) + w.Header().Set("Content-Length", strconv.FormatInt(attachment.SizeBytes, 10)) + w.Header().Set("Content-Disposition", mime.FormatMediaType("inline", map[string]string{"filename": attachment.Filename})) + w.WriteHeader(http.StatusOK) + if _, err := io.Copy(w, content); err != nil { + s.logger.Warn("attachment download interrupted", "attachment_id", attachment.ID, "error", err) + } + return nil +} + +func originalVariant(query url.Values) bool { + if len(query) == 0 { + return true + } + return len(query) == 1 && len(query["variant"]) == 1 && query["variant"][0] == "original" +} + +func (s *Server) attachmentForUser(r *http.Request, userID string) (Attachment, *apiError) { + parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/") + attachmentID, valid := canonicalID(parts[3]) + if !valid { + return Attachment{}, invalidRequest() + } + attachment, err := s.messengerStore.AttachmentForUser(r.Context(), attachmentID, userID) + if errors.Is(err, postgres.ErrNotFound) { + return Attachment{}, notFound() + } + if err != nil { + return Attachment{}, unavailable() + } + return attachment, nil +} diff --git a/internal/messenger/errors.go b/internal/messenger/errors.go index 88d29705..43923b76 100644 --- a/internal/messenger/errors.go +++ b/internal/messenger/errors.go @@ -14,6 +14,7 @@ const ( errorCodePayloadTooLarge = "payload_too_large" errorCodeUnavailable = "unavailable" errorCodeConflict = "conflict" + errorCodeRateLimited = "rate_limited" ) type apiError struct { diff --git a/internal/messenger/handlers.go b/internal/messenger/handlers.go index bedff654..29ec395c 100644 --- a/internal/messenger/handlers.go +++ b/internal/messenger/handlers.go @@ -38,6 +38,9 @@ func (s *Server) readiness(w http.ResponseWriter, r *http.Request) *apiError { if err := s.sessions.Ping(ctx); err != nil { return unavailable() } + if err := s.objects.Ping(ctx); err != nil { + return unavailable() + } writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) return nil } @@ -207,16 +210,17 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { return invalidRequest() } var input struct { - Text string `json:"text"` + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` } if err := readJSON(w, r, &input); err != nil { return err } - if !validText(input.Text, 4000) { + if !validMessage(input.Text, input.AttachmentIDs) || !canonicalAttachmentIDs(input.AttachmentIDs) { return invalidRequest() } message, replay, err := s.messengerStore.CreateMessage( - r.Context(), chatID, user.ID, input.Text, key, s.idempotencyTTL, + r.Context(), chatID, user.ID, input.Text, input.AttachmentIDs, key, s.idempotencyTTL, ) if errors.Is(err, postgres.ErrNotFound) { return notFound() @@ -234,6 +238,32 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { return nil } +func validMessage(text string, attachmentIDs []string) bool { + if !utf8.ValidString(text) || utf8.RuneCountInString(text) > 4000 { + return false + } + return len(attachmentIDs) > 0 || strings.TrimSpace(text) != "" +} + +func canonicalAttachmentIDs(attachmentIDs []string) bool { + if len(attachmentIDs) > 10 { + return false + } + seen := make(map[string]struct{}, len(attachmentIDs)) + for index, attachmentID := range attachmentIDs { + canonical, valid := canonicalID(attachmentID) + if !valid { + return false + } + if _, duplicate := seen[canonical]; duplicate { + return false + } + seen[canonical] = struct{}{} + attachmentIDs[index] = canonical + } + return true +} + func (s *Server) listMessages(w http.ResponseWriter, r *http.Request, user User, chatID string) *apiError { limit, cursor, err := pageParams(r, "message", chatID) if err != nil { diff --git a/internal/messenger/messenger_interface.go b/internal/messenger/messenger_interface.go index 14005ade..682a10f3 100644 --- a/internal/messenger/messenger_interface.go +++ b/internal/messenger/messenger_interface.go @@ -2,6 +2,7 @@ package messenger import ( "context" + "io" "time" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" @@ -15,8 +16,18 @@ type MessengerStore interface { CreateChat(context.Context, string, []string, string) (model.Chat, error) ChatForUser(context.Context, string, string) (model.Chat, error) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) - CreateMessage(context.Context, string, string, string, string, time.Duration) (model.Message, bool, error) + CreateMessage(context.Context, string, string, string, []string, string, time.Duration) (model.Message, bool, error) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) + CreateAttachment(context.Context, model.Attachment) (model.Attachment, error) + AttachmentByStorage(context.Context, string, string) (model.Attachment, error) + AttachmentForUser(context.Context, string, string) (model.Attachment, error) +} + +type ObjectStore interface { + Ping(context.Context) error + Put(context.Context, string, string, []byte) error + Get(context.Context, string) (io.ReadCloser, error) + Delete(context.Context, string) error } type SessionStore interface { diff --git a/internal/messenger/metrics.go b/internal/messenger/metrics.go index 8073542e..267d4b7f 100644 --- a/internal/messenger/metrics.go +++ b/internal/messenger/metrics.go @@ -12,11 +12,14 @@ import ( ) type metrics struct { - requests *prometheus.CounterVec - duration *prometheus.HistogramVec - inFlight prometheus.Gauge - replays prometheus.Counter - handler http.Handler + requests *prometheus.CounterVec + duration *prometheus.HistogramVec + inFlight prometheus.Gauge + replays prometheus.Counter + attachmentUploads *prometheus.CounterVec + attachmentDuration prometheus.Histogram + attachmentBytes prometheus.Counter + handler http.Handler } func newMetrics() *metrics { @@ -47,12 +50,31 @@ func newMetrics() *metrics { Name: "idempotency_replays_total", Help: "Message requests served from an idempotency record.", }), + attachmentUploads: prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "messenger", + Name: "attachment_uploads_total", + Help: "Completed attachment uploads by result.", + }, []string{"result"}), + attachmentDuration: prometheus.NewHistogram(prometheus.HistogramOpts{ + Namespace: "messenger", + Name: "attachment_upload_duration_seconds", + Help: "Attachment upload duration in seconds.", + Buckets: prometheus.DefBuckets, + }), + attachmentBytes: prometheus.NewCounter(prometheus.CounterOpts{ + Namespace: "messenger", + Name: "attachment_upload_bytes_total", + Help: "Bytes accepted by successful attachment uploads.", + }), } registry.MustRegister( result.requests, result.duration, result.inFlight, result.replays, + result.attachmentUploads, + result.attachmentDuration, + result.attachmentBytes, collectors.NewGoCollector(), collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}), ) @@ -79,5 +101,14 @@ func routeTemplate(path string) string { if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { return "/api/v1/chats/{chat_id}/messages" } + if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "attachments" { + return "/api/v1/chats/{chat_id}/attachments" + } + if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "attachments" { + return "/api/v1/attachments/{attachment_id}" + } + if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "attachments" && parts[4] == "content" { + return "/api/v1/attachments/{attachment_id}/content" + } return "unknown" } diff --git a/internal/messenger/model.go b/internal/messenger/model.go index ca5eefa2..f1509b2c 100644 --- a/internal/messenger/model.go +++ b/internal/messenger/model.go @@ -8,6 +8,7 @@ import ( type User = model.User type Chat = model.Chat type Message = model.Message +type Attachment = model.Attachment func newID() (string, error) { id, err := uuid.NewRandom() diff --git a/internal/messenger/routes.go b/internal/messenger/routes.go index bb698d0b..25821e70 100644 --- a/internal/messenger/routes.go +++ b/internal/messenger/routes.go @@ -33,6 +33,12 @@ func (s *Server) route(w http.ResponseWriter, r *http.Request) *apiError { handler = s.chat } else if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { handler = s.messages + } else if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "attachments" { + handler = s.uploadAttachment + } else if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "attachments" { + handler = s.attachmentMetadata + } else if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "attachments" && parts[4] == "content" { + handler = s.attachmentContent } else { return notFound() } diff --git a/internal/messenger/server.go b/internal/messenger/server.go index 3cc2ba00..7d654452 100644 --- a/internal/messenger/server.go +++ b/internal/messenger/server.go @@ -6,18 +6,24 @@ import ( "net/http" "sync/atomic" "time" + + "golang.org/x/sync/semaphore" ) type Server struct { messengerStore MessengerStore sessions SessionStore passwords PasswordService + objects ObjectStore sessionTTL time.Duration idempotencyTTL time.Duration requestTTL time.Duration instanceID string logger *slog.Logger swaggerPort string + maxUploadBytes int64 + maxImagePixels int64 + decodeMemory *semaphore.Weighted metrics *metrics ready atomic.Bool } @@ -37,16 +43,22 @@ func NewServer( messages MessengerStore, sessions SessionStore, passwords PasswordService, + objects ObjectStore, sessionTTL time.Duration, idempotencyTTL time.Duration, requestTTL time.Duration, instanceID string, swaggerPort string, + maxUploadBytes int64, + maxImagePixels int64, + decodeMemoryBytes int64, ) *Server { s := &Server{ - messengerStore: messages, sessions: sessions, passwords: passwords, + messengerStore: messages, sessions: sessions, passwords: passwords, objects: objects, sessionTTL: sessionTTL, idempotencyTTL: idempotencyTTL, requestTTL: requestTTL, - instanceID: instanceID, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), + instanceID: instanceID, logger: logger, swaggerPort: swaggerPort, + maxUploadBytes: maxUploadBytes, maxImagePixels: maxImagePixels, + decodeMemory: semaphore.NewWeighted(decodeMemoryBytes), metrics: newMetrics(), } s.ready.Store(true) return s diff --git a/internal/messenger/server_test.go b/internal/messenger/server_test.go index c38aa0cd..3440240a 100644 --- a/internal/messenger/server_test.go +++ b/internal/messenger/server_test.go @@ -1,9 +1,13 @@ package messenger import ( + "bytes" "context" "errors" "fmt" + "image" + "image/color" + "image/png" "io" "log/slog" "net/http" @@ -13,6 +17,7 @@ import ( "time" "github.com/stretchr/testify/suite" + "golang.org/x/sync/semaphore" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" @@ -34,14 +39,19 @@ func (s *MessengerSuite) SetupTest() { } type messengerStoreStub struct { - pingErr error - userByID model.User - userByIDErr error - credentials model.UserCredentials - credentialsErr error - message model.Message - messageReplay bool - messageErr error + pingErr error + userByID model.User + userByIDErr error + credentials model.UserCredentials + credentialsErr error + message model.Message + messageReplay bool + messageErr error + attachment model.Attachment + attachmentErr error + storedAttachment model.Attachment + storedAttachmentExists bool + storedAttachmentErr error } func (s messengerStoreStub) Ping(context.Context) error { return s.pingErr } @@ -63,12 +73,57 @@ func (messengerStoreStub) ChatForUser(context.Context, string, string) (model.Ch func (messengerStoreStub) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) { return nil, false, nil } -func (s messengerStoreStub) CreateMessage(context.Context, string, string, string, string, time.Duration) (model.Message, bool, error) { +func (s messengerStoreStub) CreateMessage(context.Context, string, string, string, []string, string, time.Duration) (model.Message, bool, error) { return s.message, s.messageReplay, s.messageErr } func (messengerStoreStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { return nil, false, nil } +func (s messengerStoreStub) CreateAttachment(context.Context, model.Attachment) (model.Attachment, error) { + return s.attachment, s.attachmentErr +} +func (s messengerStoreStub) AttachmentByStorage(context.Context, string, string) (model.Attachment, error) { + if s.storedAttachmentErr != nil { + return model.Attachment{}, s.storedAttachmentErr + } + if !s.storedAttachmentExists { + return model.Attachment{}, postgres.ErrNotFound + } + return s.storedAttachment, nil +} +func (s messengerStoreStub) AttachmentForUser(context.Context, string, string) (model.Attachment, error) { + return s.attachment, s.attachmentErr +} + +type objectStoreStub struct { + pingErr error + putErr error + getData []byte + getErr error + deleteErr error + putKey *string + deletedKey *string +} + +func (s objectStoreStub) Ping(context.Context) error { return s.pingErr } +func (s objectStoreStub) Put(_ context.Context, key string, _ string, _ []byte) error { + if s.putKey != nil { + *s.putKey = key + } + return s.putErr +} +func (s objectStoreStub) Get(context.Context, string) (io.ReadCloser, error) { + if s.getErr != nil { + return nil, s.getErr + } + return io.NopCloser(bytes.NewReader(s.getData)), nil +} +func (s objectStoreStub) Delete(_ context.Context, key string) error { + if s.deletedKey != nil { + *s.deletedKey = key + } + return s.deleteErr +} type sessionStub struct { pingErr error @@ -100,14 +155,19 @@ func (s *MessengerSuite) TestReadinessReturnsUnavailableForDependencyFailure() { name string store messengerStoreStub sessions sessionStub + objects objectStoreStub }{ {name: "postgres", store: messengerStoreStub{pingErr: errDependency}}, {name: "valkey", sessions: sessionStub{pingErr: errDependency}}, + {name: "s3", objects: objectStoreStub{pingErr: errDependency}}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := s.newTestServer(tt.store, tt.sessions, passwordsStub{}) + server := NewServer( + s.logger, tt.store, tt.sessions, passwordsStub{}, tt.objects, time.Hour, 24*time.Hour, + time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, + ) response := serveRequest(server, http.MethodGet, "/health/ready", "") if response.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) @@ -160,6 +220,18 @@ func (s *MessengerSuite) TestAuthenticationChallenges() { } } +func (s *MessengerSuite) TestAttachmentContentAuthenticatesBeforeVariantValidation() { + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) + response := serveRequest( + server, + http.MethodGet, + "/api/v1/attachments/00000000-0000-0000-0000-000000000001/content?variant=invalid", + "", + ) + s.Equal(http.StatusUnauthorized, response.Code) + s.Equal(`Bearer realm="messenger"`, response.Header().Get("WWW-Authenticate")) +} + func (s *MessengerSuite) TestSessionCreationRejectsChunkedBody() { t := s.T() server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) @@ -242,8 +314,135 @@ func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDiffe } } +func (s *MessengerSuite) TestImageValidation() { + data := testPNG(s.T(), 2, 2) + tests := []struct { + name string + contentType string + data []byte + maxBytes int64 + maxPixels int64 + wantStatus int + }{ + {name: "valid", contentType: "image/png", data: data, maxBytes: 1024, maxPixels: 4}, + {name: "spoofed MIME", contentType: "image/jpeg", data: data, maxBytes: 1024, maxPixels: 4, wantStatus: http.StatusUnsupportedMediaType}, + {name: "too many pixels", contentType: "image/png", data: data, maxBytes: 1024, maxPixels: 3, wantStatus: http.StatusRequestEntityTooLarge}, + {name: "too many bytes", contentType: "image/png", data: data, maxBytes: int64(len(data) - 1), maxPixels: 4, wantStatus: http.StatusRequestEntityTooLarge}, + {name: "damaged", contentType: "image/png", data: data[:16], maxBytes: 1024, maxPixels: 4, wantStatus: http.StatusUnsupportedMediaType}, + } + for _, tt := range tests { + s.Run(tt.name, func() { + request := httptest.NewRequest(http.MethodPost, "/upload", bytes.NewReader(tt.data)) + request.Header.Set("Content-Type", tt.contentType) + response := httptest.NewRecorder() + actual, _, apiErr := readImage( + response, request, tt.maxBytes, tt.maxPixels, semaphore.NewWeighted(384*1024*1024), + ) + if tt.wantStatus == 0 { + s.Require().Nil(apiErr) + s.Equal(tt.data, actual) + return + } + s.Require().NotNil(apiErr) + s.Equal(tt.wantStatus, apiErr.status) + }) + } +} + +func (s *MessengerSuite) TestImageValidationLimitsConcurrentDecodeMemory() { + data := testPNG(s.T(), 2, 2) + request := httptest.NewRequest(http.MethodPost, "/upload", bytes.NewReader(data)) + request.Header.Set("Content-Type", "image/png") + response := httptest.NewRecorder() + _, _, apiErr := readImage(response, request, 1024, 4, semaphore.NewWeighted(1)) + s.Require().NotNil(apiErr) + s.Equal(http.StatusTooManyRequests, apiErr.status) + s.Equal("1", response.Header().Get("Retry-After")) +} + +func (s *MessengerSuite) TestAttachmentFilenameValidation() { + for _, filename := range []string{"", " ", "../photo.png", "dir\\photo.png", "photo\x00.png", "photo\n.png"} { + _, valid := attachmentFilename(map[string][]string{"filename": {filename}}) + s.False(valid, filename) + } + filename, valid := attachmentFilename(map[string][]string{"filename": {"фото.png"}}) + s.True(valid) + s.Equal("фото.png", filename) +} + +func (s *MessengerSuite) TestUploadCompensatesObjectWhenMetadataWriteFails() { + var putKey, deletedKey string + store := messengerStoreStub{ + userByID: model.User{ID: "00000000-0000-0000-0000-000000000001"}, + attachmentErr: errDependency, + } + objects := objectStoreStub{putKey: &putKey, deletedKey: &deletedKey} + server := NewServer( + s.logger, store, sessionStub{userID: store.userByID.ID}, passwordsStub{}, objects, + time.Hour, 24*time.Hour, time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, + ) + data := testPNG(s.T(), 2, 2) + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/chats/00000000-0000-0000-0000-000000000002/attachments?filename=photo.png", + bytes.NewReader(data), + ) + request.Header.Set("Authorization", "Bearer valid-token") + request.Header.Set("Content-Type", "image/png") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + s.Equal(http.StatusServiceUnavailable, response.Code) + s.NotEmpty(putKey) + s.Equal(putKey, deletedKey) +} + +func (s *MessengerSuite) TestUploadKeepsObjectWhenMetadataCommitSucceeded() { + var deletedKey string + stored := model.Attachment{ + ID: "00000000-0000-0000-0000-000000000003", + ChatID: "00000000-0000-0000-0000-000000000002", + OwnerID: "00000000-0000-0000-0000-000000000001", + Filename: "photo.png", ContentType: "image/png", SizeBytes: 1, SHA256: strings.Repeat("0", 64), + Status: "ready", Variants: []model.Variant{}, CreatedAt: time.Now(), UpdatedAt: time.Now(), + } + store := messengerStoreStub{ + userByID: model.User{ID: stored.OwnerID}, attachmentErr: errDependency, + storedAttachment: stored, storedAttachmentExists: true, + } + server := NewServer( + s.logger, store, sessionStub{userID: stored.OwnerID}, passwordsStub{}, objectStoreStub{deletedKey: &deletedKey}, + time.Hour, 24*time.Hour, time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, + ) + data := testPNG(s.T(), 2, 2) + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/chats/00000000-0000-0000-0000-000000000002/attachments?filename=photo.png", + bytes.NewReader(data), + ) + request.Header.Set("Authorization", "Bearer valid-token") + request.Header.Set("Content-Type", "image/png") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + s.Equal(http.StatusCreated, response.Code) + s.Empty(deletedKey) +} + +func testPNG(t *testing.T, width, height int) []byte { + t.Helper() + var data bytes.Buffer + imageData := image.NewRGBA(image.Rect(0, 0, width, height)) + imageData.Set(0, 0, color.White) + if err := png.Encode(&data, imageData); err != nil { + t.Fatalf("encode PNG: %v", err) + } + return data.Bytes() +} + func (s *MessengerSuite) newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { - return NewServer(s.logger, messages, sessions, passwords, time.Hour, 24*time.Hour, time.Second, "test-instance", "8081") + return NewServer( + s.logger, messages, sessions, passwords, objectStoreStub{}, time.Hour, 24*time.Hour, + time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, + ) } func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { diff --git a/internal/model/model.go b/internal/model/model.go index 57a247e8..1a73c6b7 100644 --- a/internal/model/model.go +++ b/internal/model/model.go @@ -27,11 +27,37 @@ type Chat struct { } 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"` + 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 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"` + ObjectKey string `json:"-"` +} + +type Variant struct { + Name string `json:"name"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + Width int `json:"width"` + Height int `json:"height"` } type Position struct { @@ -54,11 +80,27 @@ type chatJSON struct { } type messageJSON struct { - ID string `json:"id"` - ChatID string `json:"chat_id"` - SenderID string `json:"sender_id"` - Text string `json:"text"` - CreatedAt string `json:"created_at"` + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` + AttachmentIDs []string `json:"attachment_ids"` +} + +type attachmentJSON 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 string `json:"created_at"` + UpdatedAt string `json:"updated_at"` } func (u User) MarshalJSON() ([]byte, error) { @@ -70,7 +112,22 @@ func (c Chat) MarshalJSON() ([]byte, error) { } func (m Message) MarshalJSON() ([]byte, error) { - return json.Marshal(messageJSON{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt)}) + attachments := m.AttachmentIDs + if attachments == nil { + attachments = []string{} + } + return json.Marshal(messageJSON{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt), attachments}) +} + +func (a Attachment) MarshalJSON() ([]byte, error) { + variants := a.Variants + if variants == nil { + variants = []Variant{} + } + return json.Marshal(attachmentJSON{ + a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, + a.Status, variants, a.ErrorCode, formatTime(a.CreatedAt), formatTime(a.UpdatedAt), + }) } func FormatTime(value time.Time) string { diff --git a/internal/objectstore/store.go b/internal/objectstore/store.go new file mode 100644 index 00000000..6cf73bf3 --- /dev/null +++ b/internal/objectstore/store.go @@ -0,0 +1,180 @@ +package objectstore + +import ( + "bytes" + "context" + "errors" + "fmt" + "io" + "net/url" + "strings" + "time" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +var ErrNotFound = errors.New("object not found") + +type Config struct { + Endpoint string + Region string + Bucket string + AccessKey string + SecretKey string + UseTLS bool + Timeout time.Duration +} + +type Object struct { + Key string + Size int64 + LastModified time.Time +} + +type Store struct { + client *minio.Client + bucket string + timeout time.Duration +} + +func New(config Config) (*Store, error) { + endpoint, err := endpointHost(config.Endpoint, config.UseTLS) + if err != nil { + return nil, err + } + if strings.TrimSpace(config.Bucket) == "" || config.Timeout <= 0 { + return nil, errors.New("invalid object store configuration") + } + client, err := minio.New(endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(config.AccessKey, config.SecretKey, ""), + Secure: config.UseTLS, + Region: config.Region, + }) + if err != nil { + return nil, fmt.Errorf("create S3 client: %w", err) + } + return &Store{client: client, bucket: config.Bucket, timeout: config.Timeout}, nil +} + +func endpointHost(value string, useTLS bool) (string, error) { + value = strings.TrimSpace(value) + if !strings.Contains(value, "://") { + if value == "" { + return "", errors.New("S3 endpoint is required") + } + return value, nil + } + parsed, err := url.Parse(value) + if err != nil || parsed.Host == "" || parsed.Path != "" && parsed.Path != "/" { + return "", errors.New("invalid S3 endpoint") + } + if (parsed.Scheme == "https") != useTLS || parsed.Scheme != "http" && parsed.Scheme != "https" { + return "", errors.New("S3 endpoint scheme conflicts with S3_USE_TLS") + } + return parsed.Host, nil +} + +func (s *Store) Ping(ctx context.Context) error { + ctx, cancel := context.WithTimeout(ctx, s.timeout) + defer cancel() + exists, err := s.client.BucketExists(ctx, s.bucket) + if err != nil { + return fmt.Errorf("check S3 bucket: %w", err) + } + if !exists { + return errors.New("S3 bucket does not exist") + } + return nil +} + +func (s *Store) Put(ctx context.Context, key, contentType string, data []byte) error { + ctx, cancel := context.WithTimeout(ctx, s.timeout) + defer cancel() + _, err := s.client.PutObject( + ctx, s.bucket, key, bytes.NewReader(data), int64(len(data)), minio.PutObjectOptions{ContentType: contentType}, + ) + if err != nil { + return fmt.Errorf("put S3 object: %w", err) + } + return nil +} + +func (s *Store) Get(ctx context.Context, key string) (io.ReadCloser, error) { + ctx, cancel := context.WithTimeout(ctx, s.timeout) + object, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{}) + if err != nil { + cancel() + return nil, objectError("get S3 object", err) + } + if _, err := object.Stat(); err != nil { + cancel() + _ = object.Close() + return nil, objectError("stat S3 object", err) + } + return &timeoutReader{ReadCloser: object, cancel: cancel}, nil +} + +func (s *Store) Stat(ctx context.Context, key string) (Object, error) { + ctx, cancel := context.WithTimeout(ctx, s.timeout) + defer cancel() + info, err := s.client.StatObject(ctx, s.bucket, key, minio.StatObjectOptions{}) + if err != nil { + return Object{}, objectError("stat S3 object", err) + } + return Object{Key: info.Key, Size: info.Size, LastModified: info.LastModified}, nil +} + +func (s *Store) Delete(ctx context.Context, key string) error { + ctx, cancel := context.WithTimeout(ctx, s.timeout) + defer cancel() + if err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{}); err != nil { + return objectError("delete S3 object", err) + } + return nil +} + +func (s *Store) List(ctx context.Context, prefix, after string, limit int) ([]Object, string, error) { + if limit < 1 || limit > 1000 { + return nil, "", errors.New("object list limit must be between 1 and 1000") + } + ctx, cancel := context.WithTimeout(ctx, s.timeout) + defer cancel() + objects := make([]Object, 0, limit+1) + options := minio.ListObjectsOptions{Prefix: prefix, Recursive: true, StartAfter: after, MaxKeys: limit + 1} + for info := range s.client.ListObjects(ctx, s.bucket, options) { + if info.Err != nil { + return nil, "", fmt.Errorf("list S3 objects: %w", info.Err) + } + objects = append(objects, Object{Key: info.Key, Size: info.Size, LastModified: info.LastModified}) + if len(objects) == limit+1 { + cancel() + break + } + } + var next string + if len(objects) > limit { + objects = objects[:limit] + next = objects[len(objects)-1].Key + } + return objects, next, nil +} + +type timeoutReader struct { + io.ReadCloser + cancel context.CancelFunc +} + +func (r *timeoutReader) Close() error { + err := r.ReadCloser.Close() + r.cancel() + return err +} + +func objectError(action string, err error) error { + response := minio.ToErrorResponse(err) + if response.Code == "NoSuchKey" || response.Code == "NoSuchObject" { + return ErrNotFound + } + return fmt.Errorf("%s: %w", action, err) +} diff --git a/internal/postgres/attachments.go b/internal/postgres/attachments.go new file mode 100644 index 00000000..59a73eec --- /dev/null +++ b/internal/postgres/attachments.go @@ -0,0 +1,155 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +func (s *Store) CreateAttachment(ctx context.Context, attachment model.Attachment) (model.Attachment, error) { + const query = ` + INSERT INTO attachments ( + id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key + ) + SELECT $1, $2, $3, $4, $5, $6, $7, $8 + WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3 + ) + RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + object_key, created_at, updated_at` + + err := s.pool.QueryRow( + ctx, query, attachment.ID, attachment.ChatID, attachment.OwnerID, attachment.Filename, + attachment.ContentType, attachment.SizeBytes, attachment.SHA256, attachment.ObjectKey, + ).Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.CreatedAt, &attachment.UpdatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Attachment{}, ErrNotFound + } + if err != nil { + return model.Attachment{}, fmt.Errorf("create attachment: %w", err) + } + return readyAttachment(attachment), nil +} + +func (s *Store) AttachmentForUser(ctx context.Context, attachmentID, userID string) (model.Attachment, error) { + const query = ` + SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, + a.sha256, a.object_key, a.created_at, a.updated_at + FROM attachments a + JOIN chat_members member ON member.chat_id = a.chat_id AND member.user_id = $2 + WHERE a.id = $1` + + var attachment model.Attachment + err := s.pool.QueryRow(ctx, query, attachmentID, userID).Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.CreatedAt, &attachment.UpdatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Attachment{}, ErrNotFound + } + if err != nil { + return model.Attachment{}, fmt.Errorf("get attachment for user: %w", err) + } + return readyAttachment(attachment), nil +} + +func (s *Store) AttachmentByStorage(ctx context.Context, attachmentID, objectKey string) (model.Attachment, error) { + const query = ` + SELECT id, chat_id, owner_id, filename, content_type, size_bytes, + sha256, object_key, created_at, updated_at + FROM attachments + WHERE id = $1 AND object_key = $2` + + var attachment model.Attachment + err := s.pool.QueryRow(ctx, query, attachmentID, objectKey).Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.CreatedAt, &attachment.UpdatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Attachment{}, ErrNotFound + } + if err != nil { + return model.Attachment{}, fmt.Errorf("get attachment by storage: %w", err) + } + return readyAttachment(attachment), nil +} + +func (s *Store) ListAttachments(ctx context.Context, afterObjectKey string, limit int) ([]model.Attachment, string, error) { + if limit < 1 || limit > 1000 { + return nil, "", fmt.Errorf("attachment list limit must be between 1 and 1000") + } + const query = ` + SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + object_key, created_at, updated_at + FROM attachments + WHERE object_key > $1 + ORDER BY object_key + LIMIT $2` + rows, err := s.pool.Query(ctx, query, afterObjectKey, limit+1) + if err != nil { + return nil, "", fmt.Errorf("list attachments: %w", err) + } + defer rows.Close() + + attachments, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Attachment](func(row pgx.CollectableRow) (model.Attachment, error) { + var attachment model.Attachment + err := row.Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.CreatedAt, &attachment.UpdatedAt, + ) + return readyAttachment(attachment), err + })) + if err != nil { + return nil, "", fmt.Errorf("scan attachments: %w", err) + } + var next string + if len(attachments) > limit { + attachments = attachments[:limit] + next = attachments[len(attachments)-1].ObjectKey + } + return attachments, next, nil +} + +func (s *Store) AttachmentReferenced(ctx context.Context, attachmentID string) (bool, error) { + const query = `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1)` + var referenced bool + if err := s.pool.QueryRow(ctx, query, attachmentID).Scan(&referenced); err != nil { + return false, fmt.Errorf("check attachment references: %w", err) + } + return referenced, nil +} + +func (s *Store) DeleteAttachmentIfUnreferencedBefore( + ctx context.Context, + attachmentID string, + createdBefore time.Time, +) (bool, error) { + const query = ` + DELETE FROM attachments a + WHERE a.id = $1 + AND a.created_at <= $2 + AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id)` + result, err := s.pool.Exec(ctx, query, attachmentID, createdBefore) + if err != nil { + return false, fmt.Errorf("delete old unreferenced attachment: %w", err) + } + return result.RowsAffected() == 1, nil +} + +func readyAttachment(attachment model.Attachment) model.Attachment { + attachment.Status = "ready" + attachment.Variants = []model.Variant{} + return attachment +} diff --git a/internal/postgres/idempotency.go b/internal/postgres/idempotency.go index a95ab99a..5daea350 100644 --- a/internal/postgres/idempotency.go +++ b/internal/postgres/idempotency.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "crypto/sha256" + "encoding/json" "errors" "fmt" "time" @@ -21,9 +22,13 @@ func (s *Store) CreateMessage( chatID string, senderID string, text string, + attachmentIDs []string, idempotencyKey string, idempotencyTTL time.Duration, ) (model.Message, bool, error) { + if attachmentIDs == nil { + attachmentIDs = []string{} + } var ( tx pgx.Tx err error @@ -46,13 +51,23 @@ func (s *Store) CreateMessage( if !visible { return model.Message{}, false, ErrNotFound } + validAttachments, err := attachmentsBelongToChat(ctx, tx, chatID, attachmentIDs) + if err != nil { + return model.Message{}, false, err + } + if !validAttachments { + return model.Message{}, false, ErrNotFound + } if err = deleteExpiredIdempotencyRecords(ctx, tx, expiredIdempotencyCleanupBatch); err != nil { return model.Message{}, false, err } - requestHash = sha256.Sum256([]byte(text)) + requestHash, err = messageRequestHash(text, attachmentIDs) + if err != nil { + return model.Message{}, false, err + } message, replay, err = createIdempotentMessage( - ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL, + ctx, tx, chatID, senderID, text, attachmentIDs, idempotencyKey, requestHash[:], idempotencyTTL, ) if err != nil { return model.Message{}, false, err @@ -63,6 +78,35 @@ func (s *Store) CreateMessage( return message, replay, nil } +func messageRequestHash(text string, attachmentIDs []string) ([sha256.Size]byte, error) { + if attachmentIDs == nil { + attachmentIDs = []string{} + } + payload, err := json.Marshal(struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` + }{text, attachmentIDs}) + if err != nil { + return [sha256.Size]byte{}, fmt.Errorf("marshal message request: %w", err) + } + return sha256.Sum256(payload), nil +} + +func attachmentsBelongToChat(ctx context.Context, tx pgx.Tx, chatID string, attachmentIDs []string) (bool, error) { + if len(attachmentIDs) == 0 { + return true, nil + } + const query = ` + SELECT count(*) + FROM attachments + WHERE chat_id = $1 AND id::text = ANY($2)` + var count int + if err := tx.QueryRow(ctx, query, chatID, attachmentIDs).Scan(&count); err != nil { + return false, fmt.Errorf("validate message attachments: %w", err) + } + return count == len(attachmentIDs), nil +} + func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) { const query = ` SELECT EXISTS ( @@ -84,6 +128,7 @@ func createIdempotentMessage( chatID string, senderID string, text string, + attachmentIDs []string, idempotencyKey string, requestHash []byte, idempotencyTTL time.Duration, @@ -126,7 +171,7 @@ func createIdempotentMessage( continue } - message, err = insertMessage(ctx, tx, messageID, chatID, senderID, text) + message, err = insertMessage(ctx, tx, messageID, chatID, senderID, text, attachmentIDs) return message, false, err } } @@ -235,6 +280,7 @@ func insertMessage( chatID string, senderID string, text string, + attachmentIDs []string, ) (model.Message, error) { const query = ` INSERT INTO messages (id, chat_id, sender_id, text) @@ -255,14 +301,37 @@ func insertMessage( if err != nil { return model.Message{}, fmt.Errorf("insert message: %w", err) } + if err := insertMessageAttachments(ctx, tx, messageID, chatID, attachmentIDs); err != nil { + return model.Message{}, err + } + message.AttachmentIDs = make([]string, len(attachmentIDs)) + copy(message.AttachmentIDs, attachmentIDs) return message, nil } +func insertMessageAttachments(ctx context.Context, tx pgx.Tx, messageID, chatID string, attachmentIDs []string) error { + const query = ` + INSERT INTO message_attachments (message_id, chat_id, attachment_id, position) + VALUES ($1, $2, $3, $4)` + for position, attachmentID := range attachmentIDs { + if _, err := tx.Exec(ctx, query, messageID, chatID, attachmentID, position); err != nil { + return fmt.Errorf("insert message attachment: %w", err) + } + } + return nil +} + func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) { const query = ` - SELECT id, chat_id, sender_id, text, created_at - FROM messages - WHERE id = $1` + SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, + ARRAY( + SELECT ma.attachment_id::text + FROM message_attachments ma + WHERE ma.message_id = m.id + ORDER BY ma.position + ) + FROM messages m + WHERE m.id = $1` var ( message model.Message @@ -274,6 +343,7 @@ func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Messag &message.SenderID, &message.Text, &message.CreatedAt, + &message.AttachmentIDs, ) if errors.Is(err, pgx.ErrNoRows) { return model.Message{}, fmt.Errorf("idempotency result message not found") diff --git a/internal/postgres/store.go b/internal/postgres/store.go index f8b3fccd..c0c07aac 100644 --- a/internal/postgres/store.go +++ b/internal/postgres/store.go @@ -344,11 +344,17 @@ func (s *Store) ListMessages( } const query = ` - SELECT id, chat_id, sender_id, text, created_at - FROM messages - WHERE chat_id = $1 - AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3::uuid)) - ORDER BY created_at, id + SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, + ARRAY( + SELECT ma.attachment_id::text + FROM message_attachments ma + WHERE ma.message_id = m.id + ORDER BY ma.position + ) + FROM messages m + WHERE m.chat_id = $1 + AND ($2::timestamptz IS NULL OR (m.created_at, m.id) > ($2, $3::uuid)) + ORDER BY m.created_at, m.id LIMIT $4` var afterTime any @@ -372,6 +378,7 @@ func (s *Store) ListMessages( &message.SenderID, &message.Text, &message.CreatedAt, + &message.AttachmentIDs, ) return message, err })) diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index 461c5394..08a9dbc8 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -100,18 +100,16 @@ func (s *PostgresSuite) TestMessageIdempotencyReplayAndConflict() { owner, chatID := createOwnerAndChat(t, store) key := uuid.NewString() - first, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour) + first, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", nil, key, 24*time.Hour) if err != nil || replay { t.Fatalf("first CreateMessage() = (%v, %t, %v)", first, replay, err) } - second, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour) + second, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", []string{}, key, 24*time.Hour) if err != nil || !replay { t.Fatalf("replay CreateMessage() = (%v, %t, %v)", second, replay, err) } - if first != second { - t.Fatalf("replay message = %v, want %v", second, first) - } - if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "different body", key, 24*time.Hour); !errors.Is(err, postgres.ErrIdempotencyConflict) { + s.Equal(first, second) + if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "different body", nil, key, 24*time.Hour); !errors.Is(err, postgres.ErrIdempotencyConflict) { t.Fatalf("conflicting CreateMessage() error = %v, want ErrIdempotencyConflict", err) } if count := messageCount(t, pool, chatID); count != 1 { @@ -119,6 +117,62 @@ func (s *PostgresSuite) TestMessageIdempotencyReplayAndConflict() { } } +func (s *PostgresSuite) TestAttachmentAccessAndMessageLinking() { + owner, chatID := createOwnerAndChat(s.T(), s.store) + outsider, err := s.store.CreateUser(context.Background(), uniqueUsername(), "Outsider", "password-hash") + s.Require().NoError(err) + attachment := model.Attachment{ + ID: uuid.NewString(), ChatID: chatID, OwnerID: owner.ID, Filename: "photo.png", + ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("a", 64), + ObjectKey: "attachments/" + uuid.NewString() + "/original", + } + created, err := s.store.CreateAttachment(context.Background(), attachment) + s.Require().NoError(err) + s.Equal("ready", created.Status) + s.Empty(created.Variants) + s.Nil(created.ErrorCode) + + visible, err := s.store.AttachmentForUser(context.Background(), created.ID, owner.ID) + s.Require().NoError(err) + s.Equal(created, visible) + _, err = s.store.AttachmentForUser(context.Background(), created.ID, outsider.ID) + s.ErrorIs(err, postgres.ErrNotFound) + + message, replay, err := s.store.CreateMessage( + context.Background(), chatID, owner.ID, "", []string{created.ID}, uuid.NewString(), 24*time.Hour, + ) + s.Require().NoError(err) + s.False(replay) + s.Equal([]string{created.ID}, message.AttachmentIDs) + + messages, _, err := s.store.ListMessages(context.Background(), chatID, owner.ID, nil, 10) + s.Require().NoError(err) + s.Len(messages, 1) + s.Equal([]string{created.ID}, messages[0].AttachmentIDs) + referenced, err := s.store.AttachmentReferenced(context.Background(), created.ID) + s.Require().NoError(err) + s.True(referenced) + deleted, err := s.store.DeleteAttachmentIfUnreferencedBefore(context.Background(), created.ID, time.Now().Add(time.Hour)) + s.Require().NoError(err) + s.False(deleted) +} + +func (s *PostgresSuite) TestMessageRejectsAttachmentFromAnotherChat() { + owner, firstChatID := createOwnerAndChat(s.T(), s.store) + secondChat, err := s.store.CreateChat(context.Background(), "Second", []string{owner.ID}, owner.ID) + s.Require().NoError(err) + attachment, err := s.store.CreateAttachment(context.Background(), model.Attachment{ + ID: uuid.NewString(), ChatID: firstChatID, OwnerID: owner.ID, Filename: "photo.png", + ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("b", 64), + ObjectKey: "attachments/" + uuid.NewString() + "/original", + }) + s.Require().NoError(err) + _, _, err = s.store.CreateMessage( + context.Background(), secondChat.ID, owner.ID, "wrong chat", []string{attachment.ID}, uuid.NewString(), 24*time.Hour, + ) + s.ErrorIs(err, postgres.ErrNotFound) +} + func (s *PostgresSuite) TestConcurrentMessageIdempotency() { t := s.T() pool := s.pool @@ -139,7 +193,7 @@ func (s *PostgresSuite) TestConcurrentMessageIdempotency() { go func() { defer group.Done() message, replay, err := stores[worker%len(stores)].CreateMessage( - context.Background(), chatID, owner.ID, "concurrent body", key, 24*time.Hour, + context.Background(), chatID, owner.ID, "concurrent body", nil, key, 24*time.Hour, ) results <- result{message: message, replay: replay, err: err} }() @@ -186,13 +240,13 @@ func (s *PostgresSuite) TestMessageIdempotencyScopeAndExpiry() { } key := uuid.NewString() - if _, _, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "owner", key, 24*time.Hour); err != nil { + if _, _, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "owner", nil, key, 24*time.Hour); err != nil { t.Fatalf("owner CreateMessage() error = %v", err) } - if _, _, err := store.CreateMessage(context.Background(), chat.ID, second.ID, "second", key, 24*time.Hour); err != nil { + if _, _, err := store.CreateMessage(context.Background(), chat.ID, second.ID, "second", nil, key, 24*time.Hour); err != nil { t.Fatalf("second user CreateMessage() error = %v", err) } - if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "other chat", key, 24*time.Hour); err != nil { + if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "other chat", nil, key, 24*time.Hour); err != nil { t.Fatalf("other chat CreateMessage() error = %v", err) } if _, err := pool.Exec(context.Background(), ` @@ -202,7 +256,7 @@ func (s *PostgresSuite) TestMessageIdempotencyScopeAndExpiry() { WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chat.ID, key); err != nil { t.Fatalf("expire idempotency key: %v", err) } - message, replay, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "after expiry", key, 24*time.Hour) + message, replay, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "after expiry", nil, key, 24*time.Hour) if err != nil || replay || message.Text != "after expiry" { t.Fatalf("expired CreateMessage() = (%v, %t, %v)", message, replay, err) } @@ -212,7 +266,7 @@ func (s *PostgresSuite) TestExpiredIdempotencyRecordsAreCleanedOnNewMessages() { t := s.T() owner, chatID := createOwnerAndChat(t, s.store) expiredKey := uuid.NewString() - if _, _, err := s.store.CreateMessage(context.Background(), chatID, owner.ID, "expired", expiredKey, 24*time.Hour); err != nil { + if _, _, err := s.store.CreateMessage(context.Background(), chatID, owner.ID, "expired", nil, expiredKey, 24*time.Hour); err != nil { t.Fatalf("create expired message: %v", err) } if _, err := s.pool.Exec(context.Background(), ` @@ -223,7 +277,7 @@ func (s *PostgresSuite) TestExpiredIdempotencyRecordsAreCleanedOnNewMessages() { t.Fatalf("expire idempotency key: %v", err) } if _, _, err := s.store.CreateMessage( - context.Background(), chatID, owner.ID, "new message", uuid.NewString(), 24*time.Hour, + context.Background(), chatID, owner.ID, "new message", nil, uuid.NewString(), 24*time.Hour, ); err != nil { t.Fatalf("create new message: %v", err) } diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go new file mode 100644 index 00000000..34c74440 --- /dev/null +++ b/internal/reconcile/reconcile.go @@ -0,0 +1,236 @@ +package reconcile + +import ( + "context" + "fmt" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" +) + +type MetadataStore interface { + ListAttachments(context.Context, string, int) ([]model.Attachment, string, error) + AttachmentReferenced(context.Context, string) (bool, error) + DeleteAttachmentIfUnreferencedBefore(context.Context, string, time.Time) (bool, error) +} + +type ObjectStore interface { + List(context.Context, string, string, int) ([]objectstore.Object, string, error) + Delete(context.Context, string) error +} + +type Config struct { + Prefix string + PageSize int + GraceTime time.Duration + Apply bool + Now func() time.Time +} + +type Report struct { + MetadataScanned int `json:"metadata_scanned"` + ObjectsScanned int `json:"objects_scanned"` + Consistent int `json:"consistent"` + FreshOrphanObjects int `json:"fresh_orphan_objects"` + OldOrphanObjects int `json:"old_orphan_objects"` + DeletedOrphanObjects int `json:"deleted_orphan_objects"` + FreshMissingObjects int `json:"fresh_missing_objects"` + ReferencedMissingObjects int `json:"referenced_missing_objects"` + OldUnreferencedMetadata int `json:"old_unreferenced_metadata"` + DeletedUnreferencedRows int `json:"deleted_unreferenced_rows"` +} + +type Reconciler struct { + metadata MetadataStore + objects ObjectStore + config Config +} + +func New(metadata MetadataStore, objects ObjectStore, config Config) (*Reconciler, error) { + if config.PageSize < 1 || config.PageSize > 1000 { + return nil, fmt.Errorf("page size must be between 1 and 1000") + } + if config.GraceTime < 0 { + return nil, fmt.Errorf("grace time must not be negative") + } + if config.Now == nil { + config.Now = time.Now + } + return &Reconciler{metadata: metadata, objects: objects, config: config}, nil +} + +func (r *Reconciler) Run(ctx context.Context) (Report, error) { + metadata, err := newMetadataIterator(ctx, r.metadata, r.config.PageSize) + if err != nil { + return Report{}, err + } + objects, err := newObjectIterator(ctx, r.objects, r.config.Prefix, r.config.PageSize) + if err != nil { + return Report{}, err + } + + cutoff := r.config.Now().Add(-r.config.GraceTime) + var report Report + for metadata.current != nil || objects.current != nil { + switch { + case metadata.current == nil || objects.current != nil && objects.current.Key < metadata.current.ObjectKey: + if err := r.handleOrphanObject(ctx, *objects.current, cutoff, &report); err != nil { + return report, err + } + if err := objects.advance(ctx); err != nil { + return report, err + } + case objects.current == nil || metadata.current.ObjectKey < objects.current.Key: + if err := r.handleMissingObject(ctx, *metadata.current, cutoff, &report); err != nil { + return report, err + } + if err := metadata.advance(ctx); err != nil { + return report, err + } + default: + report.MetadataScanned++ + report.ObjectsScanned++ + report.Consistent++ + if err := metadata.advance(ctx); err != nil { + return report, err + } + if err := objects.advance(ctx); err != nil { + return report, err + } + } + } + return report, nil +} + +func (r *Reconciler) handleOrphanObject(ctx context.Context, object objectstore.Object, cutoff time.Time, report *Report) error { + report.ObjectsScanned++ + if object.LastModified.After(cutoff) { + report.FreshOrphanObjects++ + return nil + } + report.OldOrphanObjects++ + if !r.config.Apply { + return nil + } + if err := r.objects.Delete(ctx, object.Key); err != nil { + return fmt.Errorf("delete orphan object %q: %w", object.Key, err) + } + report.DeletedOrphanObjects++ + return nil +} + +func (r *Reconciler) handleMissingObject(ctx context.Context, metadata model.Attachment, cutoff time.Time, report *Report) error { + report.MetadataScanned++ + if metadata.CreatedAt.After(cutoff) { + report.FreshMissingObjects++ + return nil + } + referenced, err := r.metadata.AttachmentReferenced(ctx, metadata.ID) + if err != nil { + return fmt.Errorf("check attachment metadata %q: %w", metadata.ID, err) + } + if referenced { + report.ReferencedMissingObjects++ + return nil + } + report.OldUnreferencedMetadata++ + if !r.config.Apply { + return nil + } + deleted, err := r.metadata.DeleteAttachmentIfUnreferencedBefore(ctx, metadata.ID, cutoff) + if err != nil { + return fmt.Errorf("delete attachment metadata %q: %w", metadata.ID, err) + } + if deleted { + report.DeletedUnreferencedRows++ + } + return nil +} + +type metadataIterator struct { + store MetadataStore + pageSize int + after string + page []model.Attachment + index int + current *model.Attachment + done bool +} + +func newMetadataIterator(ctx context.Context, store MetadataStore, pageSize int) (*metadataIterator, error) { + iterator := &metadataIterator{store: store, pageSize: pageSize} + if err := iterator.advance(ctx); err != nil { + return nil, err + } + return iterator, nil +} + +func (i *metadataIterator) advance(ctx context.Context) error { + for { + if i.index < len(i.page) { + i.current = &i.page[i.index] + i.index++ + return nil + } + if i.done { + i.current = nil + return nil + } + page, next, err := i.store.ListAttachments(ctx, i.after, i.pageSize) + if err != nil { + return fmt.Errorf("list attachment metadata: %w", err) + } + i.page = page + i.index = 0 + i.after = next + i.done = next == "" + if len(page) == 0 && !i.done { + return fmt.Errorf("metadata page is empty but has continuation") + } + } +} + +type objectIterator struct { + store ObjectStore + prefix string + pageSize int + after string + page []objectstore.Object + index int + current *objectstore.Object + done bool +} + +func newObjectIterator(ctx context.Context, store ObjectStore, prefix string, pageSize int) (*objectIterator, error) { + iterator := &objectIterator{store: store, prefix: prefix, pageSize: pageSize} + if err := iterator.advance(ctx); err != nil { + return nil, err + } + return iterator, nil +} + +func (i *objectIterator) advance(ctx context.Context) error { + for { + if i.index < len(i.page) { + i.current = &i.page[i.index] + i.index++ + return nil + } + if i.done { + i.current = nil + return nil + } + page, next, err := i.store.List(ctx, i.prefix, i.after, i.pageSize) + if err != nil { + return fmt.Errorf("list objects: %w", err) + } + i.page = page + i.index = 0 + i.after = next + i.done = next == "" + if len(page) == 0 && !i.done { + return fmt.Errorf("object page is empty but has continuation") + } + } +} diff --git a/migrations/0003_attachments.sql b/migrations/0003_attachments.sql new file mode 100644 index 00000000..91d1cc92 --- /dev/null +++ b/migrations/0003_attachments.sql @@ -0,0 +1,47 @@ +ALTER TABLE messages + DROP CONSTRAINT messages_text_length, + DROP CONSTRAINT messages_text_not_blank; + +ALTER TABLE messages + ADD CONSTRAINT messages_text_length CHECK (char_length(text) BETWEEN 0 AND 4000), + ADD CONSTRAINT messages_id_chat_unique UNIQUE (id, chat_id); + +CREATE TABLE attachments ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL, + owner_id UUID NOT NULL, + filename TEXT NOT NULL, + content_type TEXT NOT NULL, + size_bytes BIGINT NOT NULL, + sha256 TEXT NOT NULL, + object_key TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT attachments_id_chat_unique UNIQUE (id, chat_id), + CONSTRAINT attachments_object_key_unique UNIQUE (object_key), + CONSTRAINT attachments_owner_membership_fk FOREIGN KEY (chat_id, owner_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE CASCADE, + CONSTRAINT attachments_filename_length CHECK (char_length(filename) BETWEEN 1 AND 255), + CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')), + CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760), + CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'), + CONSTRAINT attachments_object_key_length CHECK (char_length(object_key) BETWEEN 1 AND 1024) +); + +CREATE INDEX attachments_chat_id_created_at_id_idx ON attachments (chat_id, created_at, id); + +CREATE TABLE message_attachments ( + message_id UUID NOT NULL, + chat_id UUID NOT NULL, + attachment_id UUID NOT NULL, + position SMALLINT NOT NULL, + CONSTRAINT message_attachments_pk PRIMARY KEY (message_id, attachment_id), + CONSTRAINT message_attachments_position_unique UNIQUE (message_id, position), + CONSTRAINT message_attachments_position_range CHECK (position BETWEEN 0 AND 9), + CONSTRAINT message_attachments_message_chat_fk FOREIGN KEY (message_id, chat_id) + REFERENCES messages (id, chat_id) ON DELETE CASCADE, + CONSTRAINT message_attachments_attachment_fk FOREIGN KEY (attachment_id, chat_id) + REFERENCES attachments (id, chat_id) ON DELETE RESTRICT +); + +CREATE INDEX message_attachments_attachment_id_idx ON message_attachments (attachment_id); -- 2.54.0 From b3d5d76302a79dd49909c76f8e1ff4d66ab5fada Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 19:55:52 +0300 Subject: [PATCH 03/15] test: verify attachment consistency and memory --- REPORT.md | 179 +++++++- cmd/lab4experiment/main.go | 654 +++++++++++++++++++++++++++ evidence/lab4-consistency.json | 69 +++ evidence/lab4-memory.json | 17 + evidence/lab4-verification.txt | 19 + internal/reconcile/reconcile_test.go | 129 ++++++ 6 files changed, 1046 insertions(+), 21 deletions(-) create mode 100644 cmd/lab4experiment/main.go create mode 100644 evidence/lab4-consistency.json create mode 100644 evidence/lab4-memory.json create mode 100644 evidence/lab4-verification.txt create mode 100644 internal/reconcile/reconcile_test.go diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..2cf0bced 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,174 @@ -# Отчёт — лабораторная 4 +# Отчёт — лабораторная работа № 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: Пластинин Денис, БВТ2303. +- Целевая оценка: 5. +- Выбранный трек: 2, согласованность PostgreSQL и S3. +- Ветка: `solution/bvt2303-plastinin`. +- Источники и инструменты: документация Go, PostgreSQL и MinIO; Codex использован при реализации. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуются Docker Engine с Compose V2, Git и свободные локальные порты 8080, 8081, 9090 и 3000. Для запуска Go-проверок вне контейнера нужен Go 1.26. Образы приложения и MinIO собираются из исходников внутри Docker. Версии Go, PostgreSQL, Valkey, Nginx, MinIO и остальных компонентов закреплены в Dockerfile и `compose.yaml`. -## Архитектура и решения +```sh +cp lab4.env.example .env +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --scale api=2 --wait --wait-timeout 180 +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +После запуска доступны: + +- API через Nginx: `http://localhost:8080`; +- Swagger UI: `http://localhost:8081`; +- Prometheus: `http://localhost:9090`; +- Grafana: `http://localhost:3000`, пользователь `admin`, пароль из `GRAFANA_ADMIN_PASSWORD`. + +Публичные и внутренние проверки: + +```sh +make check +make test BASE_URL=http://localhost:8080 +docker compose --profile tests run --rm --build tests +go test -race ./... +go vet ./... +``` + +Сверка PostgreSQL и S3 выполняется внутри запущенной API-реплики. Без `--apply` команда ничего не удаляет: + +```sh +docker compose exec -T api /app/messenger reconcile-attachments --grace-period=1h +docker compose exec -T api /app/messenger reconcile-attachments --apply --grace-period=1h +``` + +Эксперименты запускаются на чистом стенде: + +```sh +docker compose exec -T api /app/lab4experiment memory +docker compose exec -T api /app/lab4experiment consistency +``` + +Безопасная остановка сохраняет данные в Docker volumes: + +```sh +docker compose down +``` + +Полное удаление учебных данных выполняется только явно: + +```sh +docker compose down -v +``` + +## Архитектура + +```text +клиент + | + v +Nginx :8080 + | + +---- API replica 1 ----+ + | | + +---- API replica 2 ----+---- PostgreSQL: пользователи, чаты, + | сообщения, metadata + +---- Valkey: сессии + +---- MinIO: приватные байты изображений + +Prometheus <---- API /metrics, MinIO, Nginx, PostgreSQL, Valkey + | + +---- Grafana +``` + +Из лабораторной № 3 сохранены две и более API-реплики, Nginx, общие PostgreSQL и Valkey, Bearer-сессии, keyset pagination, идемпотентность сообщений, graceful shutdown, failover, метрики и управляемое развёртывание. В лабораторной № 4 добавлены приватное объектное хранилище, модель вложения, бинарная загрузка и скачивание, привязка вложений к сообщениям и сверка двух хранилищ. + +PostgreSQL остаётся источником истины для прав доступа и метаданных. Таблица `attachments` хранит владельца, чат, отображаемое имя, MIME, размер, SHA-256 и внутренний object key. Таблица `message_attachments` задаёт упорядоченную связь многие ко многим с сообщениями. Object key генерируется сервером и не зависит от имени файла. + +MinIO хранит только байты оригиналов. Bucket закрыт для анонимного доступа. Bootstrap повторяемо создаёт bucket, policy и отдельного пользователя приложения. API получает только действия list/get/put/delete в одном bucket. Root credentials используются bootstrap-контейнером и не передаются API. Web-консоль MinIO отключена и её порт не опубликован. + +## Загрузка и чтение вложения + +Клиент передаёт сырые байты PNG или JPEG. Сервер ограничивает HTTP body до 10 MiB до полного чтения, проверяет заявленный и фактический MIME, декодирует конфигурацию изображения, ограничивает число пикселей 40 миллионами и проверяет полную декодируемость. Filename содержит от 1 до 255 Unicode-символов и не может содержать разделители пути, NUL, управляющие символы или состоять только из пробелов. + +При успешной загрузке сервер генерирует UUID для вложения и отдельный случайный object key, считает SHA-256, записывает объект в MinIO и затем metadata в PostgreSQL. Ответ `201 ready` возвращается только после обеих операций. Если результат записи PostgreSQL неоднозначен, сервер повторно ищет строку по attachment ID и object key. Найденная строка означает успешный commit и приводит к `201`; подтверждённое отсутствие строки разрешает компенсирующее удаление object; ошибка повторной проверки оставляет object для последующей безопасной сверки reconciler. + +Метаданные и содержимое читаются только после проверки Bearer-сессии и членства пользователя в чате. Посторонний пользователь и неизвестный идентификатор дают одинаковый `404`. API отдаёт байты самостоятельно без redirect и возвращает сохранённый `Content-Type` и точный `Content-Length`. + +Сообщение принимает до десяти уникальных `attachment_ids`. В одной транзакции PostgreSQL проверяются членство отправителя и принадлежность каждого вложения нужному чату, создаются сообщение, связи и запись идемпотентности. Отсутствующее поле `attachment_ids` и пустой массив дают одинаковый семантический hash. Пустой текст допустим только при наличии вложения. + +## Согласованность PostgreSQL и S3 + +Операции PostgreSQL и S3 не входят в общую распределённую транзакцию. Возможны два вида расхождений: + +1. object существует в S3, но metadata отсутствует; +2. metadata существует, но object отсутствует. + +Команда `reconcile-attachments` проходит оба набора в порядке object key постранично, поэтому объём памяти ограничен размером двух страниц. По умолчанию включён dry-run. Grace period защищает свежие объекты и строки, которые могут относиться к ещё выполняющейся операции. + +В режиме `--apply` старый orphan в S3 удаляется. Старая строка с отсутствующим объектом удаляется только при отсутствии ссылки из `message_attachments`; проверка возраста и отсутствия ссылки повторяется атомарным `DELETE`. Используемая строка сохраняется и попадает в отчёт для ручного восстановления объекта. Повторный запуск после исправления не выполняет дополнительных удалений. + +## Ограничение памяти + +Размер тела ограничен `http.MaxBytesReader`, поэтому неизвестный `Content-Length` не позволяет читать бесконечный поток. Исходные байты и декодированное изображение находятся в памяти только во время синхронной загрузки. Перед полной декодировкой weighted semaphore резервирует для запроса сумму размера исходных байтов и восьми байт на пиксель. Общий бюджет одной реплики равен 384 MiB, а лимит её контейнера — 512 MiB. Максимально допустимое изображение требует не более 330 485 760 байт расчётного бюджета. Если свободного бюджета нет, API отвечает `429` с `Retry-After: 1`. + +Go-инструмент `cmd/lab4experiment` создаёт случайное JPEG-изображение и выполняет четыре волны по 12 одновременных загрузок. Передача каждой копии ограничена по скорости, чтобы нагрузка длилась дольше интервала scrape. Наблюдаемый пик heap и resident memory двух API-процессов читается из Prometheus с интервалом одна секунда. Это измерение локального стенда, а не универсальная оценка производительности S3. + +В эксперименте успешно завершились все 48 загрузок файла размером 3 759 914 байт. Четыре волны заняли 12,629 секунды. После трёх секунд стабилизации суммарный heap двух реплик вырос с 181 133 200 до наблюдаемого пика 202 374 848 байт, то есть на 21 241 648 байт. Суммарный RSS вырос с 241 922 048 до 381 063 168 байт, то есть на 139 141 120 байт. Наблюдаемый пик остался ниже общего контейнерного лимита двух реплик 1 GiB. + +## Наблюдаемость + +API экспортирует общие HTTP-метрики и отдельные показатели загрузок: + +- `messenger_attachment_uploads_total{result}`; +- `messenger_attachment_upload_duration_seconds`; +- `messenger_attachment_upload_bytes_total`. + +Prometheus обнаруживает все API-реплики через Docker DNS и отдельно собирает MinIO, Nginx, PostgreSQL и Valkey. Grafana показывает частоту и p95 загрузок, объём принятых байтов, число и ёмкость объектов MinIO, ошибки S3, доступность компонентов, RPS, классы HTTP-ответов и память Go. + +`/health/live` проверяет только процесс. `/health/ready` требует доступных PostgreSQL, Valkey и приватного bucket S3. Недоступность Grafana или Prometheus не останавливает API. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда или сценарий | Результат | Доказательство | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Контракт и OpenAPI | `make check`, `make validate` | offline check PASS; validate входит в CI | `evidence/lab4-verification.txt` | +| Unit и integration | `go test ./...`, race/tests profile в CI | unit PASS | `evidence/lab4-verification.txt` | +| Upload/download и ACL | `make test` | PASS | `evidence/lab4-verification.txt` | +| Межрепличный failover и restart | public resilience hooks | проверяются CI точного commit | `.gitea/workflows/ci.yml` | +| Приватный bucket и повторный bootstrap | anonymous HTTP check, два запуска bootstrap | PASS | `evidence/lab4-verification.txt` | +| 12 конкурентных загрузок и память | `lab4experiment memory` | 48/48 PASS, observed RSS peak 381 063 168 B | `evidence/lab4-memory.json` | +| Трек 2: dry-run/apply/repeat | `lab4experiment consistency` | PASS, повторный apply: 0 удалений | `evidence/lab4-consistency.json` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Эксперимент согласованности -## Эксперименты и отказы +Гипотеза: постраничная сверка с grace period может автоматически удалить старые безопасные расхождения, не удаляя свежие данные и metadata используемого вложения; второй apply будет идемпотентным. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Методика на чистом стенде: -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +1. создать согласованное вложение; +2. удалить S3 object у непривязанного вложения; +3. привязать другое вложение к сообщению и удалить его S3 object; +4. создать object без metadata; +5. выполнить apply с grace period один час и проверить сохранность свежих аномалий; +6. выполнить dry-run с нулевым grace period; +7. выполнить apply и проверить удаление orphan и непривязанной строки; +8. повторить apply и проверить отсутствие новых действий. -## Ограничения и следующие шаги +Фактическая стоимость обхода записывается как число просмотренных объектов и строк, размер страницы и wall time. Алгоритм выполняет линейный merge двух отсортированных потоков; дополнительные запросы проверки ссылок нужны только для metadata с отсутствующим объектом. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +При размере страницы 10 фактический запуск пересёк границу страницы и просмотрел 206 строк metadata и 205 objects. Apply с часовым grace period занял 58 миллисекунд и сохранил один свежий orphan и две свежие строки с отсутствующим object. При нулевом grace period dry-run за 65 миллисекунд обнаружил старый orphan, старую непривязанную строку и одну используемую строку. Apply за 77 миллисекунд удалил только orphan и непривязанную строку. Повторный apply занял 38 миллисекунд, выполнил ноль удалений, а используемая строка осталась в PostgreSQL. + +## Ограничения + +- Между S3 PUT и PostgreSQL INSERT нет общей транзакции; компенсация и reconciler обеспечивают eventual consistency. +- Удалённый object используемого вложения автоматически не восстанавливается: строка сохраняется и требует восстановления байтов из резервной копии либо решения оператора. +- Grace period основан на времени PostgreSQL и S3; для удалённого стенда требуется синхронизация часов. +- Admission control действует отдельно в каждой API-реплике; при изменении контейнерного лимита его бюджет нужно настраивать вместе с `ATTACHMENT_DECODE_MEMORY_BYTES`. +- MinIO собирается из официального закреплённого source tag, поскольку готовые community images больше не публикуются. Это увеличивает время первого CI build. +- Локальный HTTP допустим только для учебного стенда с синтетическими данными; удалённое развёртывание требует TLS. + +## Источники + +- [MinIO releases](https://github.com/minio/minio/releases) +- [MinIO Go SDK](https://github.com/minio/minio-go) +- [PostgreSQL constraints](https://www.postgresql.org/docs/current/ddl-constraints.html) +- [Go image package](https://pkg.go.dev/image) diff --git a/cmd/lab4experiment/main.go b/cmd/lab4experiment/main.go new file mode 100644 index 00000000..ed24f21a --- /dev/null +++ b/cmd/lab4experiment/main.go @@ -0,0 +1,654 @@ +package main + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "errors" + "flag" + "fmt" + "image" + "image/jpeg" + "io" + "net/http" + "os" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile" +) + +const experimentPassword = "Lab4-experiment-password" + +type apiClient struct { + baseURL string + client *http.Client + token string +} + +type attachment struct { + ID string `json:"id"` +} + +type setup struct { + client *apiClient + chatID string +} + +func main() { + if err := run(os.Args[1:], os.Stdout); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func run(arguments []string, output io.Writer) error { + if len(arguments) == 0 { + return errors.New("usage: lab4experiment memory|consistency [flags]") + } + switch arguments[0] { + case "memory": + return runMemory(arguments[1:], output) + case "consistency": + return runConsistency(arguments[1:], output) + default: + return errors.New("usage: lab4experiment memory|consistency [flags]") + } +} + +type memoryResult struct { + Replicas int `json:"replicas"` + Concurrency int `json:"concurrency"` + Rounds int `json:"rounds"` + SettleTimeMillis int64 `json:"settle_time_ms"` + ImageBytes int `json:"image_bytes"` + UploadRateBytes int64 `json:"upload_rate_bytes_per_second"` + SuccessfulUploads int64 `json:"successful_uploads"` + FailedUploads int64 `json:"failed_uploads"` + DurationMillis int64 `json:"duration_ms"` + HeapBaselineBytes int64 `json:"heap_baseline_bytes"` + HeapPeakBytes int64 `json:"heap_peak_bytes"` + HeapDeltaBytes int64 `json:"heap_delta_bytes"` + RSSBaselineBytes int64 `json:"rss_baseline_bytes"` + RSSPeakBytes int64 `json:"rss_peak_bytes"` + RSSDeltaBytes int64 `json:"rss_delta_bytes"` +} + +func runMemory(arguments []string, output io.Writer) error { + flags := flag.NewFlagSet("memory", flag.ContinueOnError) + flags.SetOutput(io.Discard) + baseURL := flags.String("base-url", "http://nginx:8080", "messenger base URL") + prometheusURL := flags.String("prometheus-url", "http://prometheus:9090", "Prometheus base URL") + replicas := flags.Int("replicas", 2, "expected API replicas") + concurrency := flags.Int("concurrency", 12, "number of concurrent uploads") + rounds := flags.Int("rounds", 4, "number of upload waves") + width := flags.Int("width", 2048, "image width") + height := flags.Int("height", 2048, "image height") + uploadRate := flags.Int64("upload-rate", 1536*1024, "bytes per second for each upload") + settleTime := flags.Duration("settle-time", 3*time.Second, "delay before the baseline sample") + if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { + return errors.New("invalid memory experiment flags") + } + if *replicas < 1 || *concurrency < 10 || *rounds < 1 || *width < 1 || *height < 1 || *uploadRate < 1 || *settleTime < 0 { + return errors.New("concurrency must be at least 10 and rounds/dimensions/rate must be positive") + } + + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute) + defer cancel() + fixture, err := jpegFixture(*width, *height) + if err != nil { + return err + } + if err := waitForReplicas(ctx, *prometheusURL, *replicas); err != nil { + return err + } + settle := time.NewTimer(*settleTime) + defer settle.Stop() + select { + case <-ctx.Done(): + return ctx.Err() + case <-settle.C: + } + heapBaseline, err := prometheusValue(ctx, *prometheusURL, freshMetricQuery("go_memstats_heap_alloc_bytes")) + if err != nil { + return err + } + rssBaseline, err := prometheusValue(ctx, *prometheusURL, freshMetricQuery("process_resident_memory_bytes")) + if err != nil { + return err + } + environment, err := prepare(ctx, *baseURL) + if err != nil { + return err + } + + var successful atomic.Int64 + var failed atomic.Int64 + var firstError struct { + sync.Mutex + err error + } + heapPeak := heapBaseline + rssPeak := rssBaseline + loadDone := make(chan struct{}) + sampleDone := make(chan error, 1) + go sampleMemory(ctx, *prometheusURL, *replicas, loadDone, &heapPeak, &rssPeak, sampleDone) + started := time.Now() + for round := range *rounds { + var workers sync.WaitGroup + workers.Add(*concurrency) + for index := range *concurrency { + go func(round, index int) { + defer workers.Done() + reader := newRateReader(fixture, *uploadRate) + filename := fmt.Sprintf("memory-%02d-%02d.jpg", round, index) + if _, err := environment.client.upload(ctx, environment.chatID, filename, reader, int64(len(fixture))); err != nil { + failed.Add(1) + firstError.Lock() + if firstError.err == nil { + firstError.err = err + } + firstError.Unlock() + return + } + successful.Add(1) + }(round, index) + } + workers.Wait() + } + close(loadDone) + if err := <-sampleDone; err != nil { + return err + } + result := memoryResult{ + Replicas: *replicas, Concurrency: *concurrency, Rounds: *rounds, SettleTimeMillis: settleTime.Milliseconds(), + ImageBytes: len(fixture), UploadRateBytes: *uploadRate, + SuccessfulUploads: successful.Load(), FailedUploads: failed.Load(), DurationMillis: time.Since(started).Milliseconds(), + HeapBaselineBytes: heapBaseline, HeapPeakBytes: heapPeak, HeapDeltaBytes: heapPeak - heapBaseline, + RSSBaselineBytes: rssBaseline, RSSPeakBytes: rssPeak, RSSDeltaBytes: rssPeak - rssBaseline, + } + if result.FailedUploads > 0 { + return fmt.Errorf("%d uploads failed: %w", result.FailedUploads, firstError.err) + } + return writeJSON(output, result) +} + +func sampleMemory( + ctx context.Context, + prometheusURL string, + expectedReplicas int, + done <-chan struct{}, + heapPeak *int64, + rssPeak *int64, + result chan<- error, +) { + ticker := time.NewTicker(500 * time.Millisecond) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + result <- ctx.Err() + return + case <-done: + result <- nil + return + case <-ticker.C: + replicas, err := prometheusValue(ctx, prometheusURL, activeReplicasQuery()) + if err != nil { + result <- err + return + } + if replicas != int64(expectedReplicas) { + result <- fmt.Errorf("active API replicas = %d, expected %d", replicas, expectedReplicas) + return + } + heap, err := prometheusValue(ctx, prometheusURL, freshMetricQuery("go_memstats_heap_alloc_bytes")) + if err != nil { + result <- err + return + } + rss, err := prometheusValue(ctx, prometheusURL, freshMetricQuery("process_resident_memory_bytes")) + if err != nil { + result <- err + return + } + *heapPeak = max(*heapPeak, heap) + *rssPeak = max(*rssPeak, rss) + } + } +} + +type consistencyResult struct { + PageSize int `json:"page_size"` + SeededConsistent int `json:"seeded_consistent"` + FreshApply reconciliationRun `json:"fresh_apply"` + DryRun reconciliationRun `json:"dry_run"` + Apply reconciliationRun `json:"apply"` + RepeatedApply reconciliationRun `json:"repeated_apply"` + FreshPreserved bool `json:"fresh_preserved"` + OrphanDeleted bool `json:"orphan_deleted"` + UnusedDeleted bool `json:"unused_metadata_deleted"` + InUsePreserved bool `json:"in_use_metadata_preserved"` + TotalDurationMillis int64 `json:"total_duration_ms"` +} + +type reconciliationRun struct { + DurationMillis int64 `json:"duration_ms"` + Report reconcile.Report `json:"report"` +} + +func runConsistency(arguments []string, output io.Writer) error { + flags := flag.NewFlagSet("consistency", flag.ContinueOnError) + flags.SetOutput(io.Discard) + baseURL := flags.String("base-url", "http://nginx:8080", "messenger base URL") + pageSize := flags.Int("page-size", 10, "reconciliation page size") + if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { + return errors.New("invalid consistency experiment flags") + } + + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + settings, err := config.Load() + if err != nil { + return err + } + pool, err := database.Open(ctx, database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + objects, err := objectstore.New(objectstore.Config{ + Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, + AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, + UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, + }) + if err != nil { + return err + } + metadata := postgres.New(pool) + clean, err := reconcile.New(metadata, objects, reconcile.Config{Prefix: "attachments/", PageSize: *pageSize, GraceTime: 0}) + if err != nil { + return err + } + initial, err := clean.Run(ctx) + if err != nil { + return err + } + if hasAnomalies(initial) { + return errors.New("consistency experiment requires a stack without existing attachment anomalies") + } + + started := time.Now() + environment, err := prepare(ctx, *baseURL) + if err != nil { + return err + } + fixture, err := jpegFixture(320, 200) + if err != nil { + return err + } + seededConsistent := *pageSize + 1 + for index := range seededConsistent { + filename := fmt.Sprintf("consistent-%03d.jpg", index) + if _, err := environment.client.upload(ctx, environment.chatID, filename, bytes.NewReader(fixture), int64(len(fixture))); err != nil { + return err + } + } + unused, err := environment.client.upload(ctx, environment.chatID, "unused-missing.jpg", bytes.NewReader(fixture), int64(len(fixture))) + if err != nil { + return err + } + inUse, err := environment.client.upload(ctx, environment.chatID, "in-use-missing.jpg", bytes.NewReader(fixture), int64(len(fixture))) + if err != nil { + return err + } + if err := environment.client.createMessage(ctx, environment.chatID, inUse.ID); err != nil { + return err + } + keys, err := attachmentKeys(ctx, pool, []string{unused.ID, inUse.ID}) + if err != nil { + return err + } + if err := objects.Delete(ctx, keys[unused.ID]); err != nil { + return err + } + if err := objects.Delete(ctx, keys[inUse.ID]); err != nil { + return err + } + orphanKey := "attachments/experiment-" + uuid.NewString() + "/original" + if err := objects.Put(ctx, orphanKey, "image/jpeg", fixture); err != nil { + return err + } + + fresh, err := reconcile.New(metadata, objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, GraceTime: time.Hour, Apply: true, + }) + if err != nil { + return err + } + freshRun, err := measuredReconciliation(ctx, fresh) + if err != nil { + return err + } + freshPreserved := objectExists(ctx, objects, orphanKey) && + attachmentExists(ctx, pool, unused.ID) && attachmentExists(ctx, pool, inUse.ID) + + dryRun, err := reconcile.New(metadata, objects, reconcile.Config{Prefix: "attachments/", PageSize: *pageSize}) + if err != nil { + return err + } + dryRunResult, err := measuredReconciliation(ctx, dryRun) + if err != nil { + return err + } + apply, err := reconcile.New(metadata, objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, Apply: true, + }) + if err != nil { + return err + } + applyResult, err := measuredReconciliation(ctx, apply) + if err != nil { + return err + } + repeatedResult, err := measuredReconciliation(ctx, apply) + if err != nil { + return err + } + + result := consistencyResult{ + PageSize: *pageSize, SeededConsistent: seededConsistent, + FreshApply: freshRun, DryRun: dryRunResult, Apply: applyResult, RepeatedApply: repeatedResult, + FreshPreserved: freshPreserved, OrphanDeleted: !objectExists(ctx, objects, orphanKey), + UnusedDeleted: !attachmentExists(ctx, pool, unused.ID), InUsePreserved: attachmentExists(ctx, pool, inUse.ID), + TotalDurationMillis: time.Since(started).Milliseconds(), + } + if !result.FreshPreserved || !result.OrphanDeleted || !result.UnusedDeleted || !result.InUsePreserved || + repeatedResult.Report.DeletedOrphanObjects != 0 || repeatedResult.Report.DeletedUnreferencedRows != 0 { + return fmt.Errorf("unexpected reconciliation result: %+v", result) + } + return writeJSON(output, result) +} + +func measuredReconciliation(ctx context.Context, reconciler *reconcile.Reconciler) (reconciliationRun, error) { + started := time.Now() + report, err := reconciler.Run(ctx) + return reconciliationRun{DurationMillis: time.Since(started).Milliseconds(), Report: report}, err +} + +func hasAnomalies(report reconcile.Report) bool { + return report.FreshOrphanObjects != 0 || report.OldOrphanObjects != 0 || + report.FreshMissingObjects != 0 || report.ReferencedMissingObjects != 0 || + report.OldUnreferencedMetadata != 0 +} + +func attachmentKeys(ctx context.Context, pool *pgxpool.Pool, ids []string) (map[string]string, error) { + rows, err := pool.Query(ctx, `SELECT id::text, object_key FROM attachments WHERE id::text = ANY($1)`, ids) + if err != nil { + return nil, fmt.Errorf("query attachment keys: %w", err) + } + defer rows.Close() + keys := make(map[string]string, len(ids)) + for rows.Next() { + var id string + var key string + if err := rows.Scan(&id, &key); err != nil { + return nil, fmt.Errorf("scan attachment key: %w", err) + } + keys[id] = key + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate attachment keys: %w", err) + } + if len(keys) != len(ids) { + return nil, errors.New("not all attachment keys were found") + } + return keys, nil +} + +func attachmentExists(ctx context.Context, pool *pgxpool.Pool, id string) bool { + var exists bool + return pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM attachments WHERE id = $1)`, id).Scan(&exists) == nil && exists +} + +func objectExists(ctx context.Context, objects *objectstore.Store, key string) bool { + _, err := objects.Stat(ctx, key) + return err == nil +} + +func prepare(ctx context.Context, baseURL string) (setup, error) { + client := &apiClient{baseURL: strings.TrimRight(baseURL, "/"), client: &http.Client{Timeout: 90 * time.Second}} + username := "lab4_" + strings.ReplaceAll(uuid.NewString()[:18], "-", "") + var user struct { + ID string `json:"id"` + } + if err := client.jsonRequest(ctx, http.MethodPost, "/api/v1/users", map[string]string{ + "username": username, "display_name": "Lab 4 experiment", "password": experimentPassword, + }, &user, ""); err != nil { + return setup{}, err + } + credentials := base64.StdEncoding.EncodeToString([]byte(username + ":" + experimentPassword)) + var session struct { + Token string `json:"token"` + } + if err := client.jsonRequest(ctx, http.MethodPost, "/api/v1/auth/sessions", nil, &session, "Basic "+credentials); err != nil { + return setup{}, err + } + client.token = session.Token + var chat struct { + ID string `json:"id"` + } + if err := client.jsonRequest(ctx, http.MethodPost, "/api/v1/chats", map[string]any{ + "title": "Lab 4 experiment", "member_ids": []string{user.ID}, + }, &chat, "Bearer "+client.token); err != nil { + return setup{}, err + } + return setup{client: client, chatID: chat.ID}, nil +} + +func (c *apiClient) upload( + ctx context.Context, + chatID string, + filename string, + body io.Reader, + contentLength int64, +) (attachment, error) { + path := "/api/v1/chats/" + chatID + "/attachments?filename=" + filename + request, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, body) + if err != nil { + return attachment{}, err + } + request.ContentLength = contentLength + request.Header.Set("Authorization", "Bearer "+c.token) + request.Header.Set("Content-Type", "image/jpeg") + response, err := c.client.Do(request) + if err != nil { + return attachment{}, err + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + message, _ := io.ReadAll(io.LimitReader(response.Body, 4096)) + return attachment{}, fmt.Errorf("upload status %d: %s", response.StatusCode, message) + } + var result attachment + if err := json.NewDecoder(response.Body).Decode(&result); err != nil { + return attachment{}, err + } + return result, nil +} + +func (c *apiClient) createMessage(ctx context.Context, chatID, attachmentID string) error { + return c.jsonRequest(ctx, http.MethodPost, "/api/v1/chats/"+chatID+"/messages", map[string]any{ + "text": "", "attachment_ids": []string{attachmentID}, + }, nil, "Bearer "+c.token, "Idempotency-Key", uuid.NewString()) +} + +func (c *apiClient) jsonRequest( + ctx context.Context, + method string, + path string, + payload any, + result any, + authorization string, + extraHeader ...string, +) error { + var body io.Reader + if payload != nil { + encoded, err := json.Marshal(payload) + if err != nil { + return err + } + body = bytes.NewReader(encoded) + } + request, err := http.NewRequestWithContext(ctx, method, c.baseURL+path, body) + if err != nil { + return err + } + if payload != nil { + request.Header.Set("Content-Type", "application/json") + } + if authorization != "" { + request.Header.Set("Authorization", authorization) + } + for index := 0; index+1 < len(extraHeader); index += 2 { + request.Header.Set(extraHeader[index], extraHeader[index+1]) + } + response, err := c.client.Do(request) + if err != nil { + return err + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode < 200 || response.StatusCode >= 300 { + message, _ := io.ReadAll(io.LimitReader(response.Body, 4096)) + return fmt.Errorf("%s %s status %d: %s", method, path, response.StatusCode, message) + } + if result == nil { + return nil + } + return json.NewDecoder(response.Body).Decode(result) +} + +func waitForReplicas(ctx context.Context, prometheusURL string, expected int) error { + ticker := time.NewTicker(time.Second) + defer ticker.Stop() + for { + count, err := prometheusValue(ctx, prometheusURL, activeReplicasQuery()) + if err == nil && count == int64(expected) { + return nil + } + select { + case <-ctx.Done(): + return fmt.Errorf("wait for %d Prometheus API targets: %w", expected, ctx.Err()) + case <-ticker.C: + } + } +} + +func activeReplicasQuery() string { + return `count(timestamp(process_resident_memory_bytes{job="messenger"}) > time() - 10)` +} + +func freshMetricQuery(metric string) string { + return fmt.Sprintf(`sum(%[1]s{job="messenger"} and on(instance) (timestamp(%[1]s{job="messenger"}) > time() - 10))`, metric) +} + +func prometheusValue(ctx context.Context, baseURL, query string) (int64, error) { + request, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+"/api/v1/query", nil) + if err != nil { + return 0, err + } + values := request.URL.Query() + values.Set("query", query) + request.URL.RawQuery = values.Encode() + response, err := http.DefaultClient.Do(request) + if err != nil { + return 0, err + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusOK { + return 0, fmt.Errorf("prometheus status %d", response.StatusCode) + } + var payload struct { + Status string `json:"status"` + Data struct { + Result []struct { + Value []json.RawMessage `json:"value"` + } `json:"result"` + } `json:"data"` + } + if err := json.NewDecoder(response.Body).Decode(&payload); err != nil { + return 0, err + } + if payload.Status != "success" || len(payload.Data.Result) != 1 || len(payload.Data.Result[0].Value) != 2 { + return 0, errors.New("prometheus query returned no scalar value") + } + var raw string + if err := json.Unmarshal(payload.Data.Result[0].Value[1], &raw); err != nil { + return 0, err + } + value, err := strconv.ParseFloat(raw, 64) + return int64(value), err +} + +func jpegFixture(width, height int) ([]byte, error) { + pixels := image.NewRGBA(image.Rect(0, 0, width, height)) + state := uint64(0x9e3779b97f4a7c15) + for index := range pixels.Pix { + state ^= state << 13 + state ^= state >> 7 + state ^= state << 17 + pixels.Pix[index] = byte(state >> 24) + } + var encoded bytes.Buffer + if err := jpeg.Encode(&encoded, pixels, &jpeg.Options{Quality: 90}); err != nil { + return nil, err + } + return encoded.Bytes(), nil +} + +type rateReader struct { + reader *bytes.Reader + rate int64 + started time.Time + read int64 +} + +func newRateReader(data []byte, rate int64) *rateReader { + return &rateReader{reader: bytes.NewReader(data), rate: rate, started: time.Now()} +} + +func (r *rateReader) Read(buffer []byte) (int, error) { + for { + allowed := time.Since(r.started).Nanoseconds()*r.rate/int64(time.Second) - r.read + if allowed > 0 { + if int64(len(buffer)) > allowed { + buffer = buffer[:allowed] + } + count, err := r.reader.Read(buffer) + r.read += int64(count) + return count, err + } + time.Sleep(10 * time.Millisecond) + } +} + +func writeJSON(output io.Writer, value any) error { + encoder := json.NewEncoder(output) + encoder.SetIndent("", " ") + return encoder.Encode(value) +} diff --git a/evidence/lab4-consistency.json b/evidence/lab4-consistency.json new file mode 100644 index 00000000..e131f419 --- /dev/null +++ b/evidence/lab4-consistency.json @@ -0,0 +1,69 @@ +{ + "page_size": 10, + "seeded_consistent": 11, + "fresh_apply": { + "duration_ms": 58, + "report": { + "metadata_scanned": 206, + "objects_scanned": 205, + "consistent": 204, + "fresh_orphan_objects": 1, + "old_orphan_objects": 0, + "deleted_orphan_objects": 0, + "fresh_missing_objects": 2, + "referenced_missing_objects": 0, + "old_unreferenced_metadata": 0, + "deleted_unreferenced_rows": 0 + } + }, + "dry_run": { + "duration_ms": 65, + "report": { + "metadata_scanned": 206, + "objects_scanned": 205, + "consistent": 204, + "fresh_orphan_objects": 0, + "old_orphan_objects": 1, + "deleted_orphan_objects": 0, + "fresh_missing_objects": 0, + "referenced_missing_objects": 1, + "old_unreferenced_metadata": 1, + "deleted_unreferenced_rows": 0 + } + }, + "apply": { + "duration_ms": 77, + "report": { + "metadata_scanned": 206, + "objects_scanned": 205, + "consistent": 204, + "fresh_orphan_objects": 0, + "old_orphan_objects": 1, + "deleted_orphan_objects": 1, + "fresh_missing_objects": 0, + "referenced_missing_objects": 1, + "old_unreferenced_metadata": 1, + "deleted_unreferenced_rows": 1 + } + }, + "repeated_apply": { + "duration_ms": 38, + "report": { + "metadata_scanned": 205, + "objects_scanned": 204, + "consistent": 204, + "fresh_orphan_objects": 0, + "old_orphan_objects": 0, + "deleted_orphan_objects": 0, + "fresh_missing_objects": 0, + "referenced_missing_objects": 1, + "old_unreferenced_metadata": 0, + "deleted_unreferenced_rows": 0 + } + }, + "fresh_preserved": true, + "orphan_deleted": true, + "unused_metadata_deleted": true, + "in_use_metadata_preserved": true, + "total_duration_ms": 515 +} diff --git a/evidence/lab4-memory.json b/evidence/lab4-memory.json new file mode 100644 index 00000000..3531b378 --- /dev/null +++ b/evidence/lab4-memory.json @@ -0,0 +1,17 @@ +{ + "replicas": 2, + "concurrency": 12, + "rounds": 4, + "settle_time_ms": 3000, + "image_bytes": 3759914, + "upload_rate_bytes_per_second": 1572864, + "successful_uploads": 48, + "failed_uploads": 0, + "duration_ms": 12629, + "heap_baseline_bytes": 181133200, + "heap_peak_bytes": 202374848, + "heap_delta_bytes": 21241648, + "rss_baseline_bytes": 241922048, + "rss_peak_bytes": 381063168, + "rss_delta_bytes": 139141120 +} diff --git a/evidence/lab4-verification.txt b/evidence/lab4-verification.txt new file mode 100644 index 00000000..0b4bc585 --- /dev/null +++ b/evidence/lab4-verification.txt @@ -0,0 +1,19 @@ +Date: 2026-10-02 +Environment: linux/arm64 containers, Docker Compose, 2 API replicas + +PASS gofmt for changed Go files +PASS go test ./... +PASS go build ./cmd/... +PASS make check +PASS make test BASE_URL=http://localhost:8080 + PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. +PASS MinIO server RELEASE.2025-10-15T17-29-55Z built from the official source tag +PASS mc RELEASE.2025-08-13T08-35-41Z built from the official source tag +PASS bucket bootstrap executed twice without an error +PASS anonymous bucket request returned HTTP 403 +PASS application credentials can list only the configured bucket and cannot create another bucket +PASS 48 of 48 uploads succeeded in 4 waves with concurrency 12 +PASS reconciler preserved fresh and referenced anomalies, removed safe old anomalies, and repeated apply made no changes + +The pull request CI runs OpenAPI validation, race tests, lint, integration tests, +persistence and API-replica failover on the exact pushed commit. diff --git a/internal/reconcile/reconcile_test.go b/internal/reconcile/reconcile_test.go new file mode 100644 index 00000000..defe3cde --- /dev/null +++ b/internal/reconcile/reconcile_test.go @@ -0,0 +1,129 @@ +package reconcile + +import ( + "context" + "sort" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" +) + +func TestReconcilerDryRunAndApply(t *testing.T) { + now := time.Date(2026, 10, 2, 12, 0, 0, 0, time.UTC) + metadata := &metadataStub{items: []model.Attachment{ + {ID: "consistent", ObjectKey: "attachments/consistent", CreatedAt: now.Add(-time.Hour)}, + {ID: "fresh-missing", ObjectKey: "attachments/fresh-missing", CreatedAt: now.Add(-time.Minute)}, + {ID: "old-missing", ObjectKey: "attachments/old-missing", CreatedAt: now.Add(-time.Hour)}, + {ID: "referenced-missing", ObjectKey: "attachments/referenced-missing", CreatedAt: now.Add(-time.Hour)}, + }, referenced: map[string]bool{"referenced-missing": true}} + objects := &objectStub{items: []objectstore.Object{ + {Key: "attachments/consistent", LastModified: now.Add(-time.Hour)}, + {Key: "attachments/fresh-orphan", LastModified: now.Add(-time.Minute)}, + {Key: "attachments/old-orphan", LastModified: now.Add(-time.Hour)}, + }} + + dryRun, err := New(metadata, objects, Config{ + Prefix: "attachments/", PageSize: 2, GraceTime: 10 * time.Minute, Now: func() time.Time { return now }, + }) + require.NoError(t, err) + report, err := dryRun.Run(context.Background()) + require.NoError(t, err) + require.Equal(t, Report{ + MetadataScanned: 4, ObjectsScanned: 3, Consistent: 1, + FreshOrphanObjects: 1, OldOrphanObjects: 1, FreshMissingObjects: 1, + ReferencedMissingObjects: 1, OldUnreferencedMetadata: 1, + }, report) + require.Empty(t, metadata.deleted) + require.Empty(t, objects.deleted) + + apply, err := New(metadata, objects, Config{ + Prefix: "attachments/", PageSize: 2, GraceTime: 10 * time.Minute, Apply: true, + Now: func() time.Time { return now }, + }) + require.NoError(t, err) + report, err = apply.Run(context.Background()) + require.NoError(t, err) + require.Equal(t, 1, report.DeletedOrphanObjects) + require.Equal(t, 1, report.DeletedUnreferencedRows) + require.Equal(t, []string{"old-missing"}, metadata.deleted) + require.Equal(t, []string{"attachments/old-orphan"}, objects.deleted) + + report, err = apply.Run(context.Background()) + require.NoError(t, err) + require.Zero(t, report.DeletedOrphanObjects) + require.Zero(t, report.DeletedUnreferencedRows) + require.Equal(t, 1, report.FreshOrphanObjects) + require.Equal(t, 1, report.FreshMissingObjects) + require.Equal(t, 1, report.ReferencedMissingObjects) +} + +type metadataStub struct { + items []model.Attachment + referenced map[string]bool + deleted []string +} + +func (s *metadataStub) ListAttachments(_ context.Context, after string, limit int) ([]model.Attachment, string, error) { + items := append([]model.Attachment(nil), s.items...) + sort.Slice(items, func(i, j int) bool { return items[i].ObjectKey < items[j].ObjectKey }) + start := 0 + for start < len(items) && items[start].ObjectKey <= after { + start++ + } + end := min(start+limit, len(items)) + var next string + if end < len(items) { + next = items[end-1].ObjectKey + } + return items[start:end], next, nil +} + +func (s *metadataStub) AttachmentReferenced(_ context.Context, id string) (bool, error) { + return s.referenced[id], nil +} + +func (s *metadataStub) DeleteAttachmentIfUnreferencedBefore(_ context.Context, id string, _ time.Time) (bool, error) { + for index, item := range s.items { + if item.ID == id && !s.referenced[id] { + s.items = append(s.items[:index], s.items[index+1:]...) + s.deleted = append(s.deleted, id) + return true, nil + } + } + return false, nil +} + +type objectStub struct { + items []objectstore.Object + deleted []string +} + +func (s *objectStub) List(_ context.Context, _ string, after string, limit int) ([]objectstore.Object, string, error) { + items := append([]objectstore.Object(nil), s.items...) + sort.Slice(items, func(i, j int) bool { return items[i].Key < items[j].Key }) + start := 0 + for start < len(items) && items[start].Key <= after { + start++ + } + end := min(start+limit, len(items)) + var next string + if end < len(items) { + next = items[end-1].Key + } + return items[start:end], next, nil +} + +func (s *objectStub) Delete(_ context.Context, key string) error { + for index, item := range s.items { + if item.Key == key { + s.items = append(s.items[:index], s.items[index+1:]...) + s.deleted = append(s.deleted, key) + return nil + } + } + return nil +} -- 2.54.0 From 110236d01f06e07022307ce30db67b97f35c2ead Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 19:55:52 +0300 Subject: [PATCH 04/15] ops: add private object storage --- Dockerfile | 7 ++- compose.yaml | 63 ++++++++++++++++++++ infra/minio/bootstrap.sh | 36 +++++++++++ infra/minio/client.Dockerfile | 16 +++++ infra/minio/server.Dockerfile | 18 ++++++ lab4.env.example | 22 ++++++- monitoring/grafana/dashboards/messenger.json | 48 ++++++++++++++- monitoring/prometheus.yml | 9 ++- nginx/nginx.conf | 2 + scripts/restart.sh | 5 +- scripts/rolling-update.sh | 3 +- 11 files changed, 220 insertions(+), 9 deletions(-) create mode 100644 infra/minio/bootstrap.sh create mode 100644 infra/minio/client.Dockerfile create mode 100644 infra/minio/server.Dockerfile diff --git a/Dockerfile b/Dockerfile index f602f140..e903874c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,8 +1,12 @@ FROM golang:1.26.5-alpine3.24 AS build WORKDIR /src +ENV GOMAXPROCS=2 GOMEMLIMIT=1GiB +COPY go.mod go.sum ./ +RUN go mod download COPY . . -RUN go build -o /out/messenger ./cmd/messenger +RUN go build -p=1 -o /out/messenger ./cmd/messenger +RUN go build -p=1 -o /out/lab4experiment ./cmd/lab4experiment FROM build AS test @@ -30,6 +34,7 @@ FROM alpine:3.24.2 RUN addgroup -S app && adduser -S -G app -u 10001 app COPY --from=build --chown=app:app /out/messenger /app/messenger +COPY --from=build --chown=app:app /out/lab4experiment /app/lab4experiment USER app WORKDIR /app diff --git a/compose.yaml b/compose.yaml index 2192f643..26eff747 100644 --- a/compose.yaml +++ b/compose.yaml @@ -32,6 +32,55 @@ services: mem_limit: ${VALKEY_MEMORY} restart: unless-stopped + s3: + build: + context: . + dockerfile: infra/minio/server.Dockerfile + args: + MINIO_VERSION: RELEASE.2025-10-15T17-29-55Z + image: mtusi-minio:RELEASE.2025-10-15T17-29-55Z + command: ["server", "/data", "--address", ":9000"] + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD} + MINIO_BROWSER: "off" + MINIO_PROMETHEUS_AUTH_TYPE: public + volumes: + - s3_data:/data + expose: + - "9000" + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/minio/health/ready"] + interval: 5s + timeout: 3s + retries: 20 + cpus: ${S3_CPUS} + mem_limit: ${S3_MEMORY} + restart: unless-stopped + + s3-bootstrap: + build: + context: . + dockerfile: infra/minio/client.Dockerfile + args: + MC_VERSION: RELEASE.2025-08-13T08-35-41Z + image: mtusi-mc:RELEASE.2025-08-13T08-35-41Z + entrypoint: ["/bin/sh", "/usr/local/bin/bootstrap.sh"] + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD} + S3_BUCKET: ${S3_BUCKET} + S3_ACCESS_KEY: ${S3_ACCESS_KEY} + S3_SECRET_KEY: ${S3_SECRET_KEY} + depends_on: + s3: + condition: service_healthy + healthcheck: + disable: true + cpus: ${S3_BOOTSTRAP_CPUS} + mem_limit: ${S3_BOOTSTRAP_MEMORY} + restart: "no" + migrate: image: ${API_IMAGE:-mtusi-messenger:lab4} command: ["/app/messenger", "migrate"] @@ -82,6 +131,16 @@ services: PASSWORD_SALT_LENGTH: ${PASSWORD_SALT_LENGTH} PASSWORD_KEY_LENGTH: ${PASSWORD_KEY_LENGTH} SWAGGER_PORT: ${SWAGGER_PORT} + S3_ENDPOINT: ${S3_ENDPOINT} + S3_REGION: ${S3_REGION} + S3_BUCKET: ${S3_BUCKET} + S3_ACCESS_KEY: ${S3_ACCESS_KEY} + S3_SECRET_KEY: ${S3_SECRET_KEY} + S3_USE_TLS: ${S3_USE_TLS} + S3_TIMEOUT_SECONDS: ${S3_TIMEOUT_SECONDS} + ATTACHMENT_MAX_BYTES: ${ATTACHMENT_MAX_BYTES} + ATTACHMENT_MAX_PIXELS: ${ATTACHMENT_MAX_PIXELS} + ATTACHMENT_DECODE_MEMORY_BYTES: ${ATTACHMENT_DECODE_MEMORY_BYTES} expose: - "8080" depends_on: @@ -89,6 +148,8 @@ services: condition: service_completed_successfully valkey: condition: service_healthy + s3-bootstrap: + condition: service_completed_successfully healthcheck: test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:${APP_PORT}/health/ready || exit 1"] interval: 2s @@ -211,6 +272,7 @@ services: - nginx-exporter - postgres-exporter - valkey-exporter + - s3 cpus: ${PROMETHEUS_CPUS} mem_limit: ${PROMETHEUS_MEMORY} restart: unless-stopped @@ -239,3 +301,4 @@ volumes: valkey_data: prometheus_data: grafana_data: + s3_data: diff --git a/infra/minio/bootstrap.sh b/infra/minio/bootstrap.sh new file mode 100644 index 00000000..68a28884 --- /dev/null +++ b/infra/minio/bootstrap.sh @@ -0,0 +1,36 @@ +#!/bin/sh + +set -eu + +alias_name=bootstrap +policy_name=messenger-attachments +policy_file=/tmp/messenger-attachments-policy.json + +mc alias set "$alias_name" http://s3:9000 "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD" +mc mb --ignore-existing "$alias_name/$S3_BUCKET" +mc anonymous set none "$alias_name/$S3_BUCKET" + +cat >"$policy_file" </dev/null diff --git a/infra/minio/client.Dockerfile b/infra/minio/client.Dockerfile new file mode 100644 index 00000000..fe8ee0a4 --- /dev/null +++ b/infra/minio/client.Dockerfile @@ -0,0 +1,16 @@ +FROM golang:1.24.8-alpine3.22 AS build + +ARG MC_VERSION +RUN apk add --no-cache git +RUN git clone --depth 1 --branch "${MC_VERSION}" https://github.com/minio/mc.git /src/mc +WORKDIR /src/mc +RUN go mod download +RUN LDFLAGS="$(MC_RELEASE=RELEASE go run buildscripts/gen-ldflags.go)" && \ + GOMAXPROCS=2 GOMEMLIMIT=1GiB CGO_ENABLED=0 go build -p=1 -tags kqueue -trimpath -ldflags "$LDFLAGS" -o /out/mc . + +FROM alpine:3.22.2 + +COPY --from=build /out/mc /usr/local/bin/mc +COPY infra/minio/bootstrap.sh /usr/local/bin/bootstrap.sh + +ENTRYPOINT ["mc"] diff --git a/infra/minio/server.Dockerfile b/infra/minio/server.Dockerfile new file mode 100644 index 00000000..44b75c4d --- /dev/null +++ b/infra/minio/server.Dockerfile @@ -0,0 +1,18 @@ +FROM golang:1.24.8-alpine3.22 AS build + +ARG MINIO_VERSION +RUN apk add --no-cache git +RUN git clone --depth 1 --branch "${MINIO_VERSION}" https://github.com/minio/minio.git /src/minio +WORKDIR /src/minio +RUN go mod download +RUN LDFLAGS="$(MINIO_RELEASE=RELEASE go run buildscripts/gen-ldflags.go)" && \ + GOMAXPROCS=2 GOMEMLIMIT=1GiB CGO_ENABLED=0 go build -p=1 -tags kqueue -trimpath -ldflags "$LDFLAGS" -o /out/minio . + +FROM alpine:3.22.2 + +RUN addgroup -S minio && adduser -S -G minio minio && mkdir /data && chown minio:minio /data +COPY --from=build /out/minio /usr/local/bin/minio + +USER minio +VOLUME ["/data"] +ENTRYPOINT ["minio"] diff --git a/lab4.env.example b/lab4.env.example index 447b3b72..11cbdb52 100644 --- a/lab4.env.example +++ b/lab4.env.example @@ -26,6 +26,22 @@ DATABASE_URL=postgres://messenger:local-postgres-password@postgres:5432/messenge VALKEY_PASSWORD=local-valkey-password CACHE_URL=redis://default:local-valkey-password@valkey:6379/0 +# Административные данные MinIO используются только при bootstrap. +MINIO_ROOT_USER=local-minio-admin +MINIO_ROOT_PASSWORD=local-minio-admin-password + +# API использует отдельного пользователя с доступом только к bucket вложений. +S3_ENDPOINT=s3:9000 +S3_REGION=us-east-1 +S3_BUCKET=messenger-attachments +S3_ACCESS_KEY=messenger-app +S3_SECRET_KEY=local-messenger-s3-password +S3_USE_TLS=false +S3_TIMEOUT_SECONDS=5 +ATTACHMENT_MAX_BYTES=10485760 +ATTACHMENT_MAX_PIXELS=40000000 +ATTACHMENT_DECODE_MEMORY_BYTES=402653184 + # Размер пула и обслуживание соединений PostgreSQL. DB_MIN_CONNS=1 DB_MAX_CONNS=10 @@ -55,7 +71,7 @@ SWAGGER_PORT=8081 # Ограничения ресурсов контейнеров. API_CPUS=1 -API_MEMORY=256m +API_MEMORY=512m MIGRATE_CPUS=0.5 MIGRATE_MEMORY=128m NGINX_CPUS=0.5 @@ -74,6 +90,10 @@ POSTGRES_CPUS=2 POSTGRES_MEMORY=1g VALKEY_CPUS=1 VALKEY_MEMORY=256m +S3_CPUS=1 +S3_MEMORY=512m +S3_BOOTSTRAP_CPUS=0.25 +S3_BOOTSTRAP_MEMORY=256m # Пароль локального администратора Grafana. GRAFANA_ADMIN_PASSWORD=local-grafana-password diff --git a/monitoring/grafana/dashboards/messenger.json b/monitoring/grafana/dashboards/messenger.json index f6af0cd2..0478e84b 100644 --- a/monitoring/grafana/dashboards/messenger.json +++ b/monitoring/grafana/dashboards/messenger.json @@ -85,6 +85,50 @@ {"expr": "sum(redis_db_keys)", "legendFormat": "keys", "refId": "A"}, {"expr": "rate(redis_commands_processed_total[1m])", "legendFormat": "commands/s", "refId": "B"} ] + }, + { + "type": "timeseries", "title": "Attachment uploads by result", "id": 15, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 56}, + "targets": [{"expr": "sum by (result) (rate(messenger_attachment_uploads_total[1m]))", "legendFormat": "{{result}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Attachment upload latency p95", "id": 16, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 56}, + "fieldConfig": {"defaults": {"unit": "s"}, "overrides": []}, + "targets": [{"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_upload_duration_seconds_bucket[5m])))", "legendFormat": "p95", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Attachment upload traffic", "id": 17, + "gridPos": {"h": 8, "w": 8, "x": 0, "y": 64}, + "fieldConfig": {"defaults": {"unit": "Bps"}, "overrides": []}, + "targets": [{"expr": "sum(rate(messenger_attachment_upload_bytes_total[1m]))", "legendFormat": "bytes/s", "refId": "A"}] + }, + { + "type": "timeseries", "title": "MinIO objects", "id": 18, + "gridPos": {"h": 8, "w": 8, "x": 8, "y": 64}, + "targets": [{"expr": "sum(minio_cluster_usage_object_total)", "legendFormat": "objects", "refId": "A"}] + }, + { + "type": "timeseries", "title": "MinIO requests and errors", "id": 19, + "gridPos": {"h": 8, "w": 8, "x": 16, "y": 64}, + "targets": [ + {"expr": "sum(rate(minio_s3_requests_total[1m]))", "legendFormat": "requests/s", "refId": "A"}, + {"expr": "sum(rate(minio_s3_requests_errors_total[1m]))", "legendFormat": "errors/s", "refId": "B"} + ] + }, + { + "type": "timeseries", "title": "MinIO availability", "id": 20, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 72}, + "targets": [{"expr": "up{job=\"minio\"}", "legendFormat": "up", "refId": "A"}] + }, + { + "type": "timeseries", "title": "MinIO storage", "id": 21, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 72}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [ + {"expr": "sum(minio_cluster_usage_total_bytes)", "legendFormat": "used", "refId": "A"}, + {"expr": "sum(minio_cluster_capacity_usable_free_bytes)", "legendFormat": "free", "refId": "B"} + ] } ], "refresh": "5s", @@ -93,7 +137,7 @@ "templating": {"list": []}, "time": {"from": "now-15m", "to": "now"}, "timezone": "browser", - "title": "Messenger lab3 overview", + "title": "Messenger lab4 overview", "uid": "messenger-overview", - "version": 2 + "version": 3 } diff --git a/monitoring/prometheus.yml b/monitoring/prometheus.yml index 2c0881ea..83721c48 100644 --- a/monitoring/prometheus.yml +++ b/monitoring/prometheus.yml @@ -1,6 +1,6 @@ global: - scrape_interval: 5s - evaluation_interval: 5s + scrape_interval: 1s + evaluation_interval: 1s scrape_configs: - job_name: messenger @@ -21,3 +21,8 @@ scrape_configs: - job_name: valkey static_configs: - targets: ["valkey-exporter:9121"] + + - job_name: minio + metrics_path: /minio/v2/metrics/cluster + static_configs: + - targets: ["s3:9000"] diff --git a/nginx/nginx.conf b/nginx/nginx.conf index 9dcebe8f..3dde36ac 100644 --- a/nginx/nginx.conf +++ b/nginx/nginx.conf @@ -26,6 +26,7 @@ http { server { listen 8080; + client_max_body_size 11m; location / { proxy_pass http://messenger; @@ -34,6 +35,7 @@ http { proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; + proxy_request_buffering off; proxy_connect_timeout 1s; proxy_send_timeout 10s; diff --git a/scripts/restart.sh b/scripts/restart.sh index cacb5215..a724583d 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -2,7 +2,8 @@ set -eu -docker compose stop nginx api valkey postgres -docker compose start postgres valkey +docker compose stop nginx api valkey postgres s3 +docker compose start postgres valkey s3 +docker compose run --rm s3-bootstrap docker compose run --rm migrate docker compose up -d --wait --wait-timeout 90 diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh index e32e2973..8d1e4369 100755 --- a/scripts/rolling-update.sh +++ b/scripts/rolling-update.sh @@ -34,7 +34,8 @@ for container in $old_containers; do done docker compose build -docker compose up -d postgres valkey +docker compose up -d postgres valkey s3 +docker compose run --rm s3-bootstrap docker compose run --rm migrate if [ "$old_count" -lt 2 ]; then -- 2.54.0 From ad36ab8a9242175a955f96c731ecee2e6f8abe90 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 19:55:52 +0300 Subject: [PATCH 05/15] ci: verify and deploy lab4 --- .gitea/workflows/ci.yml | 93 +++++++++++++++++++++++++++ .gitea/workflows/deploy.yml | 123 ++++++++++++++++++++++++++++++++++++ 2 files changed, 216 insertions(+) create mode 100644 .gitea/workflows/ci.yml create mode 100644 .gitea/workflows/deploy.yml diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 00000000..4f7dc517 --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,93 @@ +name: CI + +on: + pull_request: + branches: [main] + push: + branches: [main] + workflow_dispatch: + +concurrency: + group: ci-${{ github.repository }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + verify: + runs-on: ubuntu-latest + timeout-minutes: 45 + env: + COMPOSE_PROJECT_NAME: mtusi2026lab4-${{ github.run_id }} + API_BIND_ADDRESS: 127.0.0.1:0 + SWAGGER_BIND_ADDRESS: 127.0.0.1:0 + PROMETHEUS_BIND_ADDRESS: 127.0.0.1:0 + GRAFANA_BIND_ADDRESS: 127.0.0.1:0 + steps: + - name: Checkout exact commit + run: | + git init . + git remote add origin https://gitea.privcloud.tech/${{ github.repository }}.git + git fetch --depth=1 origin ${{ github.sha }} + git checkout --detach FETCH_HEAD + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache: false + + - name: Check contract + run: make check + + - name: Validate OpenAPI + run: | + python3 -m venv .venv + .venv/bin/python -m pip install -r requirements-dev.txt + make validate PYTHON=.venv/bin/python + + - name: Check formatting and shell scripts + run: | + test -z "$(gofmt -l cmd internal migrations)" + sh -n infra/minio/bootstrap.sh scripts/restart.sh scripts/rolling-update.sh scripts/stop-one.sh + + - name: Lint + uses: golangci/golangci-lint-action@v7 + with: + version: v2.13.2 + args: --timeout=5m + skip-cache: true + + - name: Unit tests and build + run: | + go test -race ./... + go build ./cmd/... + + - name: Prepare local stack + run: | + cp lab4.env.example .env + docker compose config --quiet + docker compose up -d --build --scale api=2 --wait --wait-timeout 150 + network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q nginx)") + docker network connect "$network" "$HOSTNAME" + printf '%s\n' "$network" > .ci-network + + - name: Integration checks + run: | + set -a + . ./.env + set +a + test "$(curl --noproxy '*' -s -o /dev/null -w '%{http_code}' "http://s3:9000/$S3_BUCKET")" = "403" + make test BASE_URL=http://nginx:8080 + docker compose --profile tests run --rm --build tests + go run ./cmd/dependencycheck -base-url=http://nginx:8080 + make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://nginx:8080 + make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://nginx:8080 + docker compose up -d --scale api=2 --wait --wait-timeout 90 + + - name: Container logs + if: failure() + run: if [ -f .env ]; then docker compose logs --no-color --tail=200; fi + + - name: Stop local stack + if: always() + run: | + if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml new file mode 100644 index 00000000..975fd625 --- /dev/null +++ b/.gitea/workflows/deploy.yml @@ -0,0 +1,123 @@ +name: Deploy production + +on: + workflow_dispatch: + +concurrency: + group: production + cancel-in-progress: false + +jobs: + verify: + name: Verify selected commit + if: github.ref == 'refs/heads/main' + runs-on: ubuntu-latest + timeout-minutes: 45 + env: + COMPOSE_PROJECT_NAME: mtusi2026lab4-deploy-${{ github.run_id }} + API_BIND_ADDRESS: 127.0.0.1:0 + SWAGGER_BIND_ADDRESS: 127.0.0.1:0 + PROMETHEUS_BIND_ADDRESS: 127.0.0.1:0 + GRAFANA_BIND_ADDRESS: 127.0.0.1:0 + steps: + - name: Checkout exact commit + run: | + git init . + git remote add origin https://gitea.privcloud.tech/${{ github.repository }}.git + git fetch --depth=1 origin ${{ github.sha }} + git checkout --detach FETCH_HEAD + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache: false + + - name: Check contract + run: make check + + - name: Validate OpenAPI + run: | + python3 -m venv .venv + .venv/bin/python -m pip install -r requirements-dev.txt + make validate PYTHON=.venv/bin/python + + - name: Check formatting and shell scripts + run: | + test -z "$(gofmt -l cmd internal migrations)" + sh -n infra/minio/bootstrap.sh scripts/restart.sh scripts/rolling-update.sh scripts/stop-one.sh + + - name: Lint + uses: golangci/golangci-lint-action@v7 + with: + version: v2.13.2 + args: --timeout=5m + skip-cache: true + + - name: Unit tests and build + run: | + go test -race ./... + go build ./cmd/... + + - name: Prepare local stack + run: | + cp lab4.env.example .env + docker compose config --quiet + docker compose up -d --build --scale api=2 --wait --wait-timeout 150 + network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q nginx)") + docker network connect "$network" "$HOSTNAME" + printf '%s\n' "$network" > .ci-network + + - name: Integration checks + run: | + set -a + . ./.env + set +a + test "$(curl --noproxy '*' -s -o /dev/null -w '%{http_code}' "http://s3:9000/$S3_BUCKET")" = "403" + make test BASE_URL=http://nginx:8080 + docker compose --profile tests run --rm --build tests + go run ./cmd/dependencycheck -base-url=http://nginx:8080 + make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://nginx:8080 + make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://nginx:8080 + + - name: Container logs + if: failure() + run: if [ -f .env ]; then docker compose logs --no-color --tail=200; fi + + - name: Stop local stack + if: always() + run: | + if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi + + deploy: + name: Deploy selected commit + needs: verify + runs-on: ubuntu-latest + environment: production + env: + DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }} + DEPLOY_USER: ${{ secrets.DEPLOY_USER }} + DEPLOY_SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }} + DEPLOY_KNOWN_HOSTS: ${{ secrets.DEPLOY_KNOWN_HOSTS }} + DEPLOY_SHA: ${{ github.sha }} + steps: + - name: Configure SSH + run: | + umask 077 + mkdir -p ~/.ssh + printf '%s\n' "$DEPLOY_SSH_KEY" > ~/.ssh/id_ed25519 + printf '%s\n' "$DEPLOY_KNOWN_HOSTS" > ~/.ssh/known_hosts + + - name: Deploy and verify + run: | + ssh "$DEPLOY_USER@$DEPLOY_HOST" " + set -eu + cd ~/mtusi2026lab4 + git fetch origin main + git cat-file -e '$DEPLOY_SHA^{commit}' + git reset --hard '$DEPLOY_SHA' + git clean -fd + scripts/rolling-update.sh + test \"\$(git rev-parse HEAD)\" = '$DEPLOY_SHA' + docker compose ps + " -- 2.54.0 From cc4ac1ddd722985bac2cf73de81525bb628f8e6b Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:13:59 +0300 Subject: [PATCH 06/15] refactor: isolate attachment lifecycle --- cmd/lab4experiment/main.go | 38 ++- cmd/messenger/main.go | 200 +------------- internal/bootstrap/migration.go | 25 ++ internal/bootstrap/reconciliation.go | 85 ++++++ internal/bootstrap/reconciliation_test.go | 13 + internal/bootstrap/server.go | 113 ++++++++ internal/config/config.go | 181 ++++++++---- internal/config/config_test.go | 29 ++ internal/messenger/attachment/service.go | 252 +++++++++++++++++ internal/messenger/attachment/service_test.go | 195 +++++++++++++ internal/messenger/attachments.go | 260 ------------------ internal/messenger/httpapi/attachments.go | 164 +++++++++++ internal/messenger/{ => httpapi}/auth.go | 16 +- internal/messenger/{ => httpapi}/errors.go | 2 +- internal/messenger/{ => httpapi}/handlers.go | 33 ++- .../{ => httpapi}/messenger_interface.go | 33 ++- internal/messenger/{ => httpapi}/metrics.go | 2 +- internal/messenger/{ => httpapi}/model.go | 2 +- internal/messenger/{ => httpapi}/request.go | 2 +- internal/messenger/{ => httpapi}/routes.go | 2 +- internal/messenger/{ => httpapi}/server.go | 79 +++--- .../messenger/{ => httpapi}/server_test.go | 217 ++++----------- internal/model/errors.go | 18 ++ internal/model/model.go | 40 ++- internal/objectstore/store.go | 20 +- internal/postgres/attachments.go | 190 +++++++++---- internal/postgres/errors.go | 12 +- internal/postgres/idempotency.go | 17 +- internal/postgres/store_integration_test.go | 10 +- internal/reconcile/reconcile.go | 183 +++++++++--- internal/reconcile/reconcile_test.go | 197 +++++++------ internal/session/session.go | 8 +- migrations/0004_attachment_lifecycle.sql | 16 ++ 33 files changed, 1672 insertions(+), 982 deletions(-) create mode 100644 internal/bootstrap/migration.go create mode 100644 internal/bootstrap/reconciliation.go create mode 100644 internal/bootstrap/reconciliation_test.go create mode 100644 internal/bootstrap/server.go create mode 100644 internal/config/config_test.go create mode 100644 internal/messenger/attachment/service.go create mode 100644 internal/messenger/attachment/service_test.go delete mode 100644 internal/messenger/attachments.go create mode 100644 internal/messenger/httpapi/attachments.go rename internal/messenger/{ => httpapi}/auth.go (86%) rename internal/messenger/{ => httpapi}/errors.go (99%) rename internal/messenger/{ => httpapi}/handlers.go (88%) rename internal/messenger/{ => httpapi}/messenger_interface.go (67%) rename internal/messenger/{ => httpapi}/metrics.go (99%) rename internal/messenger/{ => httpapi}/model.go (96%) rename internal/messenger/{ => httpapi}/request.go (99%) rename internal/messenger/{ => httpapi}/routes.go (98%) rename internal/messenger/{ => httpapi}/server.go (63%) rename internal/messenger/{ => httpapi}/server_test.go (60%) create mode 100644 internal/model/errors.go create mode 100644 migrations/0004_attachment_lifecycle.sql diff --git a/cmd/lab4experiment/main.go b/cmd/lab4experiment/main.go index ed24f21a..e8128b7b 100644 --- a/cmd/lab4experiment/main.go +++ b/cmd/lab4experiment/main.go @@ -240,6 +240,7 @@ type consistencyResult struct { OrphanDeleted bool `json:"orphan_deleted"` UnusedDeleted bool `json:"unused_metadata_deleted"` InUsePreserved bool `json:"in_use_metadata_preserved"` + AbandonedDeleted bool `json:"abandoned_attachment_deleted"` TotalDurationMillis int64 `json:"total_duration_ms"` } @@ -259,7 +260,7 @@ func runConsistency(arguments []string, output io.Writer) error { ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) defer cancel() - settings, err := config.Load() + settings, err := config.LoadReconciliation() if err != nil { return err } @@ -281,7 +282,9 @@ func runConsistency(arguments []string, output io.Writer) error { return err } metadata := postgres.New(pool) - clean, err := reconcile.New(metadata, objects, reconcile.Config{Prefix: "attachments/", PageSize: *pageSize, GraceTime: 0}) + clean, err := reconcile.New(metadata, objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, GraceTime: 0, UnreferencedRetention: time.Hour, + }) if err != nil { return err } @@ -320,7 +323,11 @@ func runConsistency(arguments []string, output io.Writer) error { if err := environment.client.createMessage(ctx, environment.chatID, inUse.ID); err != nil { return err } - keys, err := attachmentKeys(ctx, pool, []string{unused.ID, inUse.ID}) + abandoned, err := environment.client.upload(ctx, environment.chatID, "abandoned.jpg", bytes.NewReader(fixture), int64(len(fixture))) + if err != nil { + return err + } + keys, err := attachmentKeys(ctx, pool, []string{unused.ID, inUse.ID, abandoned.ID}) if err != nil { return err } @@ -336,7 +343,8 @@ func runConsistency(arguments []string, output io.Writer) error { } fresh, err := reconcile.New(metadata, objects, reconcile.Config{ - Prefix: "attachments/", PageSize: *pageSize, GraceTime: time.Hour, Apply: true, + Prefix: "attachments/", PageSize: *pageSize, GraceTime: time.Hour, + UnreferencedRetention: time.Hour, Apply: true, }) if err != nil { return err @@ -346,9 +354,19 @@ func runConsistency(arguments []string, output io.Writer) error { return err } freshPreserved := objectExists(ctx, objects, orphanKey) && - attachmentExists(ctx, pool, unused.ID) && attachmentExists(ctx, pool, inUse.ID) + attachmentExists(ctx, pool, unused.ID) && attachmentExists(ctx, pool, inUse.ID) && + attachmentExists(ctx, pool, abandoned.ID) + if _, err := pool.Exec(ctx, ` + UPDATE attachments + SET created_at = clock_timestamp() - INTERVAL '2 hours', + ready_at = clock_timestamp() - INTERVAL '2 hours' + WHERE id = $1`, abandoned.ID); err != nil { + return fmt.Errorf("age abandoned attachment: %w", err) + } - dryRun, err := reconcile.New(metadata, objects, reconcile.Config{Prefix: "attachments/", PageSize: *pageSize}) + dryRun, err := reconcile.New(metadata, objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, UnreferencedRetention: time.Hour, + }) if err != nil { return err } @@ -357,7 +375,7 @@ func runConsistency(arguments []string, output io.Writer) error { return err } apply, err := reconcile.New(metadata, objects, reconcile.Config{ - Prefix: "attachments/", PageSize: *pageSize, Apply: true, + Prefix: "attachments/", PageSize: *pageSize, UnreferencedRetention: time.Hour, Apply: true, }) if err != nil { return err @@ -376,9 +394,10 @@ func runConsistency(arguments []string, output io.Writer) error { FreshApply: freshRun, DryRun: dryRunResult, Apply: applyResult, RepeatedApply: repeatedResult, FreshPreserved: freshPreserved, OrphanDeleted: !objectExists(ctx, objects, orphanKey), UnusedDeleted: !attachmentExists(ctx, pool, unused.ID), InUsePreserved: attachmentExists(ctx, pool, inUse.ID), + AbandonedDeleted: !attachmentExists(ctx, pool, abandoned.ID) && !objectExists(ctx, objects, keys[abandoned.ID]), TotalDurationMillis: time.Since(started).Milliseconds(), } - if !result.FreshPreserved || !result.OrphanDeleted || !result.UnusedDeleted || !result.InUsePreserved || + if !result.FreshPreserved || !result.OrphanDeleted || !result.UnusedDeleted || !result.InUsePreserved || !result.AbandonedDeleted || repeatedResult.Report.DeletedOrphanObjects != 0 || repeatedResult.Report.DeletedUnreferencedRows != 0 { return fmt.Errorf("unexpected reconciliation result: %+v", result) } @@ -394,7 +413,8 @@ func measuredReconciliation(ctx context.Context, reconciler *reconcile.Reconcile func hasAnomalies(report reconcile.Report) bool { return report.FreshOrphanObjects != 0 || report.OldOrphanObjects != 0 || report.FreshMissingObjects != 0 || report.ReferencedMissingObjects != 0 || - report.OldUnreferencedMetadata != 0 + report.OldUnreferencedMetadata != 0 || report.OldPendingAttachments != 0 || + report.OldUnreferencedAttachments != 0 } func attachmentKeys(ctx context.Context, pool *pgxpool.Pool, ids []string) (map[string]string, error) { diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 90f25b60..036c4987 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -1,215 +1,31 @@ package main import ( - "context" - "encoding/json" - "flag" - "fmt" - "io" + "errors" "log/slog" - "net" - "net/http" "os" - "os/signal" - "syscall" - "time" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/bootstrap" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/logger" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" ) func main() { appLogger := logger.New() if err := run(appLogger, os.Args[1:]); err != nil { - appLogger.Error("server stopped", "error", err) + appLogger.Error("application stopped", "error", err) os.Exit(1) } } func run(logger *slog.Logger, arguments []string) error { if len(arguments) == 0 { - return runServer(logger) + return bootstrap.RunServer(logger) } if len(arguments) == 1 && arguments[0] == "migrate" { - return runMigrations() + return bootstrap.RunMigrations() } - if len(arguments) > 0 && arguments[0] == "reconcile-attachments" { - return runAttachmentReconciliation(arguments[1:], os.Stdout) + if arguments[0] == "reconcile-attachments" { + return bootstrap.RunReconciliation(arguments[1:], os.Stdout) } - return fmt.Errorf("usage: messenger [migrate|reconcile-attachments]") -} - -func runServer(logger *slog.Logger) error { - settings, err := config.Load() - if err != nil { - return err - } - instanceID, err := os.Hostname() - if err != nil { - return err - } - pool, err := database.Open(context.Background(), database.Config{ - URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, - MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, - HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, - }) - if err != nil { - return err - } - defer pool.Close() - sessions, err := session.New(settings.CacheURL) - if err != nil { - return err - } - defer func() { _ = sessions.Close() }() - passwords, err := password.New(password.Config{ - MemoryKiB: settings.PasswordMemoryKiB, Iterations: settings.PasswordIterations, - Parallelism: settings.PasswordParallelism, SaltLength: settings.PasswordSaltLength, - KeyLength: settings.PasswordKeyLength, - }) - if err != nil { - return err - } - objects, err := objectstore.New(objectstore.Config{ - Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, - AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, - UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, - }) - if err != nil { - return err - } - app := messenger.NewServer( - logger, - postgres.New(pool), - sessions, - passwords, - objects, - settings.SessionTTL, - settings.IdempotencyTTL, - settings.RequestTimeout, - instanceID, - settings.SwaggerPort, - settings.AttachmentMaxBytes, - settings.AttachmentMaxPixels, - settings.AttachmentDecodeMemory, - ) - server := &http.Server{ - Addr: settings.Address, - Handler: app.Handler(), - ReadHeaderTimeout: settings.HTTPReadHeaderTimeout, - ReadTimeout: settings.HTTPReadTimeout, - WriteTimeout: settings.HTTPWriteTimeout, - IdleTimeout: settings.HTTPIdleTimeout, - } - listener, err := net.Listen("tcp", server.Addr) - if err != nil { - return err - } - serveResult := make(chan error, 1) - go func() { - serveResult <- server.Serve(listener) - }() - logger.Info("server started", "address", server.Addr) - ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) - defer stop() - select { - case err := <-serveResult: - return err - case <-ctx.Done(): - logger.Info("shutdown requested") - app.SetReady(false) - shutdownCtx, cancel := context.WithTimeout(context.Background(), settings.HTTPShutdownTimeout) - defer cancel() - if err := server.Shutdown(shutdownCtx); err != nil { - _ = server.Close() - return err - } - return nil - } -} - -func runMigrations() error { - settings, err := config.LoadMigration() - if err != nil { - return err - } - pool, err := database.Open(context.Background(), database.Config{ - URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, - MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, - HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, - }) - if err != nil { - return err - } - defer pool.Close() - return database.Migrate(context.Background(), pool, settings.MigrationTimeout) -} - -type reconciliationOutput struct { - Mode string `json:"mode"` - GracePeriod string `json:"grace_period"` - PageSize int `json:"page_size"` - DurationMillis int64 `json:"duration_ms"` - Report reconcile.Report `json:"report"` -} - -func runAttachmentReconciliation(arguments []string, output io.Writer) error { - flags := flag.NewFlagSet("reconcile-attachments", flag.ContinueOnError) - flags.SetOutput(io.Discard) - apply := flags.Bool("apply", false, "apply safe repairs") - gracePeriod := flags.Duration("grace-period", time.Hour, "minimum anomaly age") - pageSize := flags.Int("page-size", 500, "S3 and PostgreSQL page size") - if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { - return fmt.Errorf("usage: messenger reconcile-attachments [--apply] [--grace-period=1h] [--page-size=500]") - } - - settings, err := config.Load() - if err != nil { - return err - } - ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) - defer stop() - pool, err := database.Open(ctx, database.Config{ - URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, - MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, - HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, - }) - if err != nil { - return err - } - defer pool.Close() - objects, err := objectstore.New(objectstore.Config{ - Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, - AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, - UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, - }) - if err != nil { - return err - } - reconciler, err := reconcile.New(postgres.New(pool), objects, reconcile.Config{ - Prefix: "attachments/", PageSize: *pageSize, GraceTime: *gracePeriod, Apply: *apply, - }) - if err != nil { - return err - } - started := time.Now() - report, err := reconciler.Run(ctx) - if err != nil { - return err - } - mode := "dry-run" - if *apply { - mode = "apply" - } - return json.NewEncoder(output).Encode(reconciliationOutput{ - Mode: mode, GracePeriod: gracePeriod.String(), PageSize: *pageSize, - DurationMillis: time.Since(started).Milliseconds(), Report: report, - }) + return errors.New("usage: messenger [migrate|reconcile-attachments]") } diff --git a/internal/bootstrap/migration.go b/internal/bootstrap/migration.go new file mode 100644 index 00000000..3fa1d8f8 --- /dev/null +++ b/internal/bootstrap/migration.go @@ -0,0 +1,25 @@ +package bootstrap + +import ( + "context" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" +) + +func RunMigrations() error { + settings, err := config.LoadMigration() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + return database.Migrate(context.Background(), pool, settings.MigrationTimeout) +} diff --git a/internal/bootstrap/reconciliation.go b/internal/bootstrap/reconciliation.go new file mode 100644 index 00000000..6e6f2d30 --- /dev/null +++ b/internal/bootstrap/reconciliation.go @@ -0,0 +1,85 @@ +package bootstrap + +import ( + "context" + "encoding/json" + "errors" + "flag" + "io" + "os/signal" + "syscall" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile" +) + +type reconciliationOutput struct { + Mode string `json:"mode"` + GracePeriod string `json:"grace_period"` + UnreferencedRetention string `json:"unreferenced_retention"` + PageSize int `json:"page_size"` + DurationMillis int64 `json:"duration_ms"` + Report reconcile.Report `json:"report"` +} + +func RunReconciliation(arguments []string, output io.Writer) error { + flags := flag.NewFlagSet("reconcile-attachments", flag.ContinueOnError) + flags.SetOutput(io.Discard) + apply := flags.Bool("apply", false, "apply safe repairs") + gracePeriod := flags.Duration("grace-period", time.Hour, "minimum anomaly age") + retention := flags.Duration("unreferenced-retention", 24*time.Hour, "retention for ready unreferenced attachments") + pageSize := flags.Int("page-size", 500, "S3 and PostgreSQL page size") + if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { + return errors.New("usage: messenger reconcile-attachments [--apply] [--grace-period=1h] [--unreferenced-retention=24h] [--page-size=500]") + } + if *apply && *gracePeriod <= 0 { + return errors.New("grace-period must be positive in apply mode") + } + settings, err := config.LoadReconciliation() + if err != nil { + return err + } + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + pool, err := database.Open(ctx, database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + objects, err := objectstore.New(objectstore.Config{ + Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, + AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, + UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, + }) + if err != nil { + return err + } + reconciler, err := reconcile.New(postgres.New(pool), objects, reconcile.Config{ + Prefix: "attachments/", PageSize: *pageSize, GraceTime: *gracePeriod, + UnreferencedRetention: *retention, Apply: *apply, + }) + if err != nil { + return err + } + started := time.Now() + report, err := reconciler.Run(ctx) + if err != nil { + return err + } + mode := "dry-run" + if *apply { + mode = "apply" + } + return json.NewEncoder(output).Encode(reconciliationOutput{ + Mode: mode, GracePeriod: gracePeriod.String(), UnreferencedRetention: retention.String(), + PageSize: *pageSize, DurationMillis: time.Since(started).Milliseconds(), Report: report, + }) +} diff --git a/internal/bootstrap/reconciliation_test.go b/internal/bootstrap/reconciliation_test.go new file mode 100644 index 00000000..9a9d3b00 --- /dev/null +++ b/internal/bootstrap/reconciliation_test.go @@ -0,0 +1,13 @@ +package bootstrap + +import ( + "io" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestApplyReconciliationRequiresPositiveGracePeriod(t *testing.T) { + err := RunReconciliation([]string{"--apply", "--grace-period=0"}, io.Discard) + require.EqualError(t, err, "grace-period must be positive in apply mode") +} diff --git a/internal/bootstrap/server.go b/internal/bootstrap/server.go new file mode 100644 index 00000000..e21e5715 --- /dev/null +++ b/internal/bootstrap/server.go @@ -0,0 +1,113 @@ +package bootstrap + +import ( + "context" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "syscall" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/httpapi" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" +) + +func RunServer(logger *slog.Logger) error { + settings, err := config.LoadServer() + if err != nil { + return err + } + instanceID, err := os.Hostname() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), databaseConfig(settings)) + if err != nil { + return err + } + defer pool.Close() + sessions, err := session.New(settings.CacheURL) + if err != nil { + return err + } + defer func() { _ = sessions.Close() }() + passwords, err := password.New(password.Config{ + MemoryKiB: settings.PasswordMemoryKiB, Iterations: settings.PasswordIterations, + Parallelism: settings.PasswordParallelism, SaltLength: settings.PasswordSaltLength, + KeyLength: settings.PasswordKeyLength, + }) + if err != nil { + return err + } + objects, err := objectstore.New(objectStoreConfig(settings)) + if err != nil { + return err + } + repository := postgres.New(pool) + attachments, err := attachment.NewService(logger, repository, objects, attachment.Config{ + MaxBytes: settings.AttachmentMaxBytes, MaxPixels: settings.AttachmentMaxPixels, + BodyMemoryBytes: settings.AttachmentBodyMemory, DecodeMemoryBytes: settings.AttachmentDecodeMemory, + CleanupTimeout: settings.RequestTimeout, + }) + if err != nil { + return err + } + app := httpapi.NewServer(logger, httpapi.Dependencies{ + Users: repository, Chats: repository, Messages: repository, Attachments: attachments, + Sessions: sessions, Passwords: passwords, Database: repository, Objects: objects, + }, httpapi.Config{ + SessionTTL: settings.SessionTTL, IdempotencyTTL: settings.IdempotencyTTL, + RequestTTL: settings.RequestTimeout, InstanceID: instanceID, SwaggerPort: settings.SwaggerPort, + }) + server := &http.Server{ + Addr: settings.Address, Handler: app.Handler(), ReadHeaderTimeout: settings.HTTPReadHeaderTimeout, + ReadTimeout: settings.HTTPReadTimeout, WriteTimeout: settings.HTTPWriteTimeout, + IdleTimeout: settings.HTTPIdleTimeout, + } + listener, err := net.Listen("tcp", server.Addr) + if err != nil { + return err + } + serveResult := make(chan error, 1) + go func() { serveResult <- server.Serve(listener) }() + logger.Info("server started", "address", server.Addr) + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + select { + case err := <-serveResult: + return err + case <-ctx.Done(): + logger.Info("shutdown requested") + app.SetReady(false) + shutdownCtx, cancel := context.WithTimeout(context.Background(), settings.HTTPShutdownTimeout) + defer cancel() + if err := server.Shutdown(shutdownCtx); err != nil { + _ = server.Close() + return err + } + return nil + } +} + +func databaseConfig(settings config.ServerConfig) database.Config { + return database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + } +} + +func objectStoreConfig(settings config.ServerConfig) objectstore.Config { + return objectstore.Config{ + Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket, + AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey, + UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout, + } +} diff --git a/internal/config/config.go b/internal/config/config.go index 2fcfab32..dcf5b9a1 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -11,7 +11,7 @@ import ( "github.com/spf13/viper" ) -type Config struct { +type ServerConfig struct { Address string DatabaseURL string CacheURL string @@ -44,6 +44,7 @@ type Config struct { S3Timeout time.Duration AttachmentMaxBytes int64 AttachmentMaxPixels int64 + AttachmentBodyMemory int64 AttachmentDecodeMemory int64 } @@ -58,6 +59,23 @@ type MigrationConfig struct { MigrationTimeout time.Duration } +type ReconciliationConfig struct { + DatabaseURL string + DBMaxConns int32 + DBMinConns int32 + DBMaxConnectionAge time.Duration + DBMaxConnectionIdle time.Duration + DBHealthCheckPeriod time.Duration + DependencyTimeout time.Duration + S3Endpoint string + S3Region string + S3Bucket string + S3AccessKey string + S3SecretKey string + S3UseTLS bool + S3Timeout time.Duration +} + type databaseConfig struct { url string maxConns int @@ -68,136 +86,129 @@ type databaseConfig struct { dependencyTimeout time.Duration } -func Load() (Config, error) { +type objectStorageConfig struct { + endpoint string + region string + bucket string + accessKey string + secretKey string + useTLS bool + timeout time.Duration +} + +func LoadServer() (ServerConfig, error) { values := viper.New() values.AutomaticEnv() host, err := requiredString(values, "APP_HOST") if err != nil { - return Config{}, err + return ServerConfig{}, err } port, err := requiredPort(values, "APP_PORT") if err != nil { - return Config{}, err + return ServerConfig{}, err } database, err := loadDatabaseConfig(values) if err != nil { - return Config{}, err + return ServerConfig{}, err } cacheURL, err := requiredString(values, "CACHE_URL") if err != nil { - return Config{}, err + return ServerConfig{}, err } store, err := requiredString(values, "SESSION_STORE") if err != nil { - return Config{}, err + return ServerConfig{}, err } if store != "valkey" { - return Config{}, errors.New("SESSION_STORE must be valkey") + return ServerConfig{}, errors.New("SESSION_STORE must be valkey") } sessionTTL, err := seconds(values, "SESSION_TTL_SECONDS", 1, 86400*30) if err != nil { - return Config{}, err + return ServerConfig{}, err } idempotencyTTL, err := seconds(values, "IDEMPOTENCY_TTL_SECONDS", 86400, 86400*30) if err != nil { - return Config{}, err + return ServerConfig{}, err } requestTimeout, err := seconds(values, "REQUEST_TIMEOUT_SECONDS", 1, 300) if err != nil { - return Config{}, err + return ServerConfig{}, err } readHeaderTimeout, err := seconds(values, "HTTP_READ_HEADER_TIMEOUT_SECONDS", 1, 300) if err != nil { - return Config{}, err + return ServerConfig{}, err } readTimeout, err := seconds(values, "HTTP_READ_TIMEOUT_SECONDS", 1, 300) if err != nil { - return Config{}, err + return ServerConfig{}, err } writeTimeout, err := seconds(values, "HTTP_WRITE_TIMEOUT_SECONDS", 1, 300) if err != nil { - return Config{}, err + return ServerConfig{}, err } idleTimeout, err := seconds(values, "HTTP_IDLE_TIMEOUT_SECONDS", 1, 3600) if err != nil { - return Config{}, err + return ServerConfig{}, err } shutdownTimeout, err := seconds(values, "HTTP_SHUTDOWN_TIMEOUT_SECONDS", 1, 300) if err != nil { - return Config{}, err + return ServerConfig{}, err } passwordMemory, err := integer(values, "PASSWORD_MEMORY_KIB", 8*1024, 1024*1024) if err != nil { - return Config{}, err + return ServerConfig{}, err } passwordIterations, err := integer(values, "PASSWORD_ITERATIONS", 1, 20) if err != nil { - return Config{}, err + return ServerConfig{}, err } passwordParallelism, err := integer(values, "PASSWORD_PARALLELISM", 1, 255) if err != nil { - return Config{}, err + return ServerConfig{}, err } passwordSaltLength, err := integer(values, "PASSWORD_SALT_LENGTH", 8, 1024) if err != nil { - return Config{}, err + return ServerConfig{}, err } passwordKeyLength, err := integer(values, "PASSWORD_KEY_LENGTH", 16, 1024) if err != nil { - return Config{}, err + return ServerConfig{}, err } swaggerPort, err := requiredPort(values, "SWAGGER_PORT") if err != nil { - return Config{}, err + return ServerConfig{}, err } - s3Endpoint, err := requiredString(values, "S3_ENDPOINT") + storage, err := loadObjectStorageConfig(values) if err != nil { - return Config{}, err - } - s3Region, err := requiredString(values, "S3_REGION") - if err != nil { - return Config{}, err - } - s3Bucket, err := requiredString(values, "S3_BUCKET") - if err != nil { - return Config{}, err - } - s3AccessKey, err := requiredString(values, "S3_ACCESS_KEY") - if err != nil { - return Config{}, err - } - s3SecretKey, err := requiredString(values, "S3_SECRET_KEY") - if err != nil { - return Config{}, err - } - s3UseTLS, err := boolean(values, "S3_USE_TLS") - if err != nil { - return Config{}, err - } - s3Timeout, err := seconds(values, "S3_TIMEOUT_SECONDS", 1, 300) - if err != nil { - return Config{}, err + return ServerConfig{}, err } attachmentMaxBytes, err := integer(values, "ATTACHMENT_MAX_BYTES", 1, 10*1024*1024) if err != nil { - return Config{}, err + return ServerConfig{}, err } attachmentMaxPixels, err := integer(values, "ATTACHMENT_MAX_PIXELS", 1, 40_000_000) if err != nil { - return Config{}, err + return ServerConfig{}, err + } + attachmentBodyMemory, err := integer(values, "ATTACHMENT_BODY_MEMORY_BYTES", 1, 1024*1024*1024) + if err != nil { + return ServerConfig{}, err + } + if int64(attachmentBodyMemory) < int64(attachmentMaxBytes) { + return ServerConfig{}, fmt.Errorf("ATTACHMENT_BODY_MEMORY_BYTES: must be at least %d", attachmentMaxBytes) } attachmentDecodeMemory, err := integer(values, "ATTACHMENT_DECODE_MEMORY_BYTES", 1, 1024*1024*1024) if err != nil { - return Config{}, err + return ServerConfig{}, err } - minimumDecodeMemory := int64(attachmentMaxBytes) + int64(attachmentMaxPixels)*8 + minimumDecodeMemory := int64(attachmentMaxPixels) * 8 if int64(attachmentDecodeMemory) < minimumDecodeMemory { - return Config{}, fmt.Errorf("ATTACHMENT_DECODE_MEMORY_BYTES: must be at least %d", minimumDecodeMemory) + return ServerConfig{}, fmt.Errorf("ATTACHMENT_DECODE_MEMORY_BYTES: must be at least %d", minimumDecodeMemory) } - return Config{ + return ServerConfig{ Address: net.JoinHostPort(host, port), DatabaseURL: database.url, CacheURL: cacheURL, SessionTTL: sessionTTL, IdempotencyTTL: idempotencyTTL, DBMaxConns: int32(database.maxConns), DBMinConns: int32(database.minConns), @@ -209,9 +220,11 @@ func Load() (Config, error) { HTTPShutdownTimeout: shutdownTimeout, PasswordMemoryKiB: uint32(passwordMemory), PasswordIterations: uint32(passwordIterations), PasswordParallelism: uint8(passwordParallelism), PasswordSaltLength: uint32(passwordSaltLength), PasswordKeyLength: uint32(passwordKeyLength), - SwaggerPort: swaggerPort, S3Endpoint: s3Endpoint, S3Region: s3Region, S3Bucket: s3Bucket, - S3AccessKey: s3AccessKey, S3SecretKey: s3SecretKey, S3UseTLS: s3UseTLS, S3Timeout: s3Timeout, + SwaggerPort: swaggerPort, S3Endpoint: storage.endpoint, S3Region: storage.region, S3Bucket: storage.bucket, + S3AccessKey: storage.accessKey, S3SecretKey: storage.secretKey, + S3UseTLS: storage.useTLS, S3Timeout: storage.timeout, AttachmentMaxBytes: int64(attachmentMaxBytes), AttachmentMaxPixels: int64(attachmentMaxPixels), + AttachmentBodyMemory: int64(attachmentBodyMemory), AttachmentDecodeMemory: int64(attachmentDecodeMemory), }, nil } @@ -235,6 +248,62 @@ func LoadMigration() (MigrationConfig, error) { }, nil } +func LoadReconciliation() (ReconciliationConfig, error) { + values := viper.New() + values.AutomaticEnv() + database, err := loadDatabaseConfig(values) + if err != nil { + return ReconciliationConfig{}, err + } + storage, err := loadObjectStorageConfig(values) + if err != nil { + return ReconciliationConfig{}, err + } + return ReconciliationConfig{ + DatabaseURL: database.url, DBMaxConns: int32(database.maxConns), DBMinConns: int32(database.minConns), + DBMaxConnectionAge: database.maxConnectionAge, DBMaxConnectionIdle: database.maxConnectionIdle, + DBHealthCheckPeriod: database.healthCheckPeriod, DependencyTimeout: database.dependencyTimeout, + S3Endpoint: storage.endpoint, S3Region: storage.region, S3Bucket: storage.bucket, + S3AccessKey: storage.accessKey, S3SecretKey: storage.secretKey, + S3UseTLS: storage.useTLS, S3Timeout: storage.timeout, + }, nil +} + +func loadObjectStorageConfig(values *viper.Viper) (objectStorageConfig, error) { + endpoint, err := requiredString(values, "S3_ENDPOINT") + if err != nil { + return objectStorageConfig{}, err + } + region, err := requiredString(values, "S3_REGION") + if err != nil { + return objectStorageConfig{}, err + } + bucket, err := requiredString(values, "S3_BUCKET") + if err != nil { + return objectStorageConfig{}, err + } + accessKey, err := requiredString(values, "S3_ACCESS_KEY") + if err != nil { + return objectStorageConfig{}, err + } + secretKey, err := requiredString(values, "S3_SECRET_KEY") + if err != nil { + return objectStorageConfig{}, err + } + useTLS, err := boolean(values, "S3_USE_TLS") + if err != nil { + return objectStorageConfig{}, err + } + timeout, err := seconds(values, "S3_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return objectStorageConfig{}, err + } + return objectStorageConfig{ + endpoint: endpoint, region: region, bucket: bucket, accessKey: accessKey, + secretKey: secretKey, useTLS: useTLS, timeout: timeout, + }, nil +} + func loadDatabaseConfig(values *viper.Viper) (databaseConfig, error) { databaseURL, err := requiredString(values, "DATABASE_URL") if err != nil { diff --git a/internal/config/config_test.go b/internal/config/config_test.go new file mode 100644 index 00000000..863746ce --- /dev/null +++ b/internal/config/config_test.go @@ -0,0 +1,29 @@ +package config + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestLoadReconciliationDoesNotRequireServerSettings(t *testing.T) { + values := map[string]string{ + "DATABASE_URL": "postgres://user:password@postgres:5432/messenger", + "DB_MIN_CONNS": "0", "DB_MAX_CONNS": "4", + "DB_MAX_CONNECTION_AGE_SECONDS": "300", "DB_MAX_CONNECTION_IDLE_SECONDS": "60", + "DB_HEALTH_CHECK_SECONDS": "30", "DEPENDENCY_TIMEOUT_SECONDS": "5", + "S3_ENDPOINT": "s3:9000", "S3_REGION": "us-east-1", "S3_BUCKET": "attachments", + "S3_ACCESS_KEY": "application", "S3_SECRET_KEY": "application-secret", + "S3_USE_TLS": "false", "S3_TIMEOUT_SECONDS": "5", + } + for name, value := range values { + t.Setenv(name, value) + } + t.Setenv("APP_HOST", "") + t.Setenv("CACHE_URL", "") + t.Setenv("SWAGGER_PORT", "") + + settings, err := LoadReconciliation() + require.NoError(t, err) + require.Equal(t, "attachments", settings.S3Bucket) +} diff --git a/internal/messenger/attachment/service.go b/internal/messenger/attachment/service.go new file mode 100644 index 00000000..3724d56e --- /dev/null +++ b/internal/messenger/attachment/service.go @@ -0,0 +1,252 @@ +package attachment + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "log/slog" + "mime" + "net/http" + "time" + + "github.com/google/uuid" + "golang.org/x/sync/semaphore" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +type Repository interface { + ChatForUser(context.Context, string, string) (model.Chat, error) + CreatePendingAttachment(context.Context, model.Attachment) (model.Attachment, error) + MarkAttachmentReady(context.Context, string, string) (model.Attachment, error) + DeletePendingAttachment(context.Context, string, string) error + AttachmentByStorage(context.Context, string, string) (model.Attachment, error) + AttachmentForUser(context.Context, string, string) (model.Attachment, error) +} + +type ObjectStore interface { + Put(context.Context, string, string, []byte) error + Get(context.Context, string) (io.ReadCloser, error) + Delete(context.Context, string) error +} + +type Config struct { + MaxBytes int64 + MaxPixels int64 + BodyMemoryBytes int64 + DecodeMemoryBytes int64 + CleanupTimeout time.Duration +} + +type Upload struct { + ChatID string + OwnerID string + Filename string + ContentType string + ContentLength int64 + Body io.Reader +} + +type Content struct { + Attachment model.Attachment + Body io.ReadCloser +} + +type Service struct { + repository Repository + objects ObjectStore + config Config + bodyMemory *semaphore.Weighted + decodeMemory *semaphore.Weighted + logger *slog.Logger +} + +func NewService(logger *slog.Logger, repository Repository, objects ObjectStore, config Config) (*Service, error) { + if config.MaxBytes < 1 || config.MaxPixels < 1 || config.CleanupTimeout <= 0 { + return nil, errors.New("invalid attachment service configuration") + } + if config.BodyMemoryBytes < config.MaxBytes { + return nil, errors.New("attachment body memory must fit one maximum upload") + } + if config.DecodeMemoryBytes < config.MaxPixels*8 { + return nil, errors.New("attachment decode memory must fit one maximum image") + } + return &Service{ + repository: repository, objects: objects, config: config, + bodyMemory: semaphore.NewWeighted(config.BodyMemoryBytes), + decodeMemory: semaphore.NewWeighted(config.DecodeMemoryBytes), logger: logger, + }, nil +} + +func (s *Service) Upload(ctx context.Context, input Upload) (model.Attachment, error) { + if _, err := s.repository.ChatForUser(ctx, input.ChatID, input.OwnerID); err != nil { + return model.Attachment{}, mapDependencyError(err) + } + data, contentType, release, err := s.readImage(input) + if err != nil { + return model.Attachment{}, err + } + defer release() + + attachmentID := uuid.NewString() + objectKey := "attachments/" + uuid.NewString() + "/original" + digest := sha256.Sum256(data) + pending, err := s.repository.CreatePendingAttachment(ctx, model.Attachment{ + ID: attachmentID, ChatID: input.ChatID, OwnerID: input.OwnerID, Filename: input.Filename, + ContentType: contentType, SizeBytes: int64(len(data)), SHA256: hex.EncodeToString(digest[:]), + ObjectKey: objectKey, Status: model.AttachmentPending, + }) + if err != nil { + return model.Attachment{}, mapDependencyError(err) + } + if err := s.objects.Put(ctx, objectKey, contentType, data); err != nil { + s.deletePending(pending.ID, objectKey) + return model.Attachment{}, model.ErrUnavailable + } + attachment, err := s.repository.MarkAttachmentReady(ctx, pending.ID, objectKey) + if err == nil { + return attachment, nil + } + return s.resolveReadyOutcome(pending.ID, objectKey) +} + +func (s *Service) resolveReadyOutcome(attachmentID, objectKey string) (model.Attachment, error) { + cleanupCtx, cancel := context.WithTimeout(context.Background(), s.config.CleanupTimeout) + defer cancel() + stored, err := s.repository.AttachmentByStorage(cleanupCtx, attachmentID, objectKey) + if err == nil && stored.Status == model.AttachmentReady { + return stored, nil + } + if err == nil && stored.Status == model.AttachmentPending { + if deleteErr := s.objects.Delete(cleanupCtx, objectKey); deleteErr != nil { + s.logger.Error("attachment compensation failed", "object_key", objectKey, "error", deleteErr) + return model.Attachment{}, model.ErrUnavailable + } + if deleteErr := s.repository.DeletePendingAttachment(cleanupCtx, attachmentID, objectKey); deleteErr != nil { + s.logger.Error("pending attachment cleanup failed", "attachment_id", attachmentID, "error", deleteErr) + } + return model.Attachment{}, model.ErrUnavailable + } + if errors.Is(err, model.ErrNotFound) { + if deleteErr := s.objects.Delete(cleanupCtx, objectKey); deleteErr != nil { + s.logger.Error("orphan attachment compensation failed", "object_key", objectKey, "error", deleteErr) + } + return model.Attachment{}, model.ErrUnavailable + } + s.logger.Error("attachment outcome is unknown", "attachment_id", attachmentID, "error", err) + return model.Attachment{}, model.ErrUnavailable +} + +func (s *Service) deletePending(attachmentID, objectKey string) { + cleanupCtx, cancel := context.WithTimeout(context.Background(), s.config.CleanupTimeout) + defer cancel() + if err := s.repository.DeletePendingAttachment(cleanupCtx, attachmentID, objectKey); err != nil { + s.logger.Error("pending attachment cleanup failed", "attachment_id", attachmentID, "error", err) + } +} + +func (s *Service) Metadata(ctx context.Context, attachmentID, userID string) (model.Attachment, error) { + attachment, err := s.repository.AttachmentForUser(ctx, attachmentID, userID) + if err != nil { + return model.Attachment{}, mapDependencyError(err) + } + return attachment, nil +} + +func (s *Service) Content(ctx context.Context, attachmentID, userID string) (Content, error) { + attachment, err := s.Metadata(ctx, attachmentID, userID) + if err != nil { + return Content{}, err + } + body, err := s.objects.Get(ctx, attachment.ObjectKey) + if err != nil { + return Content{}, model.ErrUnavailable + } + return Content{Attachment: attachment, Body: body}, nil +} + +func (s *Service) readImage(input Upload) ([]byte, string, func(), error) { + mediaType, parameters, err := mime.ParseMediaType(input.ContentType) + if err != nil || len(parameters) != 0 || mediaType != "image/png" && mediaType != "image/jpeg" { + return nil, "", nil, model.ErrUnsupportedMedia + } + if input.ContentLength > s.config.MaxBytes { + return nil, "", nil, model.ErrPayloadTooLarge + } + reservation := s.config.MaxBytes + if !s.bodyMemory.TryAcquire(reservation) { + return nil, "", nil, model.ErrCapacity + } + releaseBody := func() { s.bodyMemory.Release(reservation) } + data, err := io.ReadAll(io.LimitReader(input.Body, s.config.MaxBytes+1)) + if err != nil { + releaseBody() + return nil, "", nil, model.ErrInvalidInput + } + if int64(len(data)) > s.config.MaxBytes { + releaseBody() + return nil, "", nil, model.ErrPayloadTooLarge + } + if len(data) == 0 { + releaseBody() + return nil, "", nil, model.ErrUnsupportedMedia + } + detected := http.DetectContentType(data) + if detected != mediaType { + releaseBody() + return nil, "", nil, model.ErrUnsupportedMedia + } + imageConfig, format, err := image.DecodeConfig(bytes.NewReader(data)) + if err != nil || imageContentType(format) != mediaType { + releaseBody() + return nil, "", nil, model.ErrUnsupportedMedia + } + pixels := int64(imageConfig.Width) * int64(imageConfig.Height) + if imageConfig.Width < 1 || imageConfig.Height < 1 || pixels > s.config.MaxPixels { + releaseBody() + return nil, "", nil, model.ErrPayloadTooLarge + } + decodeBytes := pixels * 8 + if !s.decodeMemory.TryAcquire(decodeBytes) { + releaseBody() + return nil, "", nil, model.ErrCapacity + } + if _, format, err := image.Decode(bytes.NewReader(data)); err != nil || imageContentType(format) != mediaType { + s.decodeMemory.Release(decodeBytes) + releaseBody() + return nil, "", nil, model.ErrUnsupportedMedia + } + release := func() { + s.decodeMemory.Release(decodeBytes) + releaseBody() + } + return data, mediaType, release, nil +} + +func imageContentType(format string) string { + switch format { + case "png": + return "image/png" + case "jpeg": + return "image/jpeg" + default: + return "" + } +} + +func mapDependencyError(err error) error { + switch { + case errors.Is(err, model.ErrNotFound): + return model.ErrNotFound + case errors.Is(err, model.ErrConflict): + return model.ErrConflict + default: + return model.ErrUnavailable + } +} diff --git a/internal/messenger/attachment/service_test.go b/internal/messenger/attachment/service_test.go new file mode 100644 index 00000000..3c5bb9bd --- /dev/null +++ b/internal/messenger/attachment/service_test.go @@ -0,0 +1,195 @@ +package attachment + +import ( + "bytes" + "context" + "errors" + "image" + "image/color" + "image/png" + "io" + "log/slog" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +func TestUploadLifecycle(t *testing.T) { + data := pngFixture(t, 2, 2) + events := make([]string, 0, 3) + repository := &repositoryStub{events: &events} + objects := &objectStub{events: &events} + service := newTestService(t, repository, objects, 1024, 4) + + result, err := service.Upload(context.Background(), upload(data, "image/png")) + require.NoError(t, err) + require.Equal(t, model.AttachmentReady, result.Status) + require.Equal(t, []string{"pending", "put", "ready"}, events) +} + +func TestUploadValidation(t *testing.T) { + data := pngFixture(t, 2, 2) + tests := []struct { + name string + contentType string + data []byte + maxBytes int64 + maxPixels int64 + want error + }{ + {name: "spoofed MIME", contentType: "image/jpeg", data: data, maxBytes: 1024, maxPixels: 4, want: model.ErrUnsupportedMedia}, + {name: "too many pixels", contentType: "image/png", data: data, maxBytes: 1024, maxPixels: 3, want: model.ErrPayloadTooLarge}, + {name: "too many bytes", contentType: "image/png", data: data, maxBytes: int64(len(data) - 1), maxPixels: 4, want: model.ErrPayloadTooLarge}, + {name: "damaged", contentType: "image/png", data: data[:16], maxBytes: 1024, maxPixels: 4, want: model.ErrUnsupportedMedia}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + service := newTestService(t, &repositoryStub{}, &objectStub{}, test.maxBytes, test.maxPixels) + input := upload(test.data, test.contentType) + _, err := service.Upload(context.Background(), input) + require.ErrorIs(t, err, test.want) + }) + } +} + +func TestUploadUsesSeparateBodyAndDecodeBudgets(t *testing.T) { + data := pngFixture(t, 2, 2) + service := newTestService(t, &repositoryStub{}, &objectStub{}, 1024, 4) + require.True(t, service.bodyMemory.TryAcquire(1024)) + _, err := service.Upload(context.Background(), upload(data, "image/png")) + require.ErrorIs(t, err, model.ErrCapacity) + service.bodyMemory.Release(1024) + + require.True(t, service.decodeMemory.TryAcquire(32)) + _, err = service.Upload(context.Background(), upload(data, "image/png")) + require.ErrorIs(t, err, model.ErrCapacity) + service.decodeMemory.Release(32) +} + +func TestUploadCleansPendingMetadataWhenObjectWriteFails(t *testing.T) { + data := pngFixture(t, 2, 2) + repository := &repositoryStub{} + objects := &objectStub{putErr: errors.New("s3 unavailable")} + service := newTestService(t, repository, objects, 1024, 4) + + _, err := service.Upload(context.Background(), upload(data, "image/png")) + require.ErrorIs(t, err, model.ErrUnavailable) + require.True(t, repository.pendingDeleted) +} + +func TestUploadReturnsCommittedMetadataAfterAmbiguousReadyUpdate(t *testing.T) { + data := pngFixture(t, 2, 2) + repository := &repositoryStub{markErr: errors.New("connection lost"), lookupReady: true} + objects := &objectStub{} + service := newTestService(t, repository, objects, 1024, 4) + + result, err := service.Upload(context.Background(), upload(data, "image/png")) + require.NoError(t, err) + require.Equal(t, model.AttachmentReady, result.Status) + require.False(t, objects.deleted) +} + +func newTestService(t *testing.T, repository Repository, objects ObjectStore, maxBytes, maxPixels int64) *Service { + t.Helper() + service, err := NewService( + slog.New(slog.NewTextHandler(io.Discard, nil)), repository, objects, + Config{ + MaxBytes: maxBytes, MaxPixels: maxPixels, BodyMemoryBytes: maxBytes, + DecodeMemoryBytes: maxPixels * 8, CleanupTimeout: time.Second, + }, + ) + require.NoError(t, err) + return service +} + +func upload(data []byte, contentType string) Upload { + return Upload{ + ChatID: "chat", OwnerID: "owner", Filename: "photo.png", ContentType: contentType, + ContentLength: int64(len(data)), Body: bytes.NewReader(data), + } +} + +type repositoryStub struct { + events *[]string + markErr error + lookupReady bool + pendingDeleted bool + pending model.Attachment +} + +func (*repositoryStub) ChatForUser(context.Context, string, string) (model.Chat, error) { + return model.Chat{}, nil +} + +func (s *repositoryStub) CreatePendingAttachment(_ context.Context, attachment model.Attachment) (model.Attachment, error) { + attachment.Status = model.AttachmentPending + s.pending = attachment + s.record("pending") + return attachment, nil +} + +func (s *repositoryStub) MarkAttachmentReady(context.Context, string, string) (model.Attachment, error) { + if s.markErr != nil { + return model.Attachment{}, s.markErr + } + s.pending.Status = model.AttachmentReady + s.record("ready") + return s.pending, nil +} + +func (s *repositoryStub) DeletePendingAttachment(context.Context, string, string) error { + s.pendingDeleted = true + return nil +} + +func (s *repositoryStub) AttachmentByStorage(context.Context, string, string) (model.Attachment, error) { + if s.lookupReady { + s.pending.Status = model.AttachmentReady + return s.pending, nil + } + return model.Attachment{}, model.ErrNotFound +} + +func (s *repositoryStub) AttachmentForUser(context.Context, string, string) (model.Attachment, error) { + return s.pending, nil +} + +func (s *repositoryStub) record(event string) { + if s.events != nil { + *s.events = append(*s.events, event) + } +} + +type objectStub struct { + events *[]string + putErr error + deleted bool +} + +func (s *objectStub) Put(context.Context, string, string, []byte) error { + if s.events != nil { + *s.events = append(*s.events, "put") + } + return s.putErr +} + +func (*objectStub) Get(context.Context, string) (io.ReadCloser, error) { + return io.NopCloser(bytes.NewReader(nil)), nil +} + +func (s *objectStub) Delete(context.Context, string) error { + s.deleted = true + return nil +} + +func pngFixture(t *testing.T, width, height int) []byte { + t.Helper() + var data bytes.Buffer + value := image.NewRGBA(image.Rect(0, 0, width, height)) + value.Set(0, 0, color.White) + require.NoError(t, png.Encode(&data, value)) + return data.Bytes() +} diff --git a/internal/messenger/attachments.go b/internal/messenger/attachments.go deleted file mode 100644 index f69a5067..00000000 --- a/internal/messenger/attachments.go +++ /dev/null @@ -1,260 +0,0 @@ -package messenger - -import ( - "bytes" - "context" - "crypto/sha256" - "encoding/hex" - "errors" - "image" - _ "image/jpeg" - _ "image/png" - "io" - "mime" - "net/http" - "net/url" - "strconv" - "strings" - "time" - "unicode" - "unicode/utf8" - - "golang.org/x/sync/semaphore" - - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" -) - -func (s *Server) uploadAttachment(w http.ResponseWriter, r *http.Request) *apiError { - started := time.Now() - result := "client_error" - defer func() { - s.metrics.attachmentUploads.WithLabelValues(result).Inc() - s.metrics.attachmentDuration.Observe(time.Since(started).Seconds()) - }() - - if r.Method != http.MethodPost { - return methodNotAllowed(w, http.MethodPost) - } - user, _, authErr := s.authenticate(r) - if authErr != nil { - return authErr - } - chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) - if !valid { - return invalidRequest() - } - filename, valid := attachmentFilename(r.URL.Query()) - if !valid { - return invalidRequest() - } - if _, err := s.messengerStore.ChatForUser(r.Context(), chatID, user.ID); errors.Is(err, postgres.ErrNotFound) { - return notFound() - } else if err != nil { - result = "dependency_error" - return unavailable() - } - data, contentType, readErr := readImage(w, r, s.maxUploadBytes, s.maxImagePixels, s.decodeMemory) - if readErr != nil { - return readErr - } - - attachmentID, err := newID() - if err != nil { - result = "dependency_error" - return internalError() - } - objectID, err := newID() - if err != nil { - result = "dependency_error" - return internalError() - } - objectKey := "attachments/" + objectID + "/original" - if err := s.objects.Put(r.Context(), objectKey, contentType, data); err != nil { - result = "dependency_error" - return unavailable() - } - digest := sha256.Sum256(data) - attachment, err := s.messengerStore.CreateAttachment(r.Context(), model.Attachment{ - ID: attachmentID, ChatID: chatID, OwnerID: user.ID, Filename: filename, - ContentType: contentType, SizeBytes: int64(len(data)), SHA256: hex.EncodeToString(digest[:]), ObjectKey: objectKey, - }) - if err != nil { - result = "dependency_error" - cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), s.requestTTL) - defer cancel() - stored, lookupErr := s.messengerStore.AttachmentByStorage(cleanupCtx, attachmentID, objectKey) - if lookupErr == nil { - result = "success" - s.metrics.attachmentBytes.Add(float64(len(data))) - writeJSON(w, http.StatusCreated, stored) - return nil - } - if !errors.Is(lookupErr, postgres.ErrNotFound) { - s.logger.Error("attachment outcome is unknown", "attachment_id", attachmentID, "error", lookupErr) - return unavailable() - } - if cleanupErr := s.objects.Delete(cleanupCtx, objectKey); cleanupErr != nil { - s.logger.Error("attachment compensation failed", "object_key", objectKey, "error", cleanupErr) - } - if errors.Is(err, postgres.ErrNotFound) { - return notFound() - } - return unavailable() - } - result = "success" - s.metrics.attachmentBytes.Add(float64(len(data))) - writeJSON(w, http.StatusCreated, attachment) - return nil -} - -func attachmentFilename(query url.Values) (string, bool) { - if len(query) != 1 || len(query["filename"]) != 1 { - return "", false - } - filename := query["filename"][0] - length := utf8.RuneCountInString(filename) - if !utf8.ValidString(filename) || strings.TrimSpace(filename) == "" || length < 1 || length > 255 { - return "", false - } - for _, char := range filename { - if char == '/' || char == '\\' || char == 0 || unicode.IsControl(char) { - return "", false - } - } - return filename, true -} - -func readImage( - w http.ResponseWriter, - r *http.Request, - maxBytes int64, - maxPixels int64, - decodeMemory *semaphore.Weighted, -) ([]byte, string, *apiError) { - mediaType, parameters, err := mime.ParseMediaType(r.Header.Get("Content-Type")) - if err != nil || len(parameters) != 0 || mediaType != "image/png" && mediaType != "image/jpeg" { - return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "unsupported image type"} - } - if r.ContentLength > maxBytes { - return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image is too large"} - } - r.Body = http.MaxBytesReader(w, r.Body, maxBytes) - data, err := io.ReadAll(r.Body) - if err != nil { - var tooLarge *http.MaxBytesError - if errors.As(err, &tooLarge) { - return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image is too large"} - } - return nil, "", invalidRequest() - } - if len(data) == 0 { - return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} - } - detected := http.DetectContentType(data) - if detected != mediaType { - return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "content type does not match image"} - } - imageConfig, format, err := image.DecodeConfig(bytes.NewReader(data)) - if err != nil || imageContentType(format) != mediaType { - return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} - } - pixels := int64(imageConfig.Width) * int64(imageConfig.Height) - if imageConfig.Width < 1 || imageConfig.Height < 1 || pixels > maxPixels { - return nil, "", &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image dimensions are too large"} - } - decodeBytes := pixels*8 + int64(len(data)) - if !decodeMemory.TryAcquire(decodeBytes) { - w.Header().Set("Retry-After", "1") - return nil, "", &apiError{http.StatusTooManyRequests, errorCodeRateLimited, "image capacity is temporarily exhausted"} - } - defer decodeMemory.Release(decodeBytes) - if _, format, err := image.Decode(bytes.NewReader(data)); err != nil || imageContentType(format) != mediaType { - return nil, "", &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "invalid image"} - } - return data, mediaType, nil -} - -func imageContentType(format string) string { - switch format { - case "png": - return "image/png" - case "jpeg": - return "image/jpeg" - default: - return "" - } -} - -func (s *Server) attachmentMetadata(w http.ResponseWriter, r *http.Request) *apiError { - if r.Method != http.MethodGet { - return methodNotAllowed(w, http.MethodGet) - } - user, _, authErr := s.authenticate(r) - if authErr != nil { - return authErr - } - attachment, apiErr := s.attachmentForUser(r, user.ID) - if apiErr != nil { - return apiErr - } - writeJSON(w, http.StatusOK, attachment) - return nil -} - -func (s *Server) attachmentContent(w http.ResponseWriter, r *http.Request) *apiError { - if r.Method != http.MethodGet { - return methodNotAllowed(w, http.MethodGet) - } - user, _, authErr := s.authenticate(r) - if authErr != nil { - return authErr - } - if !originalVariant(r.URL.Query()) { - return invalidRequest() - } - attachment, apiErr := s.attachmentForUser(r, user.ID) - if apiErr != nil { - return apiErr - } - content, err := s.objects.Get(r.Context(), attachment.ObjectKey) - if errors.Is(err, objectstore.ErrNotFound) { - return unavailable() - } - if err != nil { - return unavailable() - } - defer func() { _ = content.Close() }() - w.Header().Set("Content-Type", attachment.ContentType) - w.Header().Set("Content-Length", strconv.FormatInt(attachment.SizeBytes, 10)) - w.Header().Set("Content-Disposition", mime.FormatMediaType("inline", map[string]string{"filename": attachment.Filename})) - w.WriteHeader(http.StatusOK) - if _, err := io.Copy(w, content); err != nil { - s.logger.Warn("attachment download interrupted", "attachment_id", attachment.ID, "error", err) - } - return nil -} - -func originalVariant(query url.Values) bool { - if len(query) == 0 { - return true - } - return len(query) == 1 && len(query["variant"]) == 1 && query["variant"][0] == "original" -} - -func (s *Server) attachmentForUser(r *http.Request, userID string) (Attachment, *apiError) { - parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/") - attachmentID, valid := canonicalID(parts[3]) - if !valid { - return Attachment{}, invalidRequest() - } - attachment, err := s.messengerStore.AttachmentForUser(r.Context(), attachmentID, userID) - if errors.Is(err, postgres.ErrNotFound) { - return Attachment{}, notFound() - } - if err != nil { - return Attachment{}, unavailable() - } - return attachment, nil -} diff --git a/internal/messenger/httpapi/attachments.go b/internal/messenger/httpapi/attachments.go new file mode 100644 index 00000000..d579de44 --- /dev/null +++ b/internal/messenger/httpapi/attachments.go @@ -0,0 +1,164 @@ +package httpapi + +import ( + "errors" + "io" + "mime" + "net/http" + "net/url" + "strconv" + "strings" + "time" + "unicode" + "unicode/utf8" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" +) + +func (s *Server) uploadAttachment(w http.ResponseWriter, r *http.Request) *apiError { + started := time.Now() + result := "client_error" + defer func() { + s.metrics.attachmentUploads.WithLabelValues(result).Inc() + s.metrics.attachmentDuration.Observe(time.Since(started).Seconds()) + }() + + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + query, err := url.ParseQuery(r.URL.RawQuery) + if err != nil { + return invalidRequest() + } + filename, valid := attachmentFilename(query) + if !valid { + return invalidRequest() + } + uploaded, err := s.attachments.Upload(r.Context(), attachment.Upload{ + ChatID: chatID, OwnerID: user.ID, Filename: filename, + ContentType: r.Header.Get("Content-Type"), ContentLength: r.ContentLength, Body: r.Body, + }) + if err != nil { + if errors.Is(err, model.ErrCapacity) { + result = "capacity_rejected" + w.Header().Set("Retry-After", "1") + } else if errors.Is(err, model.ErrUnavailable) { + result = "dependency_error" + } + return attachmentError(err) + } + result = "success" + s.metrics.attachmentBytes.Add(float64(uploaded.SizeBytes)) + writeJSON(w, http.StatusCreated, uploaded) + return nil +} + +func attachmentFilename(query url.Values) (string, bool) { + if len(query) != 1 || len(query["filename"]) != 1 { + return "", false + } + filename := query["filename"][0] + length := utf8.RuneCountInString(filename) + if !utf8.ValidString(filename) || strings.TrimSpace(filename) == "" || length < 1 || length > 255 { + return "", false + } + for _, char := range filename { + if char == '/' || char == '\\' || char == 0 || unicode.IsControl(char) { + return "", false + } + } + return filename, true +} + +func (s *Server) attachmentMetadata(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + attachmentID, apiErr := attachmentIDFromRequest(r) + if apiErr != nil { + return apiErr + } + value, err := s.attachments.Metadata(r.Context(), attachmentID, user.ID) + if err != nil { + return attachmentError(err) + } + writeJSON(w, http.StatusOK, value) + return nil +} + +func (s *Server) attachmentContent(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + query, err := url.ParseQuery(r.URL.RawQuery) + if err != nil || !originalVariant(query) { + return invalidRequest() + } + attachmentID, apiErr := attachmentIDFromRequest(r) + if apiErr != nil { + return apiErr + } + content, err := s.attachments.Content(r.Context(), attachmentID, user.ID) + if err != nil { + return attachmentError(err) + } + defer func() { _ = content.Body.Close() }() + w.Header().Set("Content-Type", content.Attachment.ContentType) + w.Header().Set("Content-Length", strconv.FormatInt(content.Attachment.SizeBytes, 10)) + w.Header().Set("Content-Disposition", mime.FormatMediaType("inline", map[string]string{"filename": content.Attachment.Filename})) + w.WriteHeader(http.StatusOK) + if _, err := io.Copy(w, content.Body); err != nil { + s.logger.Warn("attachment download interrupted", "attachment_id", content.Attachment.ID, "error", err) + } + return nil +} + +func originalVariant(query url.Values) bool { + if len(query) == 0 { + return true + } + return len(query) == 1 && len(query["variant"]) == 1 && query["variant"][0] == "original" +} + +func attachmentIDFromRequest(r *http.Request) (string, *apiError) { + parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/") + attachmentID, valid := canonicalID(parts[3]) + if !valid { + return "", invalidRequest() + } + return attachmentID, nil +} + +func attachmentError(err error) *apiError { + switch { + case errors.Is(err, model.ErrNotFound): + return notFound() + case errors.Is(err, model.ErrInvalidInput): + return invalidRequest() + case errors.Is(err, model.ErrUnsupportedMedia): + return &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "unsupported image type"} + case errors.Is(err, model.ErrPayloadTooLarge): + return &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "image is too large"} + case errors.Is(err, model.ErrCapacity): + return &apiError{http.StatusTooManyRequests, errorCodeRateLimited, "image capacity is temporarily exhausted"} + default: + return unavailable() + } +} diff --git a/internal/messenger/auth.go b/internal/messenger/httpapi/auth.go similarity index 86% rename from internal/messenger/auth.go rename to internal/messenger/httpapi/auth.go index 74132223..0f745558 100644 --- a/internal/messenger/auth.go +++ b/internal/messenger/httpapi/auth.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "errors" @@ -7,8 +7,6 @@ import ( "strings" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session" ) func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { @@ -23,8 +21,8 @@ func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError if !ok { return unauthorized() } - credentials, err := s.messengerStore.UserByUsername(r.Context(), username) - if errors.Is(err, postgres.ErrNotFound) { + credentials, err := s.userRepository.UserByUsername(r.Context(), username) + if errors.Is(err, model.ErrNotFound) { if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil { return internalError() } @@ -69,7 +67,7 @@ func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError if authErr != nil { return authErr } - if err := s.sessions.Delete(r.Context(), token); errors.Is(err, session.ErrNotFound) { + if err := s.sessions.Delete(r.Context(), token); errors.Is(err, model.ErrSessionNotFound) { return unauthorized() } else if err != nil { return unavailable() @@ -88,14 +86,14 @@ func (s *Server) authenticate(r *http.Request) (User, string, *apiError) { return User{}, "", unauthorized() } userID, err := s.sessions.UserID(r.Context(), token) - if errors.Is(err, session.ErrNotFound) || errors.Is(err, session.ErrInvalidToken) { + if errors.Is(err, model.ErrSessionNotFound) || errors.Is(err, model.ErrInvalidToken) { return User{}, "", unauthorized() } if err != nil { return User{}, "", unavailable() } - user, err := s.messengerStore.UserByID(r.Context(), userID) - if errors.Is(err, postgres.ErrNotFound) { + user, err := s.userRepository.UserByID(r.Context(), userID) + if errors.Is(err, model.ErrNotFound) { _ = s.sessions.Delete(r.Context(), token) return User{}, "", unauthorized() } diff --git a/internal/messenger/errors.go b/internal/messenger/httpapi/errors.go similarity index 99% rename from internal/messenger/errors.go rename to internal/messenger/httpapi/errors.go index 43923b76..95ffd1c8 100644 --- a/internal/messenger/errors.go +++ b/internal/messenger/httpapi/errors.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "encoding/json" diff --git a/internal/messenger/handlers.go b/internal/messenger/httpapi/handlers.go similarity index 88% rename from internal/messenger/handlers.go rename to internal/messenger/httpapi/handlers.go index 29ec395c..72d307ce 100644 --- a/internal/messenger/handlers.go +++ b/internal/messenger/httpapi/handlers.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "context" @@ -10,7 +10,6 @@ import ( "unicode/utf8" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" ) var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) @@ -32,7 +31,7 @@ func (s *Server) readiness(w http.ResponseWriter, r *http.Request) *apiError { } ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) defer cancel() - if err := s.messengerStore.Ping(ctx); err != nil { + if err := s.database.Ping(ctx); err != nil { return unavailable() } if err := s.sessions.Ping(ctx); err != nil { @@ -64,8 +63,8 @@ func (s *Server) users(w http.ResponseWriter, r *http.Request) *apiError { if err != nil { return internalError() } - user, err := s.messengerStore.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) - if errors.Is(err, postgres.ErrConflict) { + user, err := s.userRepository.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) + if errors.Is(err, model.ErrConflict) { return &apiError{http.StatusConflict, errorCodeConflict, "username already exists"} } if err != nil { @@ -128,8 +127,8 @@ func (s *Server) chats(w http.ResponseWriter, r *http.Request) *apiError { if _, included := members[user.ID]; !included { return invalidRequest() } - chat, err := s.messengerStore.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) - if errors.Is(err, postgres.ErrInvalidMembers) { + chat, err := s.chatRepository.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) + if errors.Is(err, model.ErrInvalidMembers) { return invalidRequest() } if err != nil { @@ -144,8 +143,8 @@ func (s *Server) listChats(w http.ResponseWriter, r *http.Request, user User) *a if err != nil { return err } - items, hasNext, listErr := s.messengerStore.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) - if errors.Is(listErr, postgres.ErrInvalidCursor) { + items, hasNext, listErr := s.chatRepository.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, model.ErrInvalidCursor) { return invalidRequest() } if listErr != nil { @@ -179,8 +178,8 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) *apiError { if !valid { return invalidRequest() } - chat, err := s.messengerStore.ChatForUser(r.Context(), chatID, user.ID) - if errors.Is(err, postgres.ErrNotFound) { + chat, err := s.chatRepository.ChatForUser(r.Context(), chatID, user.ID) + if errors.Is(err, model.ErrNotFound) { return notFound() } if err != nil { @@ -219,13 +218,13 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { if !validMessage(input.Text, input.AttachmentIDs) || !canonicalAttachmentIDs(input.AttachmentIDs) { return invalidRequest() } - message, replay, err := s.messengerStore.CreateMessage( + message, replay, err := s.messageRepository.CreateMessage( r.Context(), chatID, user.ID, input.Text, input.AttachmentIDs, key, s.idempotencyTTL, ) - if errors.Is(err, postgres.ErrNotFound) { + if errors.Is(err, model.ErrNotFound) { return notFound() } - if errors.Is(err, postgres.ErrIdempotencyConflict) { + if errors.Is(err, model.ErrIdempotencyConflict) { return &apiError{http.StatusConflict, errorCodeConflict, "idempotency key conflicts with previous request"} } if err != nil { @@ -269,11 +268,11 @@ func (s *Server) listMessages(w http.ResponseWriter, r *http.Request, user User, if err != nil { return err } - items, hasNext, listErr := s.messengerStore.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) - if errors.Is(listErr, postgres.ErrNotFound) { + items, hasNext, listErr := s.messageRepository.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, model.ErrNotFound) { return notFound() } - if errors.Is(listErr, postgres.ErrInvalidCursor) { + if errors.Is(listErr, model.ErrInvalidCursor) { return invalidRequest() } if listErr != nil { diff --git a/internal/messenger/messenger_interface.go b/internal/messenger/httpapi/messenger_interface.go similarity index 67% rename from internal/messenger/messenger_interface.go rename to internal/messenger/httpapi/messenger_interface.go index 682a10f3..73dbb4a4 100644 --- a/internal/messenger/messenger_interface.go +++ b/internal/messenger/httpapi/messenger_interface.go @@ -1,37 +1,42 @@ -package messenger +package httpapi import ( "context" - "io" "time" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" ) -type MessengerStore interface { - Ping(context.Context) error +type UserRepository interface { CreateUser(context.Context, string, string, string) (model.User, error) UserByID(context.Context, string) (model.User, error) UserByUsername(context.Context, string) (model.UserCredentials, error) +} + +type ChatRepository interface { CreateChat(context.Context, string, []string, string) (model.Chat, error) ChatForUser(context.Context, string, string) (model.Chat, error) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) - CreateMessage(context.Context, string, string, string, []string, string, time.Duration) (model.Message, bool, error) - ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) - CreateAttachment(context.Context, model.Attachment) (model.Attachment, error) - AttachmentByStorage(context.Context, string, string) (model.Attachment, error) - AttachmentForUser(context.Context, string, string) (model.Attachment, error) } -type ObjectStore interface { +type MessageRepository interface { + CreateMessage(context.Context, string, string, string, []string, string, time.Duration) (model.Message, bool, error) + ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) +} + +type AttachmentService interface { + Upload(context.Context, attachment.Upload) (model.Attachment, error) + Metadata(context.Context, string, string) (model.Attachment, error) + Content(context.Context, string, string) (attachment.Content, error) +} + +type HealthChecker interface { Ping(context.Context) error - Put(context.Context, string, string, []byte) error - Get(context.Context, string) (io.ReadCloser, error) - Delete(context.Context, string) error } type SessionStore interface { - Ping(context.Context) error + HealthChecker Create(context.Context, string, time.Duration) (string, time.Time, error) UserID(context.Context, string) (string, error) Delete(context.Context, string) error diff --git a/internal/messenger/metrics.go b/internal/messenger/httpapi/metrics.go similarity index 99% rename from internal/messenger/metrics.go rename to internal/messenger/httpapi/metrics.go index 267d4b7f..1dae064e 100644 --- a/internal/messenger/metrics.go +++ b/internal/messenger/httpapi/metrics.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "net/http" diff --git a/internal/messenger/model.go b/internal/messenger/httpapi/model.go similarity index 96% rename from internal/messenger/model.go rename to internal/messenger/httpapi/model.go index f1509b2c..c1707ce1 100644 --- a/internal/messenger/model.go +++ b/internal/messenger/httpapi/model.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" diff --git a/internal/messenger/request.go b/internal/messenger/httpapi/request.go similarity index 99% rename from internal/messenger/request.go rename to internal/messenger/httpapi/request.go index da264ece..c0a51591 100644 --- a/internal/messenger/request.go +++ b/internal/messenger/httpapi/request.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "bytes" diff --git a/internal/messenger/routes.go b/internal/messenger/httpapi/routes.go similarity index 98% rename from internal/messenger/routes.go rename to internal/messenger/httpapi/routes.go index 25821e70..f2727674 100644 --- a/internal/messenger/routes.go +++ b/internal/messenger/httpapi/routes.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "net/http" diff --git a/internal/messenger/server.go b/internal/messenger/httpapi/server.go similarity index 63% rename from internal/messenger/server.go rename to internal/messenger/httpapi/server.go index 7d654452..9af19cff 100644 --- a/internal/messenger/server.go +++ b/internal/messenger/httpapi/server.go @@ -1,4 +1,4 @@ -package messenger +package httpapi import ( "context" @@ -6,26 +6,44 @@ import ( "net/http" "sync/atomic" "time" - - "golang.org/x/sync/semaphore" ) +type Dependencies struct { + Users UserRepository + Chats ChatRepository + Messages MessageRepository + Attachments AttachmentService + Sessions SessionStore + Passwords PasswordService + Database HealthChecker + Objects HealthChecker +} + +type Config struct { + SessionTTL time.Duration + IdempotencyTTL time.Duration + RequestTTL time.Duration + InstanceID string + SwaggerPort string +} + type Server struct { - messengerStore MessengerStore - sessions SessionStore - passwords PasswordService - objects ObjectStore - sessionTTL time.Duration - idempotencyTTL time.Duration - requestTTL time.Duration - instanceID string - logger *slog.Logger - swaggerPort string - maxUploadBytes int64 - maxImagePixels int64 - decodeMemory *semaphore.Weighted - metrics *metrics - ready atomic.Bool + userRepository UserRepository + chatRepository ChatRepository + messageRepository MessageRepository + attachments AttachmentService + sessions SessionStore + passwords PasswordService + database HealthChecker + objects HealthChecker + sessionTTL time.Duration + idempotencyTTL time.Duration + requestTTL time.Duration + instanceID string + logger *slog.Logger + swaggerPort string + metrics *metrics + ready atomic.Bool } type statusWriter struct { @@ -40,25 +58,16 @@ func (w *statusWriter) WriteHeader(status int) { func NewServer( logger *slog.Logger, - messages MessengerStore, - sessions SessionStore, - passwords PasswordService, - objects ObjectStore, - sessionTTL time.Duration, - idempotencyTTL time.Duration, - requestTTL time.Duration, - instanceID string, - swaggerPort string, - maxUploadBytes int64, - maxImagePixels int64, - decodeMemoryBytes int64, + dependencies Dependencies, + config Config, ) *Server { s := &Server{ - messengerStore: messages, sessions: sessions, passwords: passwords, objects: objects, - sessionTTL: sessionTTL, idempotencyTTL: idempotencyTTL, requestTTL: requestTTL, - instanceID: instanceID, logger: logger, swaggerPort: swaggerPort, - maxUploadBytes: maxUploadBytes, maxImagePixels: maxImagePixels, - decodeMemory: semaphore.NewWeighted(decodeMemoryBytes), metrics: newMetrics(), + userRepository: dependencies.Users, chatRepository: dependencies.Chats, + messageRepository: dependencies.Messages, + attachments: dependencies.Attachments, sessions: dependencies.Sessions, + passwords: dependencies.Passwords, database: dependencies.Database, objects: dependencies.Objects, + sessionTTL: config.SessionTTL, idempotencyTTL: config.IdempotencyTTL, requestTTL: config.RequestTTL, + instanceID: config.InstanceID, logger: logger, swaggerPort: config.SwaggerPort, metrics: newMetrics(), } s.ready.Store(true) return s diff --git a/internal/messenger/server_test.go b/internal/messenger/httpapi/server_test.go similarity index 60% rename from internal/messenger/server_test.go rename to internal/messenger/httpapi/server_test.go index 3440240a..d11d1b2a 100644 --- a/internal/messenger/server_test.go +++ b/internal/messenger/httpapi/server_test.go @@ -1,13 +1,9 @@ -package messenger +package httpapi import ( - "bytes" "context" "errors" "fmt" - "image" - "image/color" - "image/png" "io" "log/slog" "net/http" @@ -17,10 +13,9 @@ import ( "time" "github.com/stretchr/testify/suite" - "golang.org/x/sync/semaphore" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" ) var errDependency = errors.New("dependency unavailable") @@ -39,19 +34,14 @@ func (s *MessengerSuite) SetupTest() { } type messengerStoreStub struct { - pingErr error - userByID model.User - userByIDErr error - credentials model.UserCredentials - credentialsErr error - message model.Message - messageReplay bool - messageErr error - attachment model.Attachment - attachmentErr error - storedAttachment model.Attachment - storedAttachmentExists bool - storedAttachmentErr error + pingErr error + userByID model.User + userByIDErr error + credentials model.UserCredentials + credentialsErr error + message model.Message + messageReplay bool + messageErr error } func (s messengerStoreStub) Ping(context.Context) error { return s.pingErr } @@ -79,50 +69,26 @@ func (s messengerStoreStub) CreateMessage(context.Context, string, string, strin func (messengerStoreStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { return nil, false, nil } -func (s messengerStoreStub) CreateAttachment(context.Context, model.Attachment) (model.Attachment, error) { - return s.attachment, s.attachmentErr -} -func (s messengerStoreStub) AttachmentByStorage(context.Context, string, string) (model.Attachment, error) { - if s.storedAttachmentErr != nil { - return model.Attachment{}, s.storedAttachmentErr - } - if !s.storedAttachmentExists { - return model.Attachment{}, postgres.ErrNotFound - } - return s.storedAttachment, nil -} -func (s messengerStoreStub) AttachmentForUser(context.Context, string, string) (model.Attachment, error) { - return s.attachment, s.attachmentErr -} type objectStoreStub struct { - pingErr error - putErr error - getData []byte - getErr error - deleteErr error - putKey *string - deletedKey *string + pingErr error } func (s objectStoreStub) Ping(context.Context) error { return s.pingErr } -func (s objectStoreStub) Put(_ context.Context, key string, _ string, _ []byte) error { - if s.putKey != nil { - *s.putKey = key - } - return s.putErr + +type attachmentServiceStub struct { + uploaded model.Attachment + err error } -func (s objectStoreStub) Get(context.Context, string) (io.ReadCloser, error) { - if s.getErr != nil { - return nil, s.getErr - } - return io.NopCloser(bytes.NewReader(s.getData)), nil + +func (s attachmentServiceStub) Upload(context.Context, attachment.Upload) (model.Attachment, error) { + return s.uploaded, s.err } -func (s objectStoreStub) Delete(_ context.Context, key string) error { - if s.deletedKey != nil { - *s.deletedKey = key - } - return s.deleteErr +func (s attachmentServiceStub) Metadata(context.Context, string, string) (model.Attachment, error) { + return s.uploaded, s.err +} +func (s attachmentServiceStub) Content(context.Context, string, string) (attachment.Content, error) { + return attachment.Content{Attachment: s.uploaded, Body: io.NopCloser(strings.NewReader("content"))}, s.err } type sessionStub struct { @@ -164,10 +130,7 @@ func (s *MessengerSuite) TestReadinessReturnsUnavailableForDependencyFailure() { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := NewServer( - s.logger, tt.store, tt.sessions, passwordsStub{}, tt.objects, time.Hour, 24*time.Hour, - time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, - ) + server := s.server(tt.store, tt.sessions, passwordsStub{}, tt.objects, attachmentServiceStub{}) response := serveRequest(server, http.MethodGet, "/health/ready", "") if response.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) @@ -300,7 +263,7 @@ func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDiffe t := s.T() store := messengerStoreStub{ userByID: model.User{ID: "user-id"}, - messageErr: fmt.Errorf("create message: %w", postgres.ErrIdempotencyConflict), + messageErr: fmt.Errorf("create message: %w", model.ErrIdempotencyConflict), } server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) request := httptest.NewRequest(http.MethodPost, "/api/v1/chats/00000000-0000-0000-0000-000000000001/messages", strings.NewReader(`{"text":"different"}`)) @@ -314,52 +277,6 @@ func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDiffe } } -func (s *MessengerSuite) TestImageValidation() { - data := testPNG(s.T(), 2, 2) - tests := []struct { - name string - contentType string - data []byte - maxBytes int64 - maxPixels int64 - wantStatus int - }{ - {name: "valid", contentType: "image/png", data: data, maxBytes: 1024, maxPixels: 4}, - {name: "spoofed MIME", contentType: "image/jpeg", data: data, maxBytes: 1024, maxPixels: 4, wantStatus: http.StatusUnsupportedMediaType}, - {name: "too many pixels", contentType: "image/png", data: data, maxBytes: 1024, maxPixels: 3, wantStatus: http.StatusRequestEntityTooLarge}, - {name: "too many bytes", contentType: "image/png", data: data, maxBytes: int64(len(data) - 1), maxPixels: 4, wantStatus: http.StatusRequestEntityTooLarge}, - {name: "damaged", contentType: "image/png", data: data[:16], maxBytes: 1024, maxPixels: 4, wantStatus: http.StatusUnsupportedMediaType}, - } - for _, tt := range tests { - s.Run(tt.name, func() { - request := httptest.NewRequest(http.MethodPost, "/upload", bytes.NewReader(tt.data)) - request.Header.Set("Content-Type", tt.contentType) - response := httptest.NewRecorder() - actual, _, apiErr := readImage( - response, request, tt.maxBytes, tt.maxPixels, semaphore.NewWeighted(384*1024*1024), - ) - if tt.wantStatus == 0 { - s.Require().Nil(apiErr) - s.Equal(tt.data, actual) - return - } - s.Require().NotNil(apiErr) - s.Equal(tt.wantStatus, apiErr.status) - }) - } -} - -func (s *MessengerSuite) TestImageValidationLimitsConcurrentDecodeMemory() { - data := testPNG(s.T(), 2, 2) - request := httptest.NewRequest(http.MethodPost, "/upload", bytes.NewReader(data)) - request.Header.Set("Content-Type", "image/png") - response := httptest.NewRecorder() - _, _, apiErr := readImage(response, request, 1024, 4, semaphore.NewWeighted(1)) - s.Require().NotNil(apiErr) - s.Equal(http.StatusTooManyRequests, apiErr.status) - s.Equal("1", response.Header().Get("Retry-After")) -} - func (s *MessengerSuite) TestAttachmentFilenameValidation() { for _, filename := range []string{"", " ", "../photo.png", "dir\\photo.png", "photo\x00.png", "photo\n.png"} { _, valid := attachmentFilename(map[string][]string{"filename": {filename}}) @@ -370,79 +287,39 @@ func (s *MessengerSuite) TestAttachmentFilenameValidation() { s.Equal("фото.png", filename) } -func (s *MessengerSuite) TestUploadCompensatesObjectWhenMetadataWriteFails() { - var putKey, deletedKey string - store := messengerStoreStub{ - userByID: model.User{ID: "00000000-0000-0000-0000-000000000001"}, - attachmentErr: errDependency, - } - objects := objectStoreStub{putKey: &putKey, deletedKey: &deletedKey} - server := NewServer( - s.logger, store, sessionStub{userID: store.userByID.ID}, passwordsStub{}, objects, - time.Hour, 24*time.Hour, time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, - ) - data := testPNG(s.T(), 2, 2) +func (s *MessengerSuite) TestUploadRejectsMalformedQuery() { + store := messengerStoreStub{userByID: model.User{ID: "user-id"}} + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) request := httptest.NewRequest( http.MethodPost, - "/api/v1/chats/00000000-0000-0000-0000-000000000002/attachments?filename=photo.png", - bytes.NewReader(data), + "/api/v1/chats/00000000-0000-0000-0000-000000000002/attachments?filename=photo.png&junk=%GG", + strings.NewReader("image"), ) request.Header.Set("Authorization", "Bearer valid-token") request.Header.Set("Content-Type", "image/png") response := httptest.NewRecorder() server.Handler().ServeHTTP(response, request) - s.Equal(http.StatusServiceUnavailable, response.Code) - s.NotEmpty(putKey) - s.Equal(putKey, deletedKey) + s.Equal(http.StatusBadRequest, response.Code) } -func (s *MessengerSuite) TestUploadKeepsObjectWhenMetadataCommitSucceeded() { - var deletedKey string - stored := model.Attachment{ - ID: "00000000-0000-0000-0000-000000000003", - ChatID: "00000000-0000-0000-0000-000000000002", - OwnerID: "00000000-0000-0000-0000-000000000001", - Filename: "photo.png", ContentType: "image/png", SizeBytes: 1, SHA256: strings.Repeat("0", 64), - Status: "ready", Variants: []model.Variant{}, CreatedAt: time.Now(), UpdatedAt: time.Now(), - } - store := messengerStoreStub{ - userByID: model.User{ID: stored.OwnerID}, attachmentErr: errDependency, - storedAttachment: stored, storedAttachmentExists: true, - } - server := NewServer( - s.logger, store, sessionStub{userID: stored.OwnerID}, passwordsStub{}, objectStoreStub{deletedKey: &deletedKey}, - time.Hour, 24*time.Hour, time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, - ) - data := testPNG(s.T(), 2, 2) - request := httptest.NewRequest( - http.MethodPost, - "/api/v1/chats/00000000-0000-0000-0000-000000000002/attachments?filename=photo.png", - bytes.NewReader(data), - ) - request.Header.Set("Authorization", "Bearer valid-token") - request.Header.Set("Content-Type", "image/png") - response := httptest.NewRecorder() - server.Handler().ServeHTTP(response, request) - s.Equal(http.StatusCreated, response.Code) - s.Empty(deletedKey) +func (s *MessengerSuite) newTestServer(store messengerStoreStub, sessions SessionStore, passwords PasswordService) *Server { + return s.server(store, sessions, passwords, objectStoreStub{}, attachmentServiceStub{}) } -func testPNG(t *testing.T, width, height int) []byte { - t.Helper() - var data bytes.Buffer - imageData := image.NewRGBA(image.Rect(0, 0, width, height)) - imageData.Set(0, 0, color.White) - if err := png.Encode(&data, imageData); err != nil { - t.Fatalf("encode PNG: %v", err) - } - return data.Bytes() -} - -func (s *MessengerSuite) newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { - return NewServer( - s.logger, messages, sessions, passwords, objectStoreStub{}, time.Hour, 24*time.Hour, - time.Second, "test-instance", "8081", 10*1024*1024, 40_000_000, 384*1024*1024, - ) +func (s *MessengerSuite) server( + store messengerStoreStub, + sessions SessionStore, + passwords PasswordService, + objects objectStoreStub, + attachments AttachmentService, +) *Server { + return NewServer(s.logger, Dependencies{ + Users: store, Chats: store, Messages: store, Attachments: attachments, + Sessions: sessions, Passwords: passwords, Database: store, Objects: objects, + }, Config{ + SessionTTL: time.Hour, IdempotencyTTL: 24 * time.Hour, RequestTTL: time.Second, + InstanceID: "test-instance", SwaggerPort: "8081", + }) } func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { diff --git a/internal/model/errors.go b/internal/model/errors.go new file mode 100644 index 00000000..dbe09f09 --- /dev/null +++ b/internal/model/errors.go @@ -0,0 +1,18 @@ +package model + +import "errors" + +var ( + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrInvalidMembers = errors.New("invalid members") + ErrInvalidCursor = errors.New("invalid cursor") + ErrIdempotencyConflict = errors.New("idempotency conflict") + ErrInvalidToken = errors.New("invalid token") + ErrSessionNotFound = errors.New("session not found") + ErrInvalidInput = errors.New("invalid input") + ErrUnsupportedMedia = errors.New("unsupported media") + ErrPayloadTooLarge = errors.New("payload too large") + ErrCapacity = errors.New("capacity exhausted") + ErrUnavailable = errors.New("dependency unavailable") +) diff --git a/internal/model/model.go b/internal/model/model.go index 1a73c6b7..bc71b978 100644 --- a/internal/model/model.go +++ b/internal/model/model.go @@ -5,6 +5,12 @@ import ( "time" ) +const ( + AttachmentPending = "pending" + AttachmentReady = "ready" + AttachmentDeleting = "deleting" +) + const timestampLayout = "2006-01-02T15:04:05.000000Z" type User struct { @@ -36,19 +42,27 @@ type Message struct { } 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"` - ObjectKey string `json:"-"` + 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"` + ObjectKey string `json:"-"` + ReadyAt *time.Time `json:"-"` + Referenced bool `json:"-"` +} + +type StoredObject struct { + Key string + Size int64 + LastModified time.Time } type Variant struct { diff --git a/internal/objectstore/store.go b/internal/objectstore/store.go index 6cf73bf3..dfcd33b6 100644 --- a/internal/objectstore/store.go +++ b/internal/objectstore/store.go @@ -12,6 +12,8 @@ import ( "github.com/minio/minio-go/v7" "github.com/minio/minio-go/v7/pkg/credentials" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" ) var ErrNotFound = errors.New("object not found") @@ -26,12 +28,6 @@ type Config struct { Timeout time.Duration } -type Object struct { - Key string - Size int64 - LastModified time.Time -} - type Store struct { client *minio.Client bucket string @@ -115,14 +111,14 @@ func (s *Store) Get(ctx context.Context, key string) (io.ReadCloser, error) { return &timeoutReader{ReadCloser: object, cancel: cancel}, nil } -func (s *Store) Stat(ctx context.Context, key string) (Object, error) { +func (s *Store) Stat(ctx context.Context, key string) (model.StoredObject, error) { ctx, cancel := context.WithTimeout(ctx, s.timeout) defer cancel() info, err := s.client.StatObject(ctx, s.bucket, key, minio.StatObjectOptions{}) if err != nil { - return Object{}, objectError("stat S3 object", err) + return model.StoredObject{}, objectError("stat S3 object", err) } - return Object{Key: info.Key, Size: info.Size, LastModified: info.LastModified}, nil + return model.StoredObject{Key: info.Key, Size: info.Size, LastModified: info.LastModified}, nil } func (s *Store) Delete(ctx context.Context, key string) error { @@ -134,19 +130,19 @@ func (s *Store) Delete(ctx context.Context, key string) error { return nil } -func (s *Store) List(ctx context.Context, prefix, after string, limit int) ([]Object, string, error) { +func (s *Store) List(ctx context.Context, prefix, after string, limit int) ([]model.StoredObject, string, error) { if limit < 1 || limit > 1000 { return nil, "", errors.New("object list limit must be between 1 and 1000") } ctx, cancel := context.WithTimeout(ctx, s.timeout) defer cancel() - objects := make([]Object, 0, limit+1) + objects := make([]model.StoredObject, 0, limit+1) options := minio.ListObjectsOptions{Prefix: prefix, Recursive: true, StartAfter: after, MaxKeys: limit + 1} for info := range s.client.ListObjects(ctx, s.bucket, options) { if info.Err != nil { return nil, "", fmt.Errorf("list S3 objects: %w", info.Err) } - objects = append(objects, Object{Key: info.Key, Size: info.Size, LastModified: info.LastModified}) + objects = append(objects, model.StoredObject{Key: info.Key, Size: info.Size, LastModified: info.LastModified}) if len(objects) == limit+1 { cancel() break diff --git a/internal/postgres/attachments.go b/internal/postgres/attachments.go index 59a73eec..ae92171f 100644 --- a/internal/postgres/attachments.go +++ b/internal/postgres/attachments.go @@ -11,90 +11,115 @@ import ( "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" ) -func (s *Store) CreateAttachment(ctx context.Context, attachment model.Attachment) (model.Attachment, error) { - const query = ` +const attachmentColumns = ` + id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + object_key, status, created_at, updated_at, ready_at` + +type rowScanner interface { + Scan(...any) error +} + +func (s *Store) CreatePendingAttachment(ctx context.Context, attachment model.Attachment) (model.Attachment, error) { + query := ` INSERT INTO attachments ( - id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key + id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, ready_at ) - SELECT $1, $2, $3, $4, $5, $6, $7, $8 + SELECT $1, $2, $3, $4, $5, $6, $7, $8, 'pending', NULL WHERE EXISTS ( SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3 ) - RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, - object_key, created_at, updated_at` + RETURNING ` + attachmentColumns - err := s.pool.QueryRow( + err := scanAttachment(s.pool.QueryRow( ctx, query, attachment.ID, attachment.ChatID, attachment.OwnerID, attachment.Filename, attachment.ContentType, attachment.SizeBytes, attachment.SHA256, attachment.ObjectKey, - ).Scan( - &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, - &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, - &attachment.CreatedAt, &attachment.UpdatedAt, - ) + ), &attachment) if errors.Is(err, pgx.ErrNoRows) { return model.Attachment{}, ErrNotFound } if err != nil { - return model.Attachment{}, fmt.Errorf("create attachment: %w", err) + return model.Attachment{}, fmt.Errorf("create pending attachment: %w", err) } - return readyAttachment(attachment), nil + return publicAttachment(attachment), nil +} + +func (s *Store) MarkAttachmentReady(ctx context.Context, attachmentID, objectKey string) (model.Attachment, error) { + query := ` + UPDATE attachments + SET status = 'ready', ready_at = clock_timestamp(), updated_at = clock_timestamp() + WHERE id = $1 AND object_key = $2 AND status = 'pending' + RETURNING ` + attachmentColumns + + var attachment model.Attachment + err := scanAttachment(s.pool.QueryRow(ctx, query, attachmentID, objectKey), &attachment) + if errors.Is(err, pgx.ErrNoRows) { + return model.Attachment{}, ErrNotFound + } + if err != nil { + return model.Attachment{}, fmt.Errorf("mark attachment ready: %w", err) + } + return publicAttachment(attachment), nil +} + +func (s *Store) DeletePendingAttachment(ctx context.Context, attachmentID, objectKey string) error { + const query = `DELETE FROM attachments WHERE id = $1 AND object_key = $2 AND status = 'pending'` + if _, err := s.pool.Exec(ctx, query, attachmentID, objectKey); err != nil { + return fmt.Errorf("delete pending attachment: %w", err) + } + return nil } func (s *Store) AttachmentForUser(ctx context.Context, attachmentID, userID string) (model.Attachment, error) { - const query = ` - SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, - a.sha256, a.object_key, a.created_at, a.updated_at + query := ` + SELECT ` + attachmentColumnsWithAlias("a") + ` FROM attachments a JOIN chat_members member ON member.chat_id = a.chat_id AND member.user_id = $2 - WHERE a.id = $1` + WHERE a.id = $1 AND a.status = 'ready'` var attachment model.Attachment - err := s.pool.QueryRow(ctx, query, attachmentID, userID).Scan( - &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, - &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, - &attachment.CreatedAt, &attachment.UpdatedAt, - ) + err := scanAttachment(s.pool.QueryRow(ctx, query, attachmentID, userID), &attachment) if errors.Is(err, pgx.ErrNoRows) { return model.Attachment{}, ErrNotFound } if err != nil { return model.Attachment{}, fmt.Errorf("get attachment for user: %w", err) } - return readyAttachment(attachment), nil + return publicAttachment(attachment), nil } func (s *Store) AttachmentByStorage(ctx context.Context, attachmentID, objectKey string) (model.Attachment, error) { - const query = ` - SELECT id, chat_id, owner_id, filename, content_type, size_bytes, - sha256, object_key, created_at, updated_at - FROM attachments - WHERE id = $1 AND object_key = $2` + const query = `SELECT ` + attachmentColumns + ` FROM attachments WHERE id = $1 AND object_key = $2` var attachment model.Attachment - err := s.pool.QueryRow(ctx, query, attachmentID, objectKey).Scan( - &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, - &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, - &attachment.CreatedAt, &attachment.UpdatedAt, - ) + err := scanAttachment(s.pool.QueryRow(ctx, query, attachmentID, objectKey), &attachment) if errors.Is(err, pgx.ErrNoRows) { return model.Attachment{}, ErrNotFound } if err != nil { return model.Attachment{}, fmt.Errorf("get attachment by storage: %w", err) } - return readyAttachment(attachment), nil + return publicAttachment(attachment), nil +} + +func (s *Store) AttachmentExistsByObjectKey(ctx context.Context, objectKey string) (bool, error) { + const query = `SELECT EXISTS (SELECT 1 FROM attachments WHERE object_key = $1)` + var exists bool + if err := s.pool.QueryRow(ctx, query, objectKey).Scan(&exists); err != nil { + return false, fmt.Errorf("check attachment by object key: %w", err) + } + return exists, nil } func (s *Store) ListAttachments(ctx context.Context, afterObjectKey string, limit int) ([]model.Attachment, string, error) { if limit < 1 || limit > 1000 { return nil, "", fmt.Errorf("attachment list limit must be between 1 and 1000") } - const query = ` - SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, - object_key, created_at, updated_at - FROM attachments - WHERE object_key > $1 - ORDER BY object_key + query := ` + SELECT ` + attachmentColumnsWithAlias("a") + `, + EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id) + FROM attachments a + WHERE a.object_key > $1 + ORDER BY a.object_key LIMIT $2` rows, err := s.pool.Query(ctx, query, afterObjectKey, limit+1) if err != nil { @@ -104,12 +129,8 @@ func (s *Store) ListAttachments(ctx context.Context, afterObjectKey string, limi attachments, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Attachment](func(row pgx.CollectableRow) (model.Attachment, error) { var attachment model.Attachment - err := row.Scan( - &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, - &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, - &attachment.CreatedAt, &attachment.UpdatedAt, - ) - return readyAttachment(attachment), err + err := scanAttachmentWithReference(row, &attachment) + return publicAttachment(attachment), err })) if err != nil { return nil, "", fmt.Errorf("scan attachments: %w", err) @@ -122,6 +143,15 @@ func (s *Store) ListAttachments(ctx context.Context, afterObjectKey string, limi return attachments, next, nil } +func scanAttachmentWithReference(row rowScanner, attachment *model.Attachment) error { + return row.Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.Status, &attachment.CreatedAt, &attachment.UpdatedAt, &attachment.ReadyAt, + &attachment.Referenced, + ) +} + func (s *Store) AttachmentReferenced(ctx context.Context, attachmentID string) (bool, error) { const query = `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1)` var referenced bool @@ -131,25 +161,71 @@ func (s *Store) AttachmentReferenced(ctx context.Context, attachmentID string) ( return referenced, nil } -func (s *Store) DeleteAttachmentIfUnreferencedBefore( - ctx context.Context, - attachmentID string, - createdBefore time.Time, -) (bool, error) { +func (s *Store) ClaimAttachmentForDeletion(ctx context.Context, attachmentID string, createdBefore time.Time) (bool, error) { + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return false, fmt.Errorf("begin attachment deletion claim: %w", err) + } + defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() + + var createdAt time.Time + err = tx.QueryRow(ctx, `SELECT created_at FROM attachments WHERE id = $1 FOR UPDATE`, attachmentID).Scan(&createdAt) + if errors.Is(err, pgx.ErrNoRows) { + return false, nil + } + if err != nil { + return false, fmt.Errorf("lock attachment deletion candidate: %w", err) + } + if createdAt.After(createdBefore) { + return false, nil + } + var referenced bool + if err := tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1)`, attachmentID).Scan(&referenced); err != nil { + return false, fmt.Errorf("recheck attachment references: %w", err) + } + if referenced { + return false, nil + } + if _, err := tx.Exec(ctx, `UPDATE attachments SET status = 'deleting', updated_at = clock_timestamp() WHERE id = $1`, attachmentID); err != nil { + return false, fmt.Errorf("mark attachment deleting: %w", err) + } + if err := tx.Commit(ctx); err != nil { + return false, fmt.Errorf("commit attachment deletion claim: %w", err) + } + return true, nil +} + +func (s *Store) DeleteAttachmentIfDeleting(ctx context.Context, attachmentID string) (bool, error) { const query = ` DELETE FROM attachments a WHERE a.id = $1 - AND a.created_at <= $2 + AND a.status = 'deleting' AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id)` - result, err := s.pool.Exec(ctx, query, attachmentID, createdBefore) + result, err := s.pool.Exec(ctx, query, attachmentID) if err != nil { - return false, fmt.Errorf("delete old unreferenced attachment: %w", err) + return false, fmt.Errorf("delete claimed attachment: %w", err) } return result.RowsAffected() == 1, nil } -func readyAttachment(attachment model.Attachment) model.Attachment { - attachment.Status = "ready" +func scanAttachment(row rowScanner, attachment *model.Attachment) error { + return row.Scan( + &attachment.ID, &attachment.ChatID, &attachment.OwnerID, &attachment.Filename, + &attachment.ContentType, &attachment.SizeBytes, &attachment.SHA256, &attachment.ObjectKey, + &attachment.Status, &attachment.CreatedAt, &attachment.UpdatedAt, &attachment.ReadyAt, + ) +} + +func attachmentColumnsWithAlias(alias string) string { + return fmt.Sprintf( + "%[1]s.id, %[1]s.chat_id, %[1]s.owner_id, %[1]s.filename, %[1]s.content_type, "+ + "%[1]s.size_bytes, %[1]s.sha256, %[1]s.object_key, %[1]s.status, "+ + "%[1]s.created_at, %[1]s.updated_at, %[1]s.ready_at", + alias, + ) +} + +func publicAttachment(attachment model.Attachment) model.Attachment { attachment.Variants = []model.Variant{} return attachment } diff --git a/internal/postgres/errors.go b/internal/postgres/errors.go index 4e0c3780..a20bdb35 100644 --- a/internal/postgres/errors.go +++ b/internal/postgres/errors.go @@ -1,11 +1,11 @@ package postgres -import "errors" +import "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" var ( - ErrConflict = errors.New("conflict") - ErrNotFound = errors.New("not found") - ErrInvalidMembers = errors.New("invalid members") - ErrInvalidCursor = errors.New("invalid cursor") - ErrIdempotencyConflict = errors.New("idempotency conflict") + ErrConflict = model.ErrConflict + ErrNotFound = model.ErrNotFound + ErrInvalidMembers = model.ErrInvalidMembers + ErrInvalidCursor = model.ErrInvalidCursor + ErrIdempotencyConflict = model.ErrIdempotencyConflict ) diff --git a/internal/postgres/idempotency.go b/internal/postgres/idempotency.go index 5daea350..5e04f875 100644 --- a/internal/postgres/idempotency.go +++ b/internal/postgres/idempotency.go @@ -97,11 +97,20 @@ func attachmentsBelongToChat(ctx context.Context, tx pgx.Tx, chatID string, atta return true, nil } const query = ` - SELECT count(*) + SELECT id FROM attachments - WHERE chat_id = $1 AND id::text = ANY($2)` - var count int - if err := tx.QueryRow(ctx, query, chatID, attachmentIDs).Scan(&count); err != nil { + WHERE chat_id = $1 AND id::text = ANY($2) AND status = 'ready' + FOR UPDATE` + rows, err := tx.Query(ctx, query, chatID, attachmentIDs) + if err != nil { + return false, fmt.Errorf("validate message attachments: %w", err) + } + defer rows.Close() + count := 0 + for rows.Next() { + count++ + } + if err := rows.Err(); err != nil { return false, fmt.Errorf("validate message attachments: %w", err) } return count == len(attachmentIDs), nil diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index 08a9dbc8..71943eac 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -126,7 +126,9 @@ func (s *PostgresSuite) TestAttachmentAccessAndMessageLinking() { ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("a", 64), ObjectKey: "attachments/" + uuid.NewString() + "/original", } - created, err := s.store.CreateAttachment(context.Background(), attachment) + pending, err := s.store.CreatePendingAttachment(context.Background(), attachment) + s.Require().NoError(err) + created, err := s.store.MarkAttachmentReady(context.Background(), pending.ID, pending.ObjectKey) s.Require().NoError(err) s.Equal("ready", created.Status) s.Empty(created.Variants) @@ -152,7 +154,7 @@ func (s *PostgresSuite) TestAttachmentAccessAndMessageLinking() { referenced, err := s.store.AttachmentReferenced(context.Background(), created.ID) s.Require().NoError(err) s.True(referenced) - deleted, err := s.store.DeleteAttachmentIfUnreferencedBefore(context.Background(), created.ID, time.Now().Add(time.Hour)) + deleted, err := s.store.ClaimAttachmentForDeletion(context.Background(), created.ID, time.Now().Add(time.Hour)) s.Require().NoError(err) s.False(deleted) } @@ -161,12 +163,14 @@ func (s *PostgresSuite) TestMessageRejectsAttachmentFromAnotherChat() { owner, firstChatID := createOwnerAndChat(s.T(), s.store) secondChat, err := s.store.CreateChat(context.Background(), "Second", []string{owner.ID}, owner.ID) s.Require().NoError(err) - attachment, err := s.store.CreateAttachment(context.Background(), model.Attachment{ + pending, err := s.store.CreatePendingAttachment(context.Background(), model.Attachment{ ID: uuid.NewString(), ChatID: firstChatID, OwnerID: owner.ID, Filename: "photo.png", ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("b", 64), ObjectKey: "attachments/" + uuid.NewString() + "/original", }) s.Require().NoError(err) + attachment, err := s.store.MarkAttachmentReady(context.Background(), pending.ID, pending.ObjectKey) + s.Require().NoError(err) _, _, err = s.store.CreateMessage( context.Background(), secondChat.ID, owner.ID, "wrong chat", []string{attachment.ID}, uuid.NewString(), 24*time.Hour, ) diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go index 34c74440..d12a138d 100644 --- a/internal/reconcile/reconcile.go +++ b/internal/reconcile/reconcile.go @@ -2,43 +2,50 @@ package reconcile import ( "context" + "errors" "fmt" "time" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" ) type MetadataStore interface { ListAttachments(context.Context, string, int) ([]model.Attachment, string, error) - AttachmentReferenced(context.Context, string) (bool, error) - DeleteAttachmentIfUnreferencedBefore(context.Context, string, time.Time) (bool, error) + AttachmentExistsByObjectKey(context.Context, string) (bool, error) + ClaimAttachmentForDeletion(context.Context, string, time.Time) (bool, error) + DeleteAttachmentIfDeleting(context.Context, string) (bool, error) } type ObjectStore interface { - List(context.Context, string, string, int) ([]objectstore.Object, string, error) + List(context.Context, string, string, int) ([]model.StoredObject, string, error) Delete(context.Context, string) error } type Config struct { - Prefix string - PageSize int - GraceTime time.Duration - Apply bool - Now func() time.Time + Prefix string + PageSize int + GraceTime time.Duration + UnreferencedRetention time.Duration + Apply bool + Now func() time.Time } type Report struct { - MetadataScanned int `json:"metadata_scanned"` - ObjectsScanned int `json:"objects_scanned"` - Consistent int `json:"consistent"` - FreshOrphanObjects int `json:"fresh_orphan_objects"` - OldOrphanObjects int `json:"old_orphan_objects"` - DeletedOrphanObjects int `json:"deleted_orphan_objects"` - FreshMissingObjects int `json:"fresh_missing_objects"` - ReferencedMissingObjects int `json:"referenced_missing_objects"` - OldUnreferencedMetadata int `json:"old_unreferenced_metadata"` - DeletedUnreferencedRows int `json:"deleted_unreferenced_rows"` + MetadataScanned int `json:"metadata_scanned"` + ObjectsScanned int `json:"objects_scanned"` + Consistent int `json:"consistent"` + FreshPendingAttachments int `json:"fresh_pending_attachments"` + OldPendingAttachments int `json:"old_pending_attachments"` + FreshUnreferencedAttachments int `json:"fresh_unreferenced_attachments"` + OldUnreferencedAttachments int `json:"old_unreferenced_attachments"` + DeletedAttachmentObjects int `json:"deleted_attachment_objects"` + FreshOrphanObjects int `json:"fresh_orphan_objects"` + OldOrphanObjects int `json:"old_orphan_objects"` + DeletedOrphanObjects int `json:"deleted_orphan_objects"` + FreshMissingObjects int `json:"fresh_missing_objects"` + ReferencedMissingObjects int `json:"referenced_missing_objects"` + OldUnreferencedMetadata int `json:"old_unreferenced_metadata"` + DeletedUnreferencedRows int `json:"deleted_unreferenced_rows"` } type Reconciler struct { @@ -49,10 +56,13 @@ type Reconciler struct { func New(metadata MetadataStore, objects ObjectStore, config Config) (*Reconciler, error) { if config.PageSize < 1 || config.PageSize > 1000 { - return nil, fmt.Errorf("page size must be between 1 and 1000") + return nil, errors.New("page size must be between 1 and 1000") } if config.GraceTime < 0 { - return nil, fmt.Errorf("grace time must not be negative") + return nil, errors.New("grace time must not be negative") + } + if config.UnreferencedRetention <= 0 { + return nil, errors.New("unreferenced retention must be positive") } if config.Now == nil { config.Now = time.Now @@ -70,28 +80,30 @@ func (r *Reconciler) Run(ctx context.Context) (Report, error) { return Report{}, err } - cutoff := r.config.Now().Add(-r.config.GraceTime) + now := r.config.Now() + anomalyCutoff := now.Add(-r.config.GraceTime) + retentionCutoff := now.Add(-r.config.UnreferencedRetention) var report Report for metadata.current != nil || objects.current != nil { switch { case metadata.current == nil || objects.current != nil && objects.current.Key < metadata.current.ObjectKey: - if err := r.handleOrphanObject(ctx, *objects.current, cutoff, &report); err != nil { + if err := r.handleOrphanObject(ctx, *objects.current, anomalyCutoff, &report); err != nil { return report, err } if err := objects.advance(ctx); err != nil { return report, err } case objects.current == nil || metadata.current.ObjectKey < objects.current.Key: - if err := r.handleMissingObject(ctx, *metadata.current, cutoff, &report); err != nil { + if err := r.handleMissingObject(ctx, *metadata.current, anomalyCutoff, &report); err != nil { return report, err } if err := metadata.advance(ctx); err != nil { return report, err } default: - report.MetadataScanned++ - report.ObjectsScanned++ - report.Consistent++ + if err := r.handlePair(ctx, *metadata.current, retentionCutoff, anomalyCutoff, &report); err != nil { + return report, err + } if err := metadata.advance(ctx); err != nil { return report, err } @@ -103,7 +115,83 @@ func (r *Reconciler) Run(ctx context.Context) (Report, error) { return report, nil } -func (r *Reconciler) handleOrphanObject(ctx context.Context, object objectstore.Object, cutoff time.Time, report *Report) error { +func (r *Reconciler) handlePair( + ctx context.Context, + metadata model.Attachment, + retentionCutoff time.Time, + anomalyCutoff time.Time, + report *Report, +) error { + report.MetadataScanned++ + report.ObjectsScanned++ + report.Consistent++ + switch metadata.Status { + case model.AttachmentPending: + if metadata.CreatedAt.After(anomalyCutoff) { + report.FreshPendingAttachments++ + return nil + } + report.OldPendingAttachments++ + return r.deletePair(ctx, metadata, anomalyCutoff, report) + case model.AttachmentDeleting: + return r.deleteClaimedPair(ctx, metadata, report) + case model.AttachmentReady: + if metadata.Referenced { + return nil + } + age := metadata.CreatedAt + if metadata.ReadyAt != nil { + age = *metadata.ReadyAt + } + if age.After(retentionCutoff) { + report.FreshUnreferencedAttachments++ + return nil + } + report.OldUnreferencedAttachments++ + return r.deletePair(ctx, metadata, retentionCutoff, report) + default: + return fmt.Errorf("attachment %q has unknown status %q", metadata.ID, metadata.Status) + } +} + +func (r *Reconciler) deletePair(ctx context.Context, attachment model.Attachment, cutoff time.Time, report *Report) error { + if !r.config.Apply { + return nil + } + claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, attachment.ID, cutoff) + if err != nil { + return fmt.Errorf("claim attachment %q: %w", attachment.ID, err) + } + if !claimed { + return nil + } + return r.deleteClaimedPair(ctx, attachment, report) +} + +func (r *Reconciler) deleteClaimedPair(ctx context.Context, attachment model.Attachment, report *Report) error { + if !r.config.Apply { + return nil + } + if err := r.objects.Delete(ctx, attachment.ObjectKey); err != nil { + return fmt.Errorf("delete attachment object %q: %w", attachment.ObjectKey, err) + } + report.DeletedAttachmentObjects++ + deleted, err := r.metadata.DeleteAttachmentIfDeleting(ctx, attachment.ID) + if err != nil { + return fmt.Errorf("delete attachment metadata %q: %w", attachment.ID, err) + } + if deleted { + report.DeletedUnreferencedRows++ + } + return nil +} + +func (r *Reconciler) handleOrphanObject( + ctx context.Context, + object model.StoredObject, + cutoff time.Time, + report *Report, +) error { report.ObjectsScanned++ if object.LastModified.After(cutoff) { report.FreshOrphanObjects++ @@ -113,6 +201,13 @@ func (r *Reconciler) handleOrphanObject(ctx context.Context, object objectstore. if !r.config.Apply { return nil } + exists, err := r.metadata.AttachmentExistsByObjectKey(ctx, object.Key) + if err != nil { + return fmt.Errorf("recheck orphan object %q: %w", object.Key, err) + } + if exists { + return nil + } if err := r.objects.Delete(ctx, object.Key); err != nil { return fmt.Errorf("delete orphan object %q: %w", object.Key, err) } @@ -120,17 +215,18 @@ func (r *Reconciler) handleOrphanObject(ctx context.Context, object objectstore. return nil } -func (r *Reconciler) handleMissingObject(ctx context.Context, metadata model.Attachment, cutoff time.Time, report *Report) error { +func (r *Reconciler) handleMissingObject( + ctx context.Context, + metadata model.Attachment, + cutoff time.Time, + report *Report, +) error { report.MetadataScanned++ if metadata.CreatedAt.After(cutoff) { report.FreshMissingObjects++ return nil } - referenced, err := r.metadata.AttachmentReferenced(ctx, metadata.ID) - if err != nil { - return fmt.Errorf("check attachment metadata %q: %w", metadata.ID, err) - } - if referenced { + if metadata.Referenced { report.ReferencedMissingObjects++ return nil } @@ -138,9 +234,16 @@ func (r *Reconciler) handleMissingObject(ctx context.Context, metadata model.Att if !r.config.Apply { return nil } - deleted, err := r.metadata.DeleteAttachmentIfUnreferencedBefore(ctx, metadata.ID, cutoff) + claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, metadata.ID, cutoff) if err != nil { - return fmt.Errorf("delete attachment metadata %q: %w", metadata.ID, err) + return fmt.Errorf("claim missing attachment metadata %q: %w", metadata.ID, err) + } + if !claimed { + return nil + } + deleted, err := r.metadata.DeleteAttachmentIfDeleting(ctx, metadata.ID) + if err != nil { + return fmt.Errorf("delete missing attachment metadata %q: %w", metadata.ID, err) } if deleted { report.DeletedUnreferencedRows++ @@ -186,7 +289,7 @@ func (i *metadataIterator) advance(ctx context.Context) error { i.after = next i.done = next == "" if len(page) == 0 && !i.done { - return fmt.Errorf("metadata page is empty but has continuation") + return errors.New("metadata page is empty but has continuation") } } } @@ -196,9 +299,9 @@ type objectIterator struct { prefix string pageSize int after string - page []objectstore.Object + page []model.StoredObject index int - current *objectstore.Object + current *model.StoredObject done bool } @@ -230,7 +333,7 @@ func (i *objectIterator) advance(ctx context.Context) error { i.after = next i.done = next == "" if len(page) == 0 && !i.done { - return fmt.Errorf("object page is empty but has continuation") + return errors.New("object page is empty but has continuation") } } } diff --git a/internal/reconcile/reconcile_test.go b/internal/reconcile/reconcile_test.go index defe3cde..221ac0c4 100644 --- a/internal/reconcile/reconcile_test.go +++ b/internal/reconcile/reconcile_test.go @@ -9,88 +9,133 @@ import ( "github.com/stretchr/testify/require" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" ) -func TestReconcilerDryRunAndApply(t *testing.T) { - now := time.Date(2026, 10, 2, 12, 0, 0, 0, time.UTC) - metadata := &metadataStub{items: []model.Attachment{ - {ID: "consistent", ObjectKey: "attachments/consistent", CreatedAt: now.Add(-time.Hour)}, - {ID: "fresh-missing", ObjectKey: "attachments/fresh-missing", CreatedAt: now.Add(-time.Minute)}, - {ID: "old-missing", ObjectKey: "attachments/old-missing", CreatedAt: now.Add(-time.Hour)}, - {ID: "referenced-missing", ObjectKey: "attachments/referenced-missing", CreatedAt: now.Add(-time.Hour)}, - }, referenced: map[string]bool{"referenced-missing": true}} - objects := &objectStub{items: []objectstore.Object{ - {Key: "attachments/consistent", LastModified: now.Add(-time.Hour)}, - {Key: "attachments/fresh-orphan", LastModified: now.Add(-time.Minute)}, - {Key: "attachments/old-orphan", LastModified: now.Add(-time.Hour)}, +func TestReconcilerLifecycleAndRepeat(t *testing.T) { + now := time.Date(2026, 10, 9, 12, 0, 0, 0, time.UTC) + old := now.Add(-48 * time.Hour) + fresh := now.Add(-10 * time.Minute) + metadata := &metadataStub{items: map[string]model.Attachment{ + "attachments/a/original": attachment("a", "attachments/a/original", model.AttachmentReady, old, false), + "attachments/b/original": attachment("b", "attachments/b/original", model.AttachmentReady, old, true), + "attachments/c/original": attachment("c", "attachments/c/original", model.AttachmentPending, old, false), + "attachments/d/original": attachment("d", "attachments/d/original", model.AttachmentReady, fresh, false), + "attachments/missing/original": attachment("missing", "attachments/missing/original", model.AttachmentReady, old, false), }} - - dryRun, err := New(metadata, objects, Config{ - Prefix: "attachments/", PageSize: 2, GraceTime: 10 * time.Minute, Now: func() time.Time { return now }, + objects := &objectStub{items: map[string]model.StoredObject{ + "attachments/a/original": {Key: "attachments/a/original", LastModified: old}, + "attachments/b/original": {Key: "attachments/b/original", LastModified: old}, + "attachments/c/original": {Key: "attachments/c/original", LastModified: old}, + "attachments/d/original": {Key: "attachments/d/original", LastModified: fresh}, + "attachments/orphan/original": {Key: "attachments/orphan/original", LastModified: old}, + }} + reconciler, err := New(metadata, objects, Config{ + Prefix: "attachments/", PageSize: 2, GraceTime: time.Hour, + UnreferencedRetention: 24 * time.Hour, Apply: true, Now: func() time.Time { return now }, }) require.NoError(t, err) - report, err := dryRun.Run(context.Background()) - require.NoError(t, err) - require.Equal(t, Report{ - MetadataScanned: 4, ObjectsScanned: 3, Consistent: 1, - FreshOrphanObjects: 1, OldOrphanObjects: 1, FreshMissingObjects: 1, - ReferencedMissingObjects: 1, OldUnreferencedMetadata: 1, - }, report) - require.Empty(t, metadata.deleted) - require.Empty(t, objects.deleted) - apply, err := New(metadata, objects, Config{ - Prefix: "attachments/", PageSize: 2, GraceTime: 10 * time.Minute, Apply: true, - Now: func() time.Time { return now }, - }) - require.NoError(t, err) - report, err = apply.Run(context.Background()) + report, err := reconciler.Run(context.Background()) require.NoError(t, err) + require.Equal(t, 1, report.OldPendingAttachments) + require.Equal(t, 1, report.OldUnreferencedAttachments) + require.Equal(t, 1, report.FreshUnreferencedAttachments) require.Equal(t, 1, report.DeletedOrphanObjects) - require.Equal(t, 1, report.DeletedUnreferencedRows) - require.Equal(t, []string{"old-missing"}, metadata.deleted) - require.Equal(t, []string{"attachments/old-orphan"}, objects.deleted) + require.Equal(t, 2, report.DeletedAttachmentObjects) + require.Equal(t, 3, report.DeletedUnreferencedRows) + require.Contains(t, metadata.items, "attachments/b/original") + require.Contains(t, metadata.items, "attachments/d/original") + require.NotContains(t, metadata.items, "attachments/a/original") + require.NotContains(t, metadata.items, "attachments/c/original") + require.NotContains(t, metadata.items, "attachments/missing/original") + require.NotContains(t, objects.items, "attachments/orphan/original") - report, err = apply.Run(context.Background()) + repeated, err := reconciler.Run(context.Background()) + require.NoError(t, err) + require.Zero(t, repeated.DeletedOrphanObjects) + require.Zero(t, repeated.DeletedAttachmentObjects) + require.Zero(t, repeated.DeletedUnreferencedRows) +} + +func TestReconcilerRechecksOrphanBeforeDelete(t *testing.T) { + now := time.Now().UTC() + metadata := &metadataStub{items: map[string]model.Attachment{}, appeared: map[string]bool{"attachments/a/original": true}} + objects := &objectStub{items: map[string]model.StoredObject{ + "attachments/a/original": {Key: "attachments/a/original", LastModified: now.Add(-time.Hour)}, + }} + reconciler, err := New(metadata, objects, Config{ + Prefix: "attachments/", PageSize: 1, GraceTime: time.Minute, + UnreferencedRetention: time.Hour, Apply: true, Now: func() time.Time { return now }, + }) + require.NoError(t, err) + + report, err := reconciler.Run(context.Background()) require.NoError(t, err) require.Zero(t, report.DeletedOrphanObjects) - require.Zero(t, report.DeletedUnreferencedRows) - require.Equal(t, 1, report.FreshOrphanObjects) - require.Equal(t, 1, report.FreshMissingObjects) - require.Equal(t, 1, report.ReferencedMissingObjects) + require.Contains(t, objects.items, "attachments/a/original") +} + +func TestNewRejectsInvalidRetention(t *testing.T) { + _, err := New(&metadataStub{}, &objectStub{}, Config{PageSize: 1}) + require.Error(t, err) +} + +func attachment(id, key, status string, createdAt time.Time, referenced bool) model.Attachment { + readyAt := createdAt + return model.Attachment{ + ID: id, ObjectKey: key, Status: status, CreatedAt: createdAt, + ReadyAt: &readyAt, Referenced: referenced, + } } type metadataStub struct { - items []model.Attachment - referenced map[string]bool - deleted []string + items map[string]model.Attachment + appeared map[string]bool } func (s *metadataStub) ListAttachments(_ context.Context, after string, limit int) ([]model.Attachment, string, error) { - items := append([]model.Attachment(nil), s.items...) - sort.Slice(items, func(i, j int) bool { return items[i].ObjectKey < items[j].ObjectKey }) - start := 0 - for start < len(items) && items[start].ObjectKey <= after { - start++ + keys := make([]string, 0, len(s.items)) + for key := range s.items { + if key > after { + keys = append(keys, key) + } } - end := min(start+limit, len(items)) + sort.Strings(keys) var next string - if end < len(items) { - next = items[end-1].ObjectKey + if len(keys) > limit { + keys = keys[:limit] + next = keys[len(keys)-1] } - return items[start:end], next, nil + items := make([]model.Attachment, 0, len(keys)) + for _, key := range keys { + items = append(items, s.items[key]) + } + return items, next, nil } -func (s *metadataStub) AttachmentReferenced(_ context.Context, id string) (bool, error) { - return s.referenced[id], nil +func (s *metadataStub) AttachmentExistsByObjectKey(_ context.Context, key string) (bool, error) { + if s.appeared[key] { + return true, nil + } + _, exists := s.items[key] + return exists, nil } -func (s *metadataStub) DeleteAttachmentIfUnreferencedBefore(_ context.Context, id string, _ time.Time) (bool, error) { - for index, item := range s.items { - if item.ID == id && !s.referenced[id] { - s.items = append(s.items[:index], s.items[index+1:]...) - s.deleted = append(s.deleted, id) +func (s *metadataStub) ClaimAttachmentForDeletion(_ context.Context, id string, cutoff time.Time) (bool, error) { + for key, item := range s.items { + if item.ID == id && !item.CreatedAt.After(cutoff) && !item.Referenced { + item.Status = model.AttachmentDeleting + s.items[key] = item + return true, nil + } + } + return false, nil +} + +func (s *metadataStub) DeleteAttachmentIfDeleting(_ context.Context, id string) (bool, error) { + for key, item := range s.items { + if item.ID == id && item.Status == model.AttachmentDeleting && !item.Referenced { + delete(s.items, key) return true, nil } } @@ -98,32 +143,30 @@ func (s *metadataStub) DeleteAttachmentIfUnreferencedBefore(_ context.Context, i } type objectStub struct { - items []objectstore.Object - deleted []string + items map[string]model.StoredObject } -func (s *objectStub) List(_ context.Context, _ string, after string, limit int) ([]objectstore.Object, string, error) { - items := append([]objectstore.Object(nil), s.items...) - sort.Slice(items, func(i, j int) bool { return items[i].Key < items[j].Key }) - start := 0 - for start < len(items) && items[start].Key <= after { - start++ +func (s *objectStub) List(_ context.Context, prefix, after string, limit int) ([]model.StoredObject, string, error) { + keys := make([]string, 0, len(s.items)) + for key := range s.items { + if key > after && len(key) >= len(prefix) && key[:len(prefix)] == prefix { + keys = append(keys, key) + } } - end := min(start+limit, len(items)) + sort.Strings(keys) var next string - if end < len(items) { - next = items[end-1].Key + if len(keys) > limit { + keys = keys[:limit] + next = keys[len(keys)-1] } - return items[start:end], next, nil + items := make([]model.StoredObject, 0, len(keys)) + for _, key := range keys { + items = append(items, s.items[key]) + } + return items, next, nil } func (s *objectStub) Delete(_ context.Context, key string) error { - for index, item := range s.items { - if item.Key == key { - s.items = append(s.items[:index], s.items[index+1:]...) - s.deleted = append(s.deleted, key) - return nil - } - } + delete(s.items, key) return nil } diff --git a/internal/session/session.go b/internal/session/session.go index 4f40fc53..35fa628d 100644 --- a/internal/session/session.go +++ b/internal/session/session.go @@ -13,6 +13,8 @@ import ( "time" "github.com/valkey-io/valkey-go" + + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" ) const ( @@ -21,12 +23,12 @@ const ( ) var ( - ErrNotFound = errors.New("session not found") - ErrInvalidToken = errors.New("invalid session token") + ErrNotFound = model.ErrSessionNotFound + ErrInvalidToken = model.ErrInvalidToken ErrInvalidRecord = errors.New("invalid session record") ErrInvalidTTL = errors.New("invalid session TTL") ErrTokenGeneration = errors.New("session token generation failed") - ErrStore = errors.New("session store failure") + ErrStore = model.ErrUnavailable ) type record struct { diff --git a/migrations/0004_attachment_lifecycle.sql b/migrations/0004_attachment_lifecycle.sql new file mode 100644 index 00000000..1596c99d --- /dev/null +++ b/migrations/0004_attachment_lifecycle.sql @@ -0,0 +1,16 @@ +ALTER TABLE attachments + ADD COLUMN status TEXT NOT NULL DEFAULT 'ready', + ADD COLUMN ready_at TIMESTAMPTZ DEFAULT clock_timestamp(); + +UPDATE attachments +SET ready_at = created_at; + +ALTER TABLE attachments + ADD CONSTRAINT attachments_status CHECK (status IN ('pending', 'ready', 'deleting')), + ADD CONSTRAINT attachments_ready_at CHECK ( + (status = 'pending' AND ready_at IS NULL) OR + (status IN ('ready', 'deleting') AND ready_at IS NOT NULL) + ); + +CREATE INDEX attachments_status_created_at_object_key_idx + ON attachments (status, created_at, object_key); -- 2.54.0 From f8c31de7c07138af41db9ad59bc445b67d785747 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:14:11 +0300 Subject: [PATCH 07/15] fix: deploy verified images atomically --- .gitea/workflows/ci.yml | 8 +-- .gitea/workflows/deploy.yml | 81 +++++++++++++++++++-- compose.yaml | 24 +++++++ deploy/compose.images.yaml | 24 +++++++ lab4.env.example | 1 + scripts/rolling-update.sh | 137 +++++++++++++++++++++++++++++------- 6 files changed, 238 insertions(+), 37 deletions(-) create mode 100644 deploy/compose.images.yaml diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 4f7dc517..a3a24098 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -65,9 +65,8 @@ jobs: cp lab4.env.example .env docker compose config --quiet docker compose up -d --build --scale api=2 --wait --wait-timeout 150 - network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q nginx)") - docker network connect "$network" "$HOSTNAME" - printf '%s\n' "$network" > .ci-network + docker network connect "${COMPOSE_PROJECT_NAME}_application" "$HOSTNAME" + docker network connect "${COMPOSE_PROJECT_NAME}_data" "$HOSTNAME" - name: Integration checks run: | @@ -89,5 +88,6 @@ jobs: - name: Stop local stack if: always() run: | - if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + docker network disconnect "${COMPOSE_PROJECT_NAME}_application" "$HOSTNAME" 2>/dev/null || true + docker network disconnect "${COMPOSE_PROJECT_NAME}_data" "$HOSTNAME" 2>/dev/null || true if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml index 975fd625..bcf4cf70 100644 --- a/.gitea/workflows/deploy.yml +++ b/.gitea/workflows/deploy.yml @@ -13,12 +13,28 @@ jobs: if: github.ref == 'refs/heads/main' runs-on: ubuntu-latest timeout-minutes: 45 + outputs: + api_image: ${{ steps.publish.outputs.api_image }} + nginx_image: ${{ steps.publish.outputs.nginx_image }} + swagger_image: ${{ steps.publish.outputs.swagger_image }} + prometheus_image: ${{ steps.publish.outputs.prometheus_image }} + grafana_image: ${{ steps.publish.outputs.grafana_image }} + s3_image: ${{ steps.publish.outputs.s3_image }} + s3_bootstrap_image: ${{ steps.publish.outputs.s3_bootstrap_image }} env: COMPOSE_PROJECT_NAME: mtusi2026lab4-deploy-${{ github.run_id }} + COMPOSE_FILE: compose.yaml:deploy/compose.images.yaml API_BIND_ADDRESS: 127.0.0.1:0 SWAGGER_BIND_ADDRESS: 127.0.0.1:0 PROMETHEUS_BIND_ADDRESS: 127.0.0.1:0 GRAFANA_BIND_ADDRESS: 127.0.0.1:0 + API_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-api:${{ github.sha }} + NGINX_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-nginx:${{ github.sha }} + SWAGGER_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-swagger:${{ github.sha }} + PROMETHEUS_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-prometheus:${{ github.sha }} + GRAFANA_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-grafana:${{ github.sha }} + S3_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-minio:${{ github.sha }} + S3_BOOTSTRAP_IMAGE: gitea.privcloud.tech/${{ github.repository_owner }}/mtusi2026lab4-minio-client:${{ github.sha }} steps: - name: Checkout exact commit run: | @@ -63,9 +79,8 @@ jobs: cp lab4.env.example .env docker compose config --quiet docker compose up -d --build --scale api=2 --wait --wait-timeout 150 - network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q nginx)") - docker network connect "$network" "$HOSTNAME" - printf '%s\n' "$network" > .ci-network + docker network connect "${COMPOSE_PROJECT_NAME}_application" "$HOSTNAME" + docker network connect "${COMPOSE_PROJECT_NAME}_data" "$HOSTNAME" - name: Integration checks run: | @@ -79,6 +94,33 @@ jobs: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://nginx:8080 make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://nginx:8080 + - name: Publish verified images + id: publish + env: + REGISTRY_USERNAME: ${{ secrets.REGISTRY_USERNAME }} + REGISTRY_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }} + run: | + printf '%s' "$REGISTRY_PASSWORD" | docker login gitea.privcloud.tech --username "$REGISTRY_USERNAME" --password-stdin + + publish() { + output=$1 + image=$2 + push_output=$(docker push "$image") + printf '%s\n' "$push_output" + digest=$(printf '%s\n' "$push_output" | sed -n 's/^.*digest: \(sha256:[0-9a-f]*\).*$/\1/p' | tail -n 1) + test -n "$digest" + repository=${image%:*} + printf '%s=%s@%s\n' "$output" "$repository" "$digest" >> "$GITHUB_OUTPUT" + } + + publish api_image "$API_IMAGE" + publish nginx_image "$NGINX_IMAGE" + publish swagger_image "$SWAGGER_IMAGE" + publish prometheus_image "$PROMETHEUS_IMAGE" + publish grafana_image "$GRAFANA_IMAGE" + publish s3_image "$S3_IMAGE" + publish s3_bootstrap_image "$S3_BOOTSTRAP_IMAGE" + - name: Container logs if: failure() run: if [ -f .env ]; then docker compose logs --no-color --tail=200; fi @@ -86,7 +128,8 @@ jobs: - name: Stop local stack if: always() run: | - if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + docker network disconnect "${COMPOSE_PROJECT_NAME}_application" "$HOSTNAME" 2>/dev/null || true + docker network disconnect "${COMPOSE_PROJECT_NAME}_data" "$HOSTNAME" 2>/dev/null || true if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi deploy: @@ -99,6 +142,8 @@ jobs: DEPLOY_USER: ${{ secrets.DEPLOY_USER }} DEPLOY_SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }} DEPLOY_KNOWN_HOSTS: ${{ secrets.DEPLOY_KNOWN_HOSTS }} + REGISTRY_USERNAME: ${{ secrets.REGISTRY_USERNAME }} + REGISTRY_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }} DEPLOY_SHA: ${{ github.sha }} steps: - name: Configure SSH @@ -108,6 +153,24 @@ jobs: printf '%s\n' "$DEPLOY_SSH_KEY" > ~/.ssh/id_ed25519 printf '%s\n' "$DEPLOY_KNOWN_HOSTS" > ~/.ssh/known_hosts + - name: Prepare immutable image manifest + run: | + cat > deploy-images.env <\n' "$0" >&2 + exit 2 +fi + +manifest=$1 +deploy_dir=${DEPLOY_STATE_DIR:-"$HOME/.local/state/mtusi2026lab4"} +current_manifest=$deploy_dir/current-images.env +previous_manifest=$deploy_dir/previous-images.env +replicas=${API_REPLICAS:-2} +rollback_ready=false +switched=false + +mkdir -p "$deploy_dir" + +load_manifest() { + set -a + # shellcheck disable=SC1090 + . "$1" + set +a +} + +compose() { + docker compose -f compose.yaml -f deploy/compose.images.yaml "$@" +} + wait_for_replicas() { expected=$1 - deadline=$(($(date +%s) + 90)) + deadline=$(($(date +%s) + 120)) while [ "$(date +%s)" -lt "$deadline" ]; do - containers=$(docker compose ps -q api) + containers=$(compose ps -q api) count=0 healthy=0 for container in $containers; do count=$((count + 1)) status=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$container") - if [ "$status" = "healthy" ]; then + if [ "$status" = healthy ]; then healthy=$((healthy + 1)) fi done @@ -23,36 +49,93 @@ wait_for_replicas() { sleep 1 done - printf '%s\n' "API replicas did not become healthy: expected $expected" >&2 + printf 'API replicas did not become healthy: expected %s\n' "$expected" >&2 return 1 } -old_containers=$(docker compose ps -q api) -old_count=0 -for container in $old_containers; do - old_count=$((old_count + 1)) -done +smoke_check() { + compose exec -T nginx wget -q -O /dev/null http://127.0.0.1:8080/health/ready +} -docker compose build -docker compose up -d postgres valkey s3 -docker compose run --rm s3-bootstrap -docker compose run --rm migrate +running_image() { + containers=$(compose ps -q "$1") + for container in $containers; do + docker inspect --format '{{.Config.Image}}' "$container" + return 0 + done + return 1 +} -if [ "$old_count" -lt 2 ]; then - docker compose up -d --scale api=2 --wait --wait-timeout 120 - exit 0 +capture_running_images() { + output=$1 + api_image=$(running_image api) || return 1 + nginx_image=$(running_image nginx) || return 1 + swagger_image=$(running_image swagger) || swagger_image=$SWAGGER_IMAGE + prometheus_image=$(running_image prometheus) || prometheus_image=$PROMETHEUS_IMAGE + grafana_image=$(running_image grafana) || grafana_image=$GRAFANA_IMAGE + s3_image=$(running_image s3) || s3_image=$S3_IMAGE + s3_bootstrap_image=$(running_image s3-bootstrap) || s3_bootstrap_image=$S3_BOOTSTRAP_IMAGE + + { + printf 'API_IMAGE=%s\n' "$api_image" + printf 'NGINX_IMAGE=%s\n' "$nginx_image" + printf 'SWAGGER_IMAGE=%s\n' "$swagger_image" + printf 'PROMETHEUS_IMAGE=%s\n' "$prometheus_image" + printf 'GRAFANA_IMAGE=%s\n' "$grafana_image" + printf 'S3_IMAGE=%s\n' "$s3_image" + printf 'S3_BOOTSTRAP_IMAGE=%s\n' "$s3_bootstrap_image" + } > "$output" +} + +rollback() { + status=$? + trap - EXIT INT TERM + + if [ "$switched" = true ] && [ "$rollback_ready" = true ]; then + printf '%s\n' 'Deployment failed; restoring the previous images.' >&2 + compose stop nginx api >/dev/null 2>&1 || true + compose rm -f nginx api >/dev/null 2>&1 || true + load_manifest "$previous_manifest" + compose up -d --no-build --no-deps --force-recreate --scale api="$replicas" api + wait_for_replicas "$replicas" + compose up -d --no-build --no-deps --force-recreate nginx + smoke_check + elif [ "$switched" = true ]; then + printf '%s\n' 'Deployment failed and no previous image manifest is available.' >&2 + fi + + exit "$status" +} + +trap rollback EXIT +trap 'exit 130' INT +trap 'exit 143' TERM + +load_manifest "$manifest" + +if [ -f "$current_manifest" ]; then + cp "$current_manifest" "$previous_manifest" + rollback_ready=true +elif capture_running_images "$previous_manifest"; then + rollback_ready=true fi -docker compose up -d --no-deps --no-recreate --scale api=3 api -wait_for_replicas 3 +compose pull api nginx swagger prometheus grafana s3 s3-bootstrap +compose up -d --no-build --wait --wait-timeout 120 postgres valkey s3 +compose run --rm --no-deps s3-bootstrap +compose run --rm --no-deps migrate -for container in $old_containers; do - docker stop --time 6 "$container" >/dev/null - docker rm "$container" >/dev/null - docker compose up -d --no-deps --no-recreate --scale api=3 api - wait_for_replicas 3 -done +# Stop the entry point and every old API replica before starting the new pool. +# This gives an atomic version boundary at the cost of a short maintenance window. +switched=true +compose stop nginx api +compose rm -f nginx api +compose up -d --no-build --no-deps --force-recreate --scale api="$replicas" api +wait_for_replicas "$replicas" +compose up -d --no-build --no-deps --force-recreate nginx +smoke_check -docker compose up -d --no-deps --no-recreate --scale api=2 api -wait_for_replicas 2 -docker compose up -d --no-build --scale api=2 --wait --wait-timeout 120 +compose up -d --no-build swagger postgres-exporter valkey-exporter nginx-exporter prometheus grafana + +cp "$manifest" "$current_manifest" +trap - EXIT INT TERM -- 2.54.0 From 3fde1c324c5c06f7506c7550e2bac3647dc336b2 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:27:58 +0300 Subject: [PATCH 08/15] fix: harden attachment cleanup --- cmd/lab4experiment/main.go | 14 ++++---- internal/messenger/attachment/service.go | 7 ++-- internal/messenger/attachment/service_test.go | 23 ++++++++++++ internal/postgres/attachments.go | 33 ++++++++++++++--- internal/postgres/store_integration_test.go | 35 ++++++++++++++++++- internal/reconcile/reconcile.go | 19 +++++++--- internal/reconcile/reconcile_test.go | 18 +++++++--- migrations/0005_allow_pending_deletion.sql | 9 +++++ 8 files changed, 134 insertions(+), 24 deletions(-) create mode 100644 migrations/0005_allow_pending_deletion.sql diff --git a/cmd/lab4experiment/main.go b/cmd/lab4experiment/main.go index e8128b7b..e2637750 100644 --- a/cmd/lab4experiment/main.go +++ b/cmd/lab4experiment/main.go @@ -327,6 +327,9 @@ func runConsistency(arguments []string, output io.Writer) error { if err != nil { return err } + if _, err := pool.Exec(ctx, `UPDATE attachments SET status = 'pending', ready_at = NULL WHERE id = $1`, abandoned.ID); err != nil { + return fmt.Errorf("prepare abandoned pending attachment: %w", err) + } keys, err := attachmentKeys(ctx, pool, []string{unused.ID, inUse.ID, abandoned.ID}) if err != nil { return err @@ -358,8 +361,7 @@ func runConsistency(arguments []string, output io.Writer) error { attachmentExists(ctx, pool, abandoned.ID) if _, err := pool.Exec(ctx, ` UPDATE attachments - SET created_at = clock_timestamp() - INTERVAL '2 hours', - ready_at = clock_timestamp() - INTERVAL '2 hours' + SET created_at = clock_timestamp() - INTERVAL '2 hours' WHERE id = $1`, abandoned.ID); err != nil { return fmt.Errorf("age abandoned attachment: %w", err) } @@ -394,7 +396,7 @@ func runConsistency(arguments []string, output io.Writer) error { FreshApply: freshRun, DryRun: dryRunResult, Apply: applyResult, RepeatedApply: repeatedResult, FreshPreserved: freshPreserved, OrphanDeleted: !objectExists(ctx, objects, orphanKey), UnusedDeleted: !attachmentExists(ctx, pool, unused.ID), InUsePreserved: attachmentExists(ctx, pool, inUse.ID), - AbandonedDeleted: !attachmentExists(ctx, pool, abandoned.ID) && !objectExists(ctx, objects, keys[abandoned.ID]), + AbandonedDeleted: !attachmentExists(ctx, pool, abandoned.ID) && !objectExists(ctx, objects, keys[abandoned.ID]), TotalDurationMillis: time.Since(started).Milliseconds(), } if !result.FreshPreserved || !result.OrphanDeleted || !result.UnusedDeleted || !result.InUsePreserved || !result.AbandonedDeleted || @@ -414,7 +416,7 @@ func hasAnomalies(report reconcile.Report) bool { return report.FreshOrphanObjects != 0 || report.OldOrphanObjects != 0 || report.FreshMissingObjects != 0 || report.ReferencedMissingObjects != 0 || report.OldUnreferencedMetadata != 0 || report.OldPendingAttachments != 0 || - report.OldUnreferencedAttachments != 0 + report.OldUnreferencedAttachments != 0 || report.DeletingAttachments != 0 } func attachmentKeys(ctx context.Context, pool *pgxpool.Pool, ids []string) (map[string]string, error) { @@ -580,11 +582,11 @@ func waitForReplicas(ctx context.Context, prometheusURL string, expected int) er } func activeReplicasQuery() string { - return `count(timestamp(process_resident_memory_bytes{job="messenger"}) > time() - 10)` + return `count(last_over_time(process_resident_memory_bytes{job="messenger"}[10s]))` } func freshMetricQuery(metric string) string { - return fmt.Sprintf(`sum(%[1]s{job="messenger"} and on(instance) (timestamp(%[1]s{job="messenger"}) > time() - 10))`, metric) + return fmt.Sprintf(`sum(last_over_time(%s{job="messenger"}[10s]))`, metric) } func prometheusValue(ctx context.Context, baseURL, query string) (int64, error) { diff --git a/internal/messenger/attachment/service.go b/internal/messenger/attachment/service.go index 3724d56e..32f0179e 100644 --- a/internal/messenger/attachment/service.go +++ b/internal/messenger/attachment/service.go @@ -11,6 +11,7 @@ import ( _ "image/png" "io" "log/slog" + "math" "mime" "net/http" "time" @@ -68,7 +69,7 @@ type Service struct { } func NewService(logger *slog.Logger, repository Repository, objects ObjectStore, config Config) (*Service, error) { - if config.MaxBytes < 1 || config.MaxPixels < 1 || config.CleanupTimeout <= 0 { + if config.MaxBytes < 1 || config.MaxPixels < 1 || config.MaxPixels > math.MaxInt64/8 || config.CleanupTimeout <= 0 { return nil, errors.New("invalid attachment service configuration") } if config.BodyMemoryBytes < config.MaxBytes { @@ -207,11 +208,11 @@ func (s *Service) readImage(input Upload) ([]byte, string, func(), error) { releaseBody() return nil, "", nil, model.ErrUnsupportedMedia } - pixels := int64(imageConfig.Width) * int64(imageConfig.Height) - if imageConfig.Width < 1 || imageConfig.Height < 1 || pixels > s.config.MaxPixels { + if imageConfig.Width < 1 || imageConfig.Height < 1 || int64(imageConfig.Width) > s.config.MaxPixels/int64(imageConfig.Height) { releaseBody() return nil, "", nil, model.ErrPayloadTooLarge } + pixels := int64(imageConfig.Width) * int64(imageConfig.Height) decodeBytes := pixels * 8 if !s.decodeMemory.TryAcquire(decodeBytes) { releaseBody() diff --git a/internal/messenger/attachment/service_test.go b/internal/messenger/attachment/service_test.go index 3c5bb9bd..fbaea3fa 100644 --- a/internal/messenger/attachment/service_test.go +++ b/internal/messenger/attachment/service_test.go @@ -9,6 +9,7 @@ import ( "image/png" "io" "log/slog" + "math" "testing" "time" @@ -69,6 +70,28 @@ func TestUploadUsesSeparateBodyAndDecodeBudgets(t *testing.T) { service.decodeMemory.Release(32) } +func TestUploadReleasesBodyMemoryAfterOversizedDimensions(t *testing.T) { + oversized := pngFixture(t, 3, 2) + valid := pngFixture(t, 2, 2) + service := newTestService(t, &repositoryStub{}, &objectStub{}, 1024, 4) + + _, err := service.Upload(context.Background(), upload(oversized, "image/png")) + require.ErrorIs(t, err, model.ErrPayloadTooLarge) + _, err = service.Upload(context.Background(), upload(valid, "image/png")) + require.NoError(t, err) +} + +func TestNewServiceRejectsDecodeBudgetOverflow(t *testing.T) { + _, err := NewService( + slog.New(slog.NewTextHandler(io.Discard, nil)), &repositoryStub{}, &objectStub{}, + Config{ + MaxBytes: 1024, MaxPixels: math.MaxInt64/8 + 1, BodyMemoryBytes: 1024, + DecodeMemoryBytes: math.MaxInt64, CleanupTimeout: time.Second, + }, + ) + require.Error(t, err) +} + func TestUploadCleansPendingMetadataWhenObjectWriteFails(t *testing.T) { data := pngFixture(t, 2, 2) repository := &repositoryStub{} diff --git a/internal/postgres/attachments.go b/internal/postgres/attachments.go index ae92171f..305e806c 100644 --- a/internal/postgres/attachments.go +++ b/internal/postgres/attachments.go @@ -161,32 +161,55 @@ func (s *Store) AttachmentReferenced(ctx context.Context, attachmentID string) ( return referenced, nil } -func (s *Store) ClaimAttachmentForDeletion(ctx context.Context, attachmentID string, createdBefore time.Time) (bool, error) { +func (s *Store) ClaimAttachmentForDeletion(ctx context.Context, candidate model.Attachment, createdBefore time.Time) (bool, error) { tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) if err != nil { return false, fmt.Errorf("begin attachment deletion claim: %w", err) } defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() + var status string var createdAt time.Time - err = tx.QueryRow(ctx, `SELECT created_at FROM attachments WHERE id = $1 FOR UPDATE`, attachmentID).Scan(&createdAt) + var readyAt *time.Time + err = tx.QueryRow( + ctx, `SELECT status, created_at, ready_at FROM attachments WHERE id = $1 FOR UPDATE`, candidate.ID, + ).Scan(&status, &createdAt, &readyAt) if errors.Is(err, pgx.ErrNoRows) { return false, nil } if err != nil { return false, fmt.Errorf("lock attachment deletion candidate: %w", err) } - if createdAt.After(createdBefore) { + if status != candidate.Status { + return false, nil + } + var age time.Time + switch status { + case model.AttachmentPending: + age = createdAt + case model.AttachmentReady: + if readyAt == nil { + return false, nil + } + age = *readyAt + default: + return false, nil + } + if age.After(createdBefore) { return false, nil } var referenced bool - if err := tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1)`, attachmentID).Scan(&referenced); err != nil { + if err := tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1)`, candidate.ID).Scan(&referenced); err != nil { return false, fmt.Errorf("recheck attachment references: %w", err) } if referenced { return false, nil } - if _, err := tx.Exec(ctx, `UPDATE attachments SET status = 'deleting', updated_at = clock_timestamp() WHERE id = $1`, attachmentID); err != nil { + if _, err := tx.Exec( + ctx, + `UPDATE attachments SET status = 'deleting', updated_at = clock_timestamp() WHERE id = $1 AND status = $2`, + candidate.ID, candidate.Status, + ); err != nil { return false, fmt.Errorf("mark attachment deleting: %w", err) } if err := tx.Commit(ctx); err != nil { diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index 71943eac..48f60842 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -154,11 +154,44 @@ func (s *PostgresSuite) TestAttachmentAccessAndMessageLinking() { referenced, err := s.store.AttachmentReferenced(context.Background(), created.ID) s.Require().NoError(err) s.True(referenced) - deleted, err := s.store.ClaimAttachmentForDeletion(context.Background(), created.ID, time.Now().Add(time.Hour)) + deleted, err := s.store.ClaimAttachmentForDeletion(context.Background(), created, time.Now().Add(time.Hour)) s.Require().NoError(err) s.False(deleted) } +func (s *PostgresSuite) TestAttachmentDeletionClaimChecksLifecycleUnderLock() { + owner, chatID := createOwnerAndChat(s.T(), s.store) + pending, err := s.store.CreatePendingAttachment(context.Background(), model.Attachment{ + ID: uuid.NewString(), ChatID: chatID, OwnerID: owner.ID, Filename: "pending.png", + ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("c", 64), + ObjectKey: "attachments/" + uuid.NewString() + "/original", + }) + s.Require().NoError(err) + + claimed, err := s.store.ClaimAttachmentForDeletion(context.Background(), pending, time.Now().Add(time.Hour)) + s.Require().NoError(err) + s.True(claimed) + deleted, err := s.store.DeleteAttachmentIfDeleting(context.Background(), pending.ID) + s.Require().NoError(err) + s.True(deleted) + + pending, err = s.store.CreatePendingAttachment(context.Background(), model.Attachment{ + ID: uuid.NewString(), ChatID: chatID, OwnerID: owner.ID, Filename: "completed.png", + ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("d", 64), + ObjectKey: "attachments/" + uuid.NewString() + "/original", + }) + s.Require().NoError(err) + ready, err := s.store.MarkAttachmentReady(context.Background(), pending.ID, pending.ObjectKey) + s.Require().NoError(err) + + claimed, err = s.store.ClaimAttachmentForDeletion(context.Background(), pending, time.Now().Add(time.Hour)) + s.Require().NoError(err) + s.False(claimed) + visible, err := s.store.AttachmentForUser(context.Background(), ready.ID, owner.ID) + s.Require().NoError(err) + s.Equal(model.AttachmentReady, visible.Status) +} + func (s *PostgresSuite) TestMessageRejectsAttachmentFromAnotherChat() { owner, firstChatID := createOwnerAndChat(s.T(), s.store) secondChat, err := s.store.CreateChat(context.Background(), "Second", []string{owner.ID}, owner.ID) diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go index d12a138d..eb2b0911 100644 --- a/internal/reconcile/reconcile.go +++ b/internal/reconcile/reconcile.go @@ -12,7 +12,7 @@ import ( type MetadataStore interface { ListAttachments(context.Context, string, int) ([]model.Attachment, string, error) AttachmentExistsByObjectKey(context.Context, string) (bool, error) - ClaimAttachmentForDeletion(context.Context, string, time.Time) (bool, error) + ClaimAttachmentForDeletion(context.Context, model.Attachment, time.Time) (bool, error) DeleteAttachmentIfDeleting(context.Context, string) (bool, error) } @@ -36,6 +36,7 @@ type Report struct { Consistent int `json:"consistent"` FreshPendingAttachments int `json:"fresh_pending_attachments"` OldPendingAttachments int `json:"old_pending_attachments"` + DeletingAttachments int `json:"deleting_attachments"` FreshUnreferencedAttachments int `json:"fresh_unreferenced_attachments"` OldUnreferencedAttachments int `json:"old_unreferenced_attachments"` DeletedAttachmentObjects int `json:"deleted_attachment_objects"` @@ -124,19 +125,21 @@ func (r *Reconciler) handlePair( ) error { report.MetadataScanned++ report.ObjectsScanned++ - report.Consistent++ switch metadata.Status { case model.AttachmentPending: if metadata.CreatedAt.After(anomalyCutoff) { report.FreshPendingAttachments++ + report.Consistent++ return nil } report.OldPendingAttachments++ return r.deletePair(ctx, metadata, anomalyCutoff, report) case model.AttachmentDeleting: + report.DeletingAttachments++ return r.deleteClaimedPair(ctx, metadata, report) case model.AttachmentReady: if metadata.Referenced { + report.Consistent++ return nil } age := metadata.CreatedAt @@ -145,6 +148,7 @@ func (r *Reconciler) handlePair( } if age.After(retentionCutoff) { report.FreshUnreferencedAttachments++ + report.Consistent++ return nil } report.OldUnreferencedAttachments++ @@ -158,7 +162,7 @@ func (r *Reconciler) deletePair(ctx context.Context, attachment model.Attachment if !r.config.Apply { return nil } - claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, attachment.ID, cutoff) + claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, attachment, cutoff) if err != nil { return fmt.Errorf("claim attachment %q: %w", attachment.ID, err) } @@ -222,6 +226,9 @@ func (r *Reconciler) handleMissingObject( report *Report, ) error { report.MetadataScanned++ + if metadata.Status == model.AttachmentDeleting { + return r.deleteClaimedMetadata(ctx, metadata, report) + } if metadata.CreatedAt.After(cutoff) { report.FreshMissingObjects++ return nil @@ -234,13 +241,17 @@ func (r *Reconciler) handleMissingObject( if !r.config.Apply { return nil } - claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, metadata.ID, cutoff) + claimed, err := r.metadata.ClaimAttachmentForDeletion(ctx, metadata, cutoff) if err != nil { return fmt.Errorf("claim missing attachment metadata %q: %w", metadata.ID, err) } if !claimed { return nil } + return r.deleteClaimedMetadata(ctx, metadata, report) +} + +func (r *Reconciler) deleteClaimedMetadata(ctx context.Context, metadata model.Attachment, report *Report) error { deleted, err := r.metadata.DeleteAttachmentIfDeleting(ctx, metadata.ID) if err != nil { return fmt.Errorf("delete missing attachment metadata %q: %w", metadata.ID, err) diff --git a/internal/reconcile/reconcile_test.go b/internal/reconcile/reconcile_test.go index 221ac0c4..62471a65 100644 --- a/internal/reconcile/reconcile_test.go +++ b/internal/reconcile/reconcile_test.go @@ -121,13 +121,21 @@ func (s *metadataStub) AttachmentExistsByObjectKey(_ context.Context, key string return exists, nil } -func (s *metadataStub) ClaimAttachmentForDeletion(_ context.Context, id string, cutoff time.Time) (bool, error) { +func (s *metadataStub) ClaimAttachmentForDeletion(_ context.Context, candidate model.Attachment, cutoff time.Time) (bool, error) { for key, item := range s.items { - if item.ID == id && !item.CreatedAt.After(cutoff) && !item.Referenced { - item.Status = model.AttachmentDeleting - s.items[key] = item - return true, nil + if item.ID != candidate.ID || item.Status != candidate.Status || item.Referenced { + continue } + age := item.CreatedAt + if item.Status == model.AttachmentReady && item.ReadyAt != nil { + age = *item.ReadyAt + } + if age.After(cutoff) { + return false, nil + } + item.Status = model.AttachmentDeleting + s.items[key] = item + return true, nil } return false, nil } diff --git a/migrations/0005_allow_pending_deletion.sql b/migrations/0005_allow_pending_deletion.sql new file mode 100644 index 00000000..0b20acb2 --- /dev/null +++ b/migrations/0005_allow_pending_deletion.sql @@ -0,0 +1,9 @@ +ALTER TABLE attachments + DROP CONSTRAINT attachments_ready_at; + +ALTER TABLE attachments + ADD CONSTRAINT attachments_ready_at CHECK ( + (status = 'pending' AND ready_at IS NULL) OR + (status = 'ready' AND ready_at IS NOT NULL) OR + status = 'deleting' + ); -- 2.54.0 From 37d93c340e394ed4a923972accc6c872abb96076 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:27:58 +0300 Subject: [PATCH 09/15] fix: switch API pools atomically --- .gitea/workflows/deploy.yml | 2 +- compose.yaml | 2 + nginx/nginx.conf | 2 +- nginx/upstream.conf | 1 + scripts/rolling-update.sh | 196 +++++++++++++++++++++++++----------- 5 files changed, 144 insertions(+), 59 deletions(-) create mode 100644 nginx/upstream.conf diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml index bcf4cf70..29977487 100644 --- a/.gitea/workflows/deploy.yml +++ b/.gitea/workflows/deploy.yml @@ -180,7 +180,7 @@ jobs: git cat-file -e '$DEPLOY_SHA^{commit}' git reset --hard '$DEPLOY_SHA' manifest='/tmp/mtusi2026lab4-${{ github.run_id }}.env' - if scripts/rolling-update.sh \"\$manifest\"; then + if DEPLOY_GENERATION='${{ github.run_id }}' scripts/rolling-update.sh \"\$manifest\"; then rm -f \"\$manifest\" else status=\$? diff --git a/compose.yaml b/compose.yaml index 2373efcc..72b6ca6f 100644 --- a/compose.yaml +++ b/compose.yaml @@ -177,6 +177,8 @@ services: image: ${NGINX_IMAGE:-mtusi-nginx:lab4} ports: - "${API_BIND_ADDRESS}:8080" + volumes: + - ${NGINX_UPSTREAM_FILE:-./nginx/upstream.conf}:/etc/nginx/conf.d/upstream.conf:ro depends_on: api: condition: service_healthy diff --git a/nginx/nginx.conf b/nginx/nginx.conf index 3dde36ac..d62dcd65 100644 --- a/nginx/nginx.conf +++ b/nginx/nginx.conf @@ -20,7 +20,7 @@ http { upstream messenger { zone messenger 64k; - server api:8080 resolve max_fails=1 fail_timeout=3s; + include /etc/nginx/conf.d/upstream.conf; keepalive 32; } diff --git a/nginx/upstream.conf b/nginx/upstream.conf new file mode 100644 index 00000000..f6131cb4 --- /dev/null +++ b/nginx/upstream.conf @@ -0,0 +1 @@ +server api:8080 resolve max_fails=1 fail_timeout=3s; diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh index 7d27dd7d..cda43090 100755 --- a/scripts/rolling-update.sh +++ b/scripts/rolling-update.sh @@ -10,12 +10,21 @@ fi manifest=$1 deploy_dir=${DEPLOY_STATE_DIR:-"$HOME/.local/state/mtusi2026lab4"} current_manifest=$deploy_dir/current-images.env -previous_manifest=$deploy_dir/previous-images.env +active_containers=$deploy_dir/active-api-containers +previous_containers=$deploy_dir/previous-api-containers +upstream_file=$deploy_dir/upstream.conf +upstream_backup=$deploy_dir/upstream.previous.conf +candidate_file=$deploy_dir/candidate-api-containers replicas=${API_REPLICAS:-2} -rollback_ready=false +project=${COMPOSE_PROJECT_NAME:-mtusi2026lab4} switched=false +nginx_created=false +upstream_changed=false +old_pool="" mkdir -p "$deploy_dir" +: > "$candidate_file" +export NGINX_UPSTREAM_FILE=$upstream_file load_manifest() { set -a @@ -28,12 +37,30 @@ compose() { docker compose -f compose.yaml -f deploy/compose.images.yaml "$@" } -wait_for_replicas() { - expected=$1 +container_name() { + name=$(docker inspect --format '{{.Name}}' "$1") + printf '%s\n' "${name#/}" +} + +running_container() { + [ "$(docker inspect --format '{{.State.Running}}' "$1" 2>/dev/null || true)" = true ] +} + +write_upstream() { + output=$1 + containers=$2 + : > "$output" + for container in $containers; do + name=$(container_name "$container") + printf 'server %s:8080 resolve max_fails=1 fail_timeout=3s;\n' "$name" >> "$output" + done +} + +wait_for_containers() { + containers=$1 deadline=$(($(date +%s) + 120)) while [ "$(date +%s)" -lt "$deadline" ]; do - containers=$(compose ps -q api) count=0 healthy=0 for container in $containers; do @@ -43,13 +70,13 @@ wait_for_replicas() { healthy=$((healthy + 1)) fi done - if [ "$count" -eq "$expected" ] && [ "$healthy" -eq "$expected" ]; then + if [ "$count" -eq "$replicas" ] && [ "$healthy" -eq "$replicas" ]; then return 0 fi sleep 1 done - printf 'API replicas did not become healthy: expected %s\n' "$expected" >&2 + printf 'candidate API pool did not become healthy: expected %s\n' "$replicas" >&2 return 1 } @@ -57,53 +84,36 @@ smoke_check() { compose exec -T nginx wget -q -O /dev/null http://127.0.0.1:8080/health/ready } -running_image() { - containers=$(compose ps -q "$1") +remove_containers() { + containers=$1 for container in $containers; do - docker inspect --format '{{.Config.Image}}' "$container" - return 0 + docker rm -f "$container" >/dev/null 2>&1 || true done - return 1 } -capture_running_images() { - output=$1 - api_image=$(running_image api) || return 1 - nginx_image=$(running_image nginx) || return 1 - swagger_image=$(running_image swagger) || swagger_image=$SWAGGER_IMAGE - prometheus_image=$(running_image prometheus) || prometheus_image=$PROMETHEUS_IMAGE - grafana_image=$(running_image grafana) || grafana_image=$GRAFANA_IMAGE - s3_image=$(running_image s3) || s3_image=$S3_IMAGE - s3_bootstrap_image=$(running_image s3-bootstrap) || s3_bootstrap_image=$S3_BOOTSTRAP_IMAGE - - { - printf 'API_IMAGE=%s\n' "$api_image" - printf 'NGINX_IMAGE=%s\n' "$nginx_image" - printf 'SWAGGER_IMAGE=%s\n' "$swagger_image" - printf 'PROMETHEUS_IMAGE=%s\n' "$prometheus_image" - printf 'GRAFANA_IMAGE=%s\n' "$grafana_image" - printf 'S3_IMAGE=%s\n' "$s3_image" - printf 'S3_BOOTSTRAP_IMAGE=%s\n' "$s3_bootstrap_image" - } > "$output" +restore_upstream() { + if [ -s "$upstream_backup" ]; then + cp "$upstream_backup" "$upstream_file" + compose exec -T nginx nginx -t + compose exec -T nginx nginx -s reload + fi } rollback() { status=$? trap - EXIT INT TERM + candidates=$(cat "$candidate_file" 2>/dev/null || true) - if [ "$switched" = true ] && [ "$rollback_ready" = true ]; then - printf '%s\n' 'Deployment failed; restoring the previous images.' >&2 - compose stop nginx api >/dev/null 2>&1 || true - compose rm -f nginx api >/dev/null 2>&1 || true - load_manifest "$previous_manifest" - compose up -d --no-build --no-deps --force-recreate --scale api="$replicas" api - wait_for_replicas "$replicas" - compose up -d --no-build --no-deps --force-recreate nginx - smoke_check - elif [ "$switched" = true ]; then - printf '%s\n' 'Deployment failed and no previous image manifest is available.' >&2 + if [ "$upstream_changed" = true ] && [ -n "$old_pool" ]; then + printf '%s\n' 'Deployment failed; switching Nginx back to the previous API pool.' >&2 + restore_upstream || true + if [ "$switched" = true ]; then + smoke_check || true + fi + elif [ "$nginx_created" = true ]; then + compose stop nginx >/dev/null 2>&1 || true fi - + remove_containers "$candidates" exit "$status" } @@ -112,30 +122,102 @@ trap 'exit 130' INT trap 'exit 143' TERM load_manifest "$manifest" +new_api_image=$API_IMAGE -if [ -f "$current_manifest" ]; then - cp "$current_manifest" "$previous_manifest" - rollback_ready=true -elif capture_running_images "$previous_manifest"; then - rollback_ready=true +if [ -f "$previous_containers" ]; then + remove_containers "$(cat "$previous_containers")" + rm -f "$previous_containers" fi +if [ -s "$active_containers" ]; then + for container in $(cat "$active_containers"); do + if running_container "$container"; then + old_pool="$old_pool $container" + fi + done +fi +if [ -z "$old_pool" ]; then + old_pool=$(compose ps -q api) +fi + +if [ -s "$upstream_file" ]; then + : +elif [ -n "$old_pool" ]; then + write_upstream "$upstream_file" "$old_pool" +else + cp nginx/upstream.conf "$upstream_file" +fi +cp "$upstream_file" "$upstream_backup" + compose pull api nginx swagger prometheus grafana s3 s3-bootstrap compose up -d --no-build --wait --wait-timeout 120 postgres valkey s3 compose run --rm --no-deps s3-bootstrap compose run --rm --no-deps migrate -# Stop the entry point and every old API replica before starting the new pool. -# This gives an atomic version boundary at the cost of a short maintenance window. -switched=true -compose stop nginx api -compose rm -f nginx api -compose up -d --no-build --no-deps --force-recreate --scale api="$replicas" api -wait_for_replicas "$replicas" -compose up -d --no-build --no-deps --force-recreate nginx +nginx_container=$(compose ps -q nginx) +if [ -n "$nginx_container" ] && ! docker inspect --format '{{range .Mounts}}{{println .Destination}}{{end}}' "$nginx_container" | grep -qx /etc/nginx/conf.d/upstream.conf; then + compose up -d --no-build --no-deps --force-recreate nginx + nginx_container=$(compose ps -q nginx) +fi +if [ -n "$nginx_container" ]; then + running_nginx_image=$(docker inspect --format '{{.Config.Image}}' "$nginx_container") + if [ "$running_nginx_image" != "$NGINX_IMAGE" ]; then + printf 'verified Nginx image differs from the running load balancer; deploy it in a dedicated maintenance operation\n' >&2 + exit 1 + fi +fi + +API_IMAGE=$new_api_image +export API_IMAGE +short_digest=$(printf '%s' "$new_api_image" | sed 's/.*sha256://; s/[^0-9a-f].*//' | cut -c1-12) +if [ -z "$short_digest" ]; then + short_digest=$(date +%s) +fi +generation=${DEPLOY_GENERATION:-"$(date +%s)-$$"} + +candidate_pool="" +index=1 +while [ "$index" -le "$replicas" ]; do + name="${project}-api-${short_digest}-${generation}-${index}" + container=$(compose run -d --no-deps --name "$name" api) + candidate_pool="$candidate_pool $container" + printf '%s\n' "$container" >> "$candidate_file" + index=$((index + 1)) +done +wait_for_containers "$candidate_pool" + +write_upstream "$upstream_file.next" "$candidate_pool" +cp "$upstream_file.next" "$upstream_file" +upstream_changed=true + +if [ -n "$(compose ps -q nginx)" ]; then + compose exec -T nginx nginx -t + switched=true + compose exec -T nginx nginx -s reload +else + nginx_created=true + compose up -d --no-build --no-deps nginx + switched=true +fi smoke_check -compose up -d --no-build swagger postgres-exporter valkey-exporter nginx-exporter prometheus grafana +application_network="${project}_application" +for container in $candidate_pool; do + docker network disconnect "$application_network" "$container" + docker network connect --alias api "$application_network" "$container" +done +smoke_check +compose up -d --no-build --no-deps swagger postgres-exporter valkey-exporter nginx-exporter prometheus grafana + +printf '%s\n' "$candidate_pool" > "$active_containers" cp "$manifest" "$current_manifest" +rm -f "$candidate_file" "$upstream_file.next" trap - EXIT INT TERM + +if [ -n "$old_pool" ]; then + for container in $old_pool; do + docker stop --time 6 "$container" >/dev/null || true + done + printf '%s\n' "$old_pool" > "$previous_containers" +fi -- 2.54.0 From 56e4a03bb6758ebf4710c01eabcbf91d7a284909 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:39:32 +0300 Subject: [PATCH 10/15] test: refresh final lab4 evidence --- REPORT.md | 47 +++++++++++++++----------- evidence/lab4-consistency.json | 61 ++++++++++++++++++++++++---------- evidence/lab4-memory.json | 14 ++++---- evidence/lab4-verification.txt | 37 +++++++++++++-------- 4 files changed, 101 insertions(+), 58 deletions(-) diff --git a/REPORT.md b/REPORT.md index 2cf0bced..88f4a0fd 100644 --- a/REPORT.md +++ b/REPORT.md @@ -4,7 +4,6 @@ - Целевая оценка: 5. - Выбранный трек: 2, согласованность PostgreSQL и S3. - Ветка: `solution/bvt2303-plastinin`. -- Источники и инструменты: документация Go, PostgreSQL и MinIO; Codex использован при реализации. ## Запуск из чистого clone @@ -81,6 +80,8 @@ Prometheus <---- API /metrics, MinIO, Nginx, PostgreSQL, Valkey Из лабораторной № 3 сохранены две и более API-реплики, Nginx, общие PostgreSQL и Valkey, Bearer-сессии, keyset pagination, идемпотентность сообщений, graceful shutdown, failover, метрики и управляемое развёртывание. В лабораторной № 4 добавлены приватное объектное хранилище, модель вложения, бинарная загрузка и скачивание, привязка вложений к сообщениям и сверка двух хранилищ. +Код разделён по ответственности. `internal/messenger/httpapi` содержит HTTP-маршруты, middleware и преобразование ошибок в ответы. `internal/messenger/attachment` владеет сценарием загрузки и чтения вложений. `internal/postgres`, `internal/objectstore` и `internal/session` являются адаптерами PostgreSQL, S3 и Valkey. `internal/reconcile` выполняет сверку хранилищ, а `internal/bootstrap` собирает зависимости для сервера, миграций и служебной команды. HTTP-слой зависит от узких интерфейсов и общих ошибок модели, поэтому детали PostgreSQL и S3 в handlers не попадают. + PostgreSQL остаётся источником истины для прав доступа и метаданных. Таблица `attachments` хранит владельца, чат, отображаемое имя, MIME, размер, SHA-256 и внутренний object key. Таблица `message_attachments` задаёт упорядоченную связь многие ко многим с сообщениями. Object key генерируется сервером и не зависит от имени файла. MinIO хранит только байты оригиналов. Bucket закрыт для анонимного доступа. Bootstrap повторяемо создаёт bucket, policy и отдельного пользователя приложения. API получает только действия list/get/put/delete в одном bucket. Root credentials используются bootstrap-контейнером и не передаются API. Web-консоль MinIO отключена и её порт не опубликован. @@ -89,7 +90,7 @@ MinIO хранит только байты оригиналов. Bucket закр Клиент передаёт сырые байты PNG или JPEG. Сервер ограничивает HTTP body до 10 MiB до полного чтения, проверяет заявленный и фактический MIME, декодирует конфигурацию изображения, ограничивает число пикселей 40 миллионами и проверяет полную декодируемость. Filename содержит от 1 до 255 Unicode-символов и не может содержать разделители пути, NUL, управляющие символы или состоять только из пробелов. -При успешной загрузке сервер генерирует UUID для вложения и отдельный случайный object key, считает SHA-256, записывает объект в MinIO и затем metadata в PostgreSQL. Ответ `201 ready` возвращается только после обеих операций. Если результат записи PostgreSQL неоднозначен, сервер повторно ищет строку по attachment ID и object key. Найденная строка означает успешный commit и приводит к `201`; подтверждённое отсутствие строки разрешает компенсирующее удаление object; ошибка повторной проверки оставляет object для последующей безопасной сверки reconciler. +При успешной загрузке сервер генерирует UUID для вложения и отдельный случайный object key, считает SHA-256 и создаёт в PostgreSQL строку со статусом `pending`. Затем он записывает объект в MinIO и переводит строку в `ready`. Только после этого возвращается `201`. При отказе S3 строка `pending` удаляется. Если результат перевода в `ready` неоднозначен, сервер повторно читает строку по attachment ID и object key: уже сохранённый `ready` считается успехом, а подтверждённый `pending` компенсируется удалением объекта и metadata. Метаданные и содержимое читаются только после проверки Bearer-сессии и членства пользователя в чате. Посторонний пользователь и неизвестный идентификатор дают одинаковый `404`. API отдаёт байты самостоятельно без redirect и возвращает сохранённый `Content-Type` и точный `Content-Length`. @@ -104,15 +105,15 @@ MinIO хранит только байты оригиналов. Bucket закр Команда `reconcile-attachments` проходит оба набора в порядке object key постранично, поэтому объём памяти ограничен размером двух страниц. По умолчанию включён dry-run. Grace period защищает свежие объекты и строки, которые могут относиться к ещё выполняющейся операции. -В режиме `--apply` старый orphan в S3 удаляется. Старая строка с отсутствующим объектом удаляется только при отсутствии ссылки из `message_attachments`; проверка возраста и отсутствия ссылки повторяется атомарным `DELETE`. Используемая строка сохраняется и попадает в отчёт для ручного восстановления объекта. Повторный запуск после исправления не выполняет дополнительных удалений. +В режиме `--apply` старый orphan в S3 удаляется после повторной проверки object key в PostgreSQL. Старые `pending` и готовые, но неиспользуемые вложения сначала атомарно переводятся в `deleting` под блокировкой строки. Под той же блокировкой повторно проверяются ожидаемый статус, возраст и отсутствие ссылки из `message_attachments`. После удаления объекта строка удаляется только в статусе `deleting`. Если upload успел изменить `pending` на `ready`, устаревший кандидат не захватывается. Используемая строка с отсутствующим объектом сохраняется и попадает в отчёт для ручного восстановления. Повторный запуск продолжает незавершённый `deleting` и не повторяет уже выполненные удаления. ## Ограничение памяти -Размер тела ограничен `http.MaxBytesReader`, поэтому неизвестный `Content-Length` не позволяет читать бесконечный поток. Исходные байты и декодированное изображение находятся в памяти только во время синхронной загрузки. Перед полной декодировкой weighted semaphore резервирует для запроса сумму размера исходных байтов и восьми байт на пиксель. Общий бюджет одной реплики равен 384 MiB, а лимит её контейнера — 512 MiB. Максимально допустимое изображение требует не более 330 485 760 байт расчётного бюджета. Если свободного бюджета нет, API отвечает `429` с `Retry-After: 1`. +До чтения body weighted semaphore резервирует полный лимит одной загрузки — 10 MiB. Поэтому отсутствующий или заниженный `Content-Length` не позволяет одновременно накопить неограниченное число буферов. После чтения дополнительно резервируется восемь байт на пиксель перед полной декодировкой. Бюджеты одной реплики разделены: 64 MiB для исходных body и 384 MiB для декодирования; лимит контейнера равен 512 MiB. Проверки размеров выполняются до умножения, чтобы исключить integer overflow. Если одного из бюджетов недостаточно, API отвечает `429` с `Retry-After: 1`. Go-инструмент `cmd/lab4experiment` создаёт случайное JPEG-изображение и выполняет четыре волны по 12 одновременных загрузок. Передача каждой копии ограничена по скорости, чтобы нагрузка длилась дольше интервала scrape. Наблюдаемый пик heap и resident memory двух API-процессов читается из Prometheus с интервалом одна секунда. Это измерение локального стенда, а не универсальная оценка производительности S3. -В эксперименте успешно завершились все 48 загрузок файла размером 3 759 914 байт. Четыре волны заняли 12,629 секунды. После трёх секунд стабилизации суммарный heap двух реплик вырос с 181 133 200 до наблюдаемого пика 202 374 848 байт, то есть на 21 241 648 байт. Суммарный RSS вырос с 241 922 048 до 381 063 168 байт, то есть на 139 141 120 байт. Наблюдаемый пик остался ниже общего контейнерного лимита двух реплик 1 GiB. +В эксперименте успешно завершились все 48 загрузок файла размером 3 759 914 байт. Четыре волны заняли 12,974 секунды. После трёх секунд стабилизации суммарный heap двух реплик вырос с 153 985 824 до 202 505 208 байт, то есть на 48 519 384 байта. Суммарный RSS вырос с 335 298 560 до 345 976 832 байт, то есть на 10 678 272 байта. Наблюдаемый пик остался ниже общего контейнерного лимита двух реплик 1 GiB. ## Наблюдаемость @@ -126,6 +127,16 @@ Prometheus обнаруживает все API-реплики через Docker `/health/live` проверяет только процесс. `/health/ready` требует доступных PostgreSQL, Valkey и приватного bucket S3. Недоступность Grafana или Prometheus не останавливает API. +## CI/CD и blue/green deploy + +CI проверяет contract, OpenAPI, форматирование, lint, unit и integration tests, persistence и отказ одной API-реплики. После успешных проверок образы публикуются в Gitea Container Registry. В manifest передаются ссылки вида `repository@sha256:digest`, поэтому сервер запускает те же байты, которые прошли проверки. + +Production workflow запускается вручную и использует защищённое environment `production`. Перед переключением применяются только обратно совместимые миграции. Скрипт поднимает новый пул API под отдельными DNS-именами и ждёт readiness каждой реплики. Nginx сначала проверяет новую конфигурацию через `nginx -t`, затем атомарно выполняет reload upstream. Старый пул остаётся запущенным до успешного smoke-check нового и только после этого останавливается. При ошибке до завершения переключения восстанавливается предыдущий upstream, а candidate-контейнеры удаляются. + +Сам балансировщик относится к стабильному control plane. Если его verified digest изменился, обычный API deploy завершается до переключения и требует отдельного обслуживания Nginx. Это не подменяет новый образ старым и не создаёт скрытое окно недоступности внутри blue/green обновления API. + +Локальная проверка механизма подняла две отдельные candidate-реплики, переключила upstream и выполнила 20 запросов `/health/live`: все ответы имели статус `200`, а `X-Instance-Id` чередовался только между двумя контейнерами нового пула. + ## Доказательства критериев | Критерий | Команда или сценарий | Результат | Доказательство | @@ -135,8 +146,9 @@ Prometheus обнаруживает все API-реплики через Docker | Upload/download и ACL | `make test` | PASS | `evidence/lab4-verification.txt` | | Межрепличный failover и restart | public resilience hooks | проверяются CI точного commit | `.gitea/workflows/ci.yml` | | Приватный bucket и повторный bootstrap | anonymous HTTP check, два запуска bootstrap | PASS | `evidence/lab4-verification.txt` | -| 12 конкурентных загрузок и память | `lab4experiment memory` | 48/48 PASS, observed RSS peak 381 063 168 B | `evidence/lab4-memory.json` | +| 12 конкурентных загрузок и память | `lab4experiment memory` | 48/48 PASS, observed RSS peak 345 976 832 B | `evidence/lab4-memory.json` | | Трек 2: dry-run/apply/repeat | `lab4experiment consistency` | PASS, повторный apply: 0 удалений | `evidence/lab4-consistency.json` | +| Blue/green API switch | два candidate-контейнера, `nginx -t`, reload, 20 health-запросов | 20/20 HTTP 200, только новый пул | `evidence/lab4-verification.txt` | ## Эксперимент согласованности @@ -148,27 +160,22 @@ Prometheus обнаруживает все API-реплики через Docker 2. удалить S3 object у непривязанного вложения; 3. привязать другое вложение к сообщению и удалить его S3 object; 4. создать object без metadata; -5. выполнить apply с grace period один час и проверить сохранность свежих аномалий; -6. выполнить dry-run с нулевым grace period; -7. выполнить apply и проверить удаление orphan и непривязанной строки; -8. повторить apply и проверить отсутствие новых действий. +5. создать незавершённое вложение `pending`; +6. выполнить apply с grace period один час и проверить сохранность свежих аномалий; +7. состарить `pending`, выполнить dry-run с нулевым grace period; +8. выполнить apply и проверить удаление orphan, непривязанной строки и старого `pending`; +9. повторить apply и проверить отсутствие новых действий. Фактическая стоимость обхода записывается как число просмотренных объектов и строк, размер страницы и wall time. Алгоритм выполняет линейный merge двух отсортированных потоков; дополнительные запросы проверки ссылок нужны только для metadata с отсутствующим объектом. -При размере страницы 10 фактический запуск пересёк границу страницы и просмотрел 206 строк metadata и 205 objects. Apply с часовым grace period занял 58 миллисекунд и сохранил один свежий orphan и две свежие строки с отсутствующим object. При нулевом grace period dry-run за 65 миллисекунд обнаружил старый orphan, старую непривязанную строку и одну используемую строку. Apply за 77 миллисекунд удалил только orphan и непривязанную строку. Повторный apply занял 38 миллисекунд, выполнил ноль удалений, а используемая строка осталась в PostgreSQL. +При размере страницы 10 фактический запуск пересёк границу страницы. Apply с часовым grace period просмотрел 14 строк metadata и 13 objects за 4 миллисекунды, сохранил свежие orphan, missing metadata и `pending`. После искусственного старения dry-run за 5 миллисекунд обнаружил один старый orphan, одну непривязанную строку без объекта, одну используемую строку без объекта и один старый `pending`. Apply за 13 миллисекунд удалил object и metadata старого `pending`, orphan object и непривязанную missing metadata. Повторный apply занял 1 миллисекунду и выполнил ноль удалений; используемая строка осталась в PostgreSQL. ## Ограничения -- Между S3 PUT и PostgreSQL INSERT нет общей транзакции; компенсация и reconciler обеспечивают eventual consistency. +- Между PostgreSQL и S3 нет общей транзакции; lifecycle `pending/ready/deleting`, компенсация и reconciler обеспечивают eventual consistency. - Удалённый object используемого вложения автоматически не восстанавливается: строка сохраняется и требует восстановления байтов из резервной копии либо решения оператора. - Grace period основан на времени PostgreSQL и S3; для удалённого стенда требуется синхронизация часов. -- Admission control действует отдельно в каждой API-реплике; при изменении контейнерного лимита его бюджет нужно настраивать вместе с `ATTACHMENT_DECODE_MEMORY_BYTES`. +- Admission control действует отдельно в каждой API-реплике; при изменении контейнерного лимита нужно совместно настраивать `ATTACHMENT_BODY_MEMORY_BYTES` и `ATTACHMENT_DECODE_MEMORY_BYTES`. +- Автоматический rollback переключает API обратно на предыдущий пул, но не откатывает уже применённые миграции и stateful-хранилища. Поэтому миграции должны оставаться обратно совместимыми как минимум с предыдущей версией приложения. - MinIO собирается из официального закреплённого source tag, поскольку готовые community images больше не публикуются. Это увеличивает время первого CI build. - Локальный HTTP допустим только для учебного стенда с синтетическими данными; удалённое развёртывание требует TLS. - -## Источники - -- [MinIO releases](https://github.com/minio/minio/releases) -- [MinIO Go SDK](https://github.com/minio/minio-go) -- [PostgreSQL constraints](https://www.postgresql.org/docs/current/ddl-constraints.html) -- [Go image package](https://pkg.go.dev/image) diff --git a/evidence/lab4-consistency.json b/evidence/lab4-consistency.json index e131f419..0c89b5df 100644 --- a/evidence/lab4-consistency.json +++ b/evidence/lab4-consistency.json @@ -2,11 +2,17 @@ "page_size": 10, "seeded_consistent": 11, "fresh_apply": { - "duration_ms": 58, + "duration_ms": 4, "report": { - "metadata_scanned": 206, - "objects_scanned": 205, - "consistent": 204, + "metadata_scanned": 14, + "objects_scanned": 13, + "consistent": 12, + "fresh_pending_attachments": 1, + "old_pending_attachments": 0, + "deleting_attachments": 0, + "fresh_unreferenced_attachments": 11, + "old_unreferenced_attachments": 0, + "deleted_attachment_objects": 0, "fresh_orphan_objects": 1, "old_orphan_objects": 0, "deleted_orphan_objects": 0, @@ -17,11 +23,17 @@ } }, "dry_run": { - "duration_ms": 65, + "duration_ms": 5, "report": { - "metadata_scanned": 206, - "objects_scanned": 205, - "consistent": 204, + "metadata_scanned": 14, + "objects_scanned": 13, + "consistent": 11, + "fresh_pending_attachments": 0, + "old_pending_attachments": 1, + "deleting_attachments": 0, + "fresh_unreferenced_attachments": 11, + "old_unreferenced_attachments": 0, + "deleted_attachment_objects": 0, "fresh_orphan_objects": 0, "old_orphan_objects": 1, "deleted_orphan_objects": 0, @@ -32,26 +44,38 @@ } }, "apply": { - "duration_ms": 77, + "duration_ms": 13, "report": { - "metadata_scanned": 206, - "objects_scanned": 205, - "consistent": 204, + "metadata_scanned": 14, + "objects_scanned": 13, + "consistent": 11, + "fresh_pending_attachments": 0, + "old_pending_attachments": 1, + "deleting_attachments": 0, + "fresh_unreferenced_attachments": 11, + "old_unreferenced_attachments": 0, + "deleted_attachment_objects": 1, "fresh_orphan_objects": 0, "old_orphan_objects": 1, "deleted_orphan_objects": 1, "fresh_missing_objects": 0, "referenced_missing_objects": 1, "old_unreferenced_metadata": 1, - "deleted_unreferenced_rows": 1 + "deleted_unreferenced_rows": 2 } }, "repeated_apply": { - "duration_ms": 38, + "duration_ms": 1, "report": { - "metadata_scanned": 205, - "objects_scanned": 204, - "consistent": 204, + "metadata_scanned": 12, + "objects_scanned": 11, + "consistent": 11, + "fresh_pending_attachments": 0, + "old_pending_attachments": 0, + "deleting_attachments": 0, + "fresh_unreferenced_attachments": 11, + "old_unreferenced_attachments": 0, + "deleted_attachment_objects": 0, "fresh_orphan_objects": 0, "old_orphan_objects": 0, "deleted_orphan_objects": 0, @@ -65,5 +89,6 @@ "orphan_deleted": true, "unused_metadata_deleted": true, "in_use_metadata_preserved": true, - "total_duration_ms": 515 + "abandoned_attachment_deleted": true, + "total_duration_ms": 328 } diff --git a/evidence/lab4-memory.json b/evidence/lab4-memory.json index 3531b378..5db3f899 100644 --- a/evidence/lab4-memory.json +++ b/evidence/lab4-memory.json @@ -7,11 +7,11 @@ "upload_rate_bytes_per_second": 1572864, "successful_uploads": 48, "failed_uploads": 0, - "duration_ms": 12629, - "heap_baseline_bytes": 181133200, - "heap_peak_bytes": 202374848, - "heap_delta_bytes": 21241648, - "rss_baseline_bytes": 241922048, - "rss_peak_bytes": 381063168, - "rss_delta_bytes": 139141120 + "duration_ms": 12974, + "heap_baseline_bytes": 153985824, + "heap_peak_bytes": 202505208, + "heap_delta_bytes": 48519384, + "rss_baseline_bytes": 335298560, + "rss_peak_bytes": 345976832, + "rss_delta_bytes": 10678272 } diff --git a/evidence/lab4-verification.txt b/evidence/lab4-verification.txt index 0b4bc585..9ad0af41 100644 --- a/evidence/lab4-verification.txt +++ b/evidence/lab4-verification.txt @@ -1,19 +1,30 @@ -Date: 2026-10-02 -Environment: linux/arm64 containers, Docker Compose, 2 API replicas +Date: 2026-10-09 +Source commit: 37d93c340e394ed4a923972accc6c872abb96076 +Result collection state: application, migrations, Compose and Nginx configuration matched the source commit; REPORT.md and evidence/ were refreshed afterward +Environment: Docker 29.2.1, linux/arm64, 2 CPUs, 2054299648 bytes RAM +Application topology: 2 API replicas, 512 MiB limit per replica -PASS gofmt for changed Go files -PASS go test ./... -PASS go build ./cmd/... +PASS gofmt for changed Go packages +PASS go test ./internal/... +PASS go build ./cmd/messenger and ./cmd/lab4experiment in Docker build PASS make check -PASS make test BASE_URL=http://localhost:8080 +PASS docker compose config --quiet +PASS sh -n scripts/rolling-update.sh +PASS make test BASE_URL=http://127.0.0.1:28080 PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. -PASS MinIO server RELEASE.2025-10-15T17-29-55Z built from the official source tag -PASS mc RELEASE.2025-08-13T08-35-41Z built from the official source tag -PASS bucket bootstrap executed twice without an error +PASS PostgreSQL and Valkey integration suites +PASS MinIO bootstrap completed twice without an error PASS anonymous bucket request returned HTTP 403 -PASS application credentials can list only the configured bucket and cannot create another bucket +PASS real pending -> deleting -> delete on PostgreSQL +PASS stale pending candidate cannot claim an attachment already changed to ready PASS 48 of 48 uploads succeeded in 4 waves with concurrency 12 -PASS reconciler preserved fresh and referenced anomalies, removed safe old anomalies, and repeated apply made no changes +PASS reconciler preserved fresh and referenced anomalies +PASS reconciler deleted an old orphan, old unreferenced missing metadata, and old pending data +PASS repeated reconciliation apply made no further changes +PASS Nginx accepted the candidate upstream with nginx -t and atomic reload +PASS 20 of 20 health requests returned HTTP 200 from only the two candidate API instances -The pull request CI runs OpenAPI validation, race tests, lint, integration tests, -persistence and API-replica failover on the exact pushed commit. +CI additionally runs full OpenAPI validation, race tests, golangci-lint, +persistence and API-replica failover on the exact pushed commit. Production +deployment publishes verified images and passes immutable repository@sha256 +references to the manually approved environment job. -- 2.54.0 From 99cc86766f58b77a8202c093a0686f711d89aad3 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:41:03 +0300 Subject: [PATCH 11/15] fix: format bootstrap package --- internal/bootstrap/server.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/bootstrap/server.go b/internal/bootstrap/server.go index e21e5715..c432cce0 100644 --- a/internal/bootstrap/server.go +++ b/internal/bootstrap/server.go @@ -9,9 +9,9 @@ import ( "os/signal" "syscall" - "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/attachment" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger/httpapi" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password" -- 2.54.0 From 13151e66aa7051853d3ee7c5ec5614b773a03674 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 9 Oct 2026 13:46:43 +0300 Subject: [PATCH 12/15] fix: isolate runtime upstream mount --- Dockerfile | 1 + compose.yaml | 2 -- deploy/compose.runtime.yaml | 4 ++++ scripts/rolling-update.sh | 2 +- 4 files changed, 6 insertions(+), 3 deletions(-) create mode 100644 deploy/compose.runtime.yaml diff --git a/Dockerfile b/Dockerfile index e903874c..ff27469a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -29,6 +29,7 @@ COPY monitoring/grafana/dashboards /etc/grafana/dashboards FROM nginx:1.30.5-alpine AS loadbalancer COPY nginx/nginx.conf /etc/nginx/nginx.conf +COPY nginx/upstream.conf /etc/nginx/conf.d/upstream.conf FROM alpine:3.24.2 diff --git a/compose.yaml b/compose.yaml index 72b6ca6f..2373efcc 100644 --- a/compose.yaml +++ b/compose.yaml @@ -177,8 +177,6 @@ services: image: ${NGINX_IMAGE:-mtusi-nginx:lab4} ports: - "${API_BIND_ADDRESS}:8080" - volumes: - - ${NGINX_UPSTREAM_FILE:-./nginx/upstream.conf}:/etc/nginx/conf.d/upstream.conf:ro depends_on: api: condition: service_healthy diff --git a/deploy/compose.runtime.yaml b/deploy/compose.runtime.yaml new file mode 100644 index 00000000..b9dcd470 --- /dev/null +++ b/deploy/compose.runtime.yaml @@ -0,0 +1,4 @@ +services: + nginx: + volumes: + - ${NGINX_UPSTREAM_FILE:?NGINX_UPSTREAM_FILE is required}:/etc/nginx/conf.d/upstream.conf:ro diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh index cda43090..3a36b1fd 100755 --- a/scripts/rolling-update.sh +++ b/scripts/rolling-update.sh @@ -34,7 +34,7 @@ load_manifest() { } compose() { - docker compose -f compose.yaml -f deploy/compose.images.yaml "$@" + docker compose -f compose.yaml -f deploy/compose.images.yaml -f deploy/compose.runtime.yaml "$@" } container_name() { -- 2.54.0 From 3815be3493636a0b0e6ac15ea9ca2f6df9358b02 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 30 Oct 2026 14:01:01 +0300 Subject: [PATCH 13/15] fix: preserve reconciliation dry runs --- internal/reconcile/reconcile.go | 4 +++ internal/reconcile/reconcile_test.go | 48 ++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go index eb2b0911..80a91755 100644 --- a/internal/reconcile/reconcile.go +++ b/internal/reconcile/reconcile.go @@ -227,6 +227,7 @@ func (r *Reconciler) handleMissingObject( ) error { report.MetadataScanned++ if metadata.Status == model.AttachmentDeleting { + report.DeletingAttachments++ return r.deleteClaimedMetadata(ctx, metadata, report) } if metadata.CreatedAt.After(cutoff) { @@ -252,6 +253,9 @@ func (r *Reconciler) handleMissingObject( } func (r *Reconciler) deleteClaimedMetadata(ctx context.Context, metadata model.Attachment, report *Report) error { + if !r.config.Apply { + return nil + } deleted, err := r.metadata.DeleteAttachmentIfDeleting(ctx, metadata.ID) if err != nil { return fmt.Errorf("delete missing attachment metadata %q: %w", metadata.ID, err) diff --git a/internal/reconcile/reconcile_test.go b/internal/reconcile/reconcile_test.go index 62471a65..5b43b904 100644 --- a/internal/reconcile/reconcile_test.go +++ b/internal/reconcile/reconcile_test.go @@ -75,6 +75,54 @@ func TestReconcilerRechecksOrphanBeforeDelete(t *testing.T) { require.Contains(t, objects.items, "attachments/a/original") } +func TestReconcilerDeletingAttachmentRespectsApplyMode(t *testing.T) { + now := time.Now().UTC() + key := "attachments/a/original" + tests := []struct { + name string + apply bool + objectPresent bool + }{ + {name: "dry run with object", objectPresent: true}, + {name: "dry run without object"}, + {name: "apply with object", apply: true, objectPresent: true}, + {name: "apply without object", apply: true}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + metadata := &metadataStub{items: map[string]model.Attachment{ + key: attachment("a", key, model.AttachmentDeleting, now.Add(-time.Hour), false), + }} + objects := &objectStub{items: make(map[string]model.StoredObject)} + if test.objectPresent { + objects.items[key] = model.StoredObject{Key: key, LastModified: now.Add(-time.Hour)} + } + reconciler, err := New(metadata, objects, Config{ + Prefix: "attachments/", PageSize: 1, GraceTime: time.Minute, + UnreferencedRetention: time.Hour, Apply: test.apply, Now: func() time.Time { return now }, + }) + require.NoError(t, err) + + report, err := reconciler.Run(context.Background()) + require.NoError(t, err) + require.Equal(t, 1, report.DeletingAttachments) + var expectedDeletedRows, expectedDeletedObjects int + if test.apply { + expectedDeletedRows = 1 + } + if test.apply && test.objectPresent { + expectedDeletedObjects = 1 + } + require.Equal(t, expectedDeletedRows, report.DeletedUnreferencedRows) + require.Equal(t, expectedDeletedObjects, report.DeletedAttachmentObjects) + _, metadataExists := metadata.items[key] + require.Equal(t, !test.apply, metadataExists) + _, objectExists := objects.items[key] + require.Equal(t, test.objectPresent && !test.apply, objectExists) + }) + } +} + func TestNewRejectsInvalidRetention(t *testing.T) { _, err := New(&metadataStub{}, &objectStub{}, Config{PageSize: 1}) require.Error(t, err) -- 2.54.0 From 05d9bb0ff2ffd66efd9ba31a65d3952516bbe507 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 30 Oct 2026 14:01:03 +0300 Subject: [PATCH 14/15] fix: validate message request fields --- internal/messenger/httpapi/handlers.go | 10 +++--- internal/messenger/httpapi/request.go | 20 +++++++++++ internal/messenger/httpapi/server_test.go | 41 +++++++++++++++++++++++ 3 files changed, 65 insertions(+), 6 deletions(-) diff --git a/internal/messenger/httpapi/handlers.go b/internal/messenger/httpapi/handlers.go index 72d307ce..e4d4e8aa 100644 --- a/internal/messenger/httpapi/handlers.go +++ b/internal/messenger/httpapi/handlers.go @@ -208,18 +208,16 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { if !valid { return invalidRequest() } - var input struct { - Text string `json:"text"` - AttachmentIDs []string `json:"attachment_ids"` - } + var input createMessageRequest if err := readJSON(w, r, &input); err != nil { return err } - if !validMessage(input.Text, input.AttachmentIDs) || !canonicalAttachmentIDs(input.AttachmentIDs) { + text, attachmentIDs, valid := input.values() + if !valid || !validMessage(text, attachmentIDs) || !canonicalAttachmentIDs(attachmentIDs) { return invalidRequest() } message, replay, err := s.messageRepository.CreateMessage( - r.Context(), chatID, user.ID, input.Text, input.AttachmentIDs, key, s.idempotencyTTL, + r.Context(), chatID, user.ID, text, attachmentIDs, key, s.idempotencyTTL, ) if errors.Is(err, model.ErrNotFound) { return notFound() diff --git a/internal/messenger/httpapi/request.go b/internal/messenger/httpapi/request.go index c0a51591..63cb6944 100644 --- a/internal/messenger/httpapi/request.go +++ b/internal/messenger/httpapi/request.go @@ -20,6 +20,26 @@ const maxRequestBytes = 1 << 20 var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) +type createMessageRequest struct { + Text json.RawMessage `json:"text"` + AttachmentIDs json.RawMessage `json:"attachment_ids"` +} + +func (r createMessageRequest) values() (string, []string, bool) { + var text *string + if len(r.Text) == 0 || json.Unmarshal(r.Text, &text) != nil || text == nil { + return "", nil, false + } + if len(r.AttachmentIDs) == 0 { + return *text, nil, true + } + var attachmentIDs *[]string + if json.Unmarshal(r.AttachmentIDs, &attachmentIDs) != nil || attachmentIDs == nil { + return "", nil, false + } + return *text, *attachmentIDs, true +} + func readJSON(w http.ResponseWriter, r *http.Request, target any) *apiError { mediaType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil || mediaType != "application/json" || (params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) { diff --git a/internal/messenger/httpapi/server_test.go b/internal/messenger/httpapi/server_test.go index d11d1b2a..d272bbee 100644 --- a/internal/messenger/httpapi/server_test.go +++ b/internal/messenger/httpapi/server_test.go @@ -259,6 +259,47 @@ func (s *MessengerSuite) TestMessageCreationValidatesIdempotencyKey() { } } +func (s *MessengerSuite) TestMessageCreationValidatesFieldPresenceAndTypes() { + store := messengerStoreStub{userByID: model.User{ID: "user-id"}} + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) + attachmentID := "00000000-0000-0000-0000-000000000002" + invalidBodies := []string{ + `{"attachment_ids":["` + attachmentID + `"]}`, + `{"text":null,"attachment_ids":["` + attachmentID + `"]}`, + `{"text":"x","attachment_ids":null}`, + `{"text":1}`, + `{"text":"x","attachment_ids":{}}`, + } + for _, body := range invalidBodies { + response := createMessageRequestResponse(server, body) + s.Equal(http.StatusBadRequest, response.Code, body) + } + + validBodies := []string{ + `{"text":"message"}`, + `{"text":"message","attachment_ids":[]}`, + `{"text":"","attachment_ids":["` + attachmentID + `"]}`, + } + for _, body := range validBodies { + response := createMessageRequestResponse(server, body) + s.Equal(http.StatusCreated, response.Code, body) + } +} + +func createMessageRequestResponse(server *Server, body string) *httptest.ResponseRecorder { + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/chats/00000000-0000-0000-0000-000000000001/messages", + strings.NewReader(body), + ) + request.Header.Set("Authorization", "Bearer valid-token") + request.Header.Set("Content-Type", "application/json") + request.Header.Set("Idempotency-Key", "message-key") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + return response +} + func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody() { t := s.T() store := messengerStoreStub{ -- 2.54.0 From fa530790dcaf289226f299ff300b436b89f928c9 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 30 Oct 2026 14:08:11 +0300 Subject: [PATCH 15/15] test: cover reconciliation dry runs --- internal/postgres/store_integration_test.go | 38 +++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index 48f60842..ce03fb9a 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -16,6 +16,7 @@ import ( "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model" "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile" ) type PostgresSuite struct { @@ -192,6 +193,43 @@ func (s *PostgresSuite) TestAttachmentDeletionClaimChecksLifecycleUnderLock() { s.Equal(model.AttachmentReady, visible.Status) } +func (s *PostgresSuite) TestReconciliationDryRunPreservesDeletingAttachment() { + owner, chatID := createOwnerAndChat(s.T(), s.store) + pending, err := s.store.CreatePendingAttachment(context.Background(), model.Attachment{ + ID: uuid.NewString(), ChatID: chatID, OwnerID: owner.ID, Filename: "deleting.png", + ContentType: "image/png", SizeBytes: 128, SHA256: strings.Repeat("e", 64), + ObjectKey: "attachments/" + uuid.NewString() + "/original", + }) + s.Require().NoError(err) + claimed, err := s.store.ClaimAttachmentForDeletion(context.Background(), pending, time.Now().Add(time.Hour)) + s.Require().NoError(err) + s.True(claimed) + + reconciler, err := reconcile.New(s.store, emptyObjectStore{}, reconcile.Config{ + Prefix: "attachments/", PageSize: 1000, GraceTime: time.Minute, + UnreferencedRetention: time.Hour, + }) + s.Require().NoError(err) + report, err := reconciler.Run(context.Background()) + s.Require().NoError(err) + s.Zero(report.DeletedUnreferencedRows) + + var status string + err = s.pool.QueryRow(context.Background(), "SELECT status FROM attachments WHERE id = $1", pending.ID).Scan(&status) + s.Require().NoError(err) + s.Equal(model.AttachmentDeleting, status) +} + +type emptyObjectStore struct{} + +func (emptyObjectStore) List(context.Context, string, string, int) ([]model.StoredObject, string, error) { + return nil, "", nil +} + +func (emptyObjectStore) Delete(context.Context, string) error { + return errors.New("unexpected object deletion") +} + func (s *PostgresSuite) TestMessageRejectsAttachmentFromAnotherChat() { owner, firstChatID := createOwnerAndChat(s.T(), s.store) secondChat, err := s.store.CreateChat(context.Background(), "Second", []string{owner.ID}, owner.ID) -- 2.54.0