From da1ab2d216b9bbef588c4219d8c6cc061e46f842 Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 2 Oct 2026 15:59:16 +0300 Subject: [PATCH] feat: add shared idempotency and replica identity --- cmd/messenger/main.go | 21 +- cmd/migrate/main.go | 34 +++ go.mod | 2 +- internal/config/config.go | 117 ++++++++--- internal/database/database.go | 21 +- internal/messenger/auth.go | 6 +- internal/messenger/handlers.go | 18 +- internal/messenger/messenger_interface.go | 4 +- internal/messenger/metrics.go | 8 + internal/messenger/model.go | 2 +- internal/messenger/request.go | 11 + internal/messenger/server.go | 24 ++- internal/messenger/server_test.go | 70 ++++++- internal/postgres/errors.go | 9 +- internal/postgres/store.go | 208 +++++++++++++++++-- internal/postgres/store_integration_test.go | 144 ++++++++++++- internal/session/session_integration_test.go | 2 +- migrations/0002_message_idempotency.sql | 19 ++ 18 files changed, 630 insertions(+), 90 deletions(-) create mode 100644 cmd/migrate/main.go create mode 100644 migrations/0002_message_idempotency.sql diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 8341bce..9926f0e 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -9,13 +9,13 @@ import ( "os/signal" "syscall" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/config" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/database" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/logger" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/messenger" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/password" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/logger" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/messenger" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/password" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/session" ) func main() { @@ -31,11 +31,14 @@ func run(logger *slog.Logger) error { 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, - MigrationTimeout: settings.MigrationTimeout, }) if err != nil { return err @@ -60,7 +63,9 @@ func run(logger *slog.Logger) error { sessions, passwords, settings.SessionTTL, + settings.IdempotencyTTL, settings.RequestTimeout, + instanceID, settings.SwaggerPort, ) server := &http.Server{ diff --git a/cmd/migrate/main.go b/cmd/migrate/main.go new file mode 100644 index 0000000..81dac78 --- /dev/null +++ b/cmd/migrate/main.go @@ -0,0 +1,34 @@ +package main + +import ( + "context" + "fmt" + "os" + + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/database" +) + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func run() 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/go.mod b/go.mod index 87b3785..b644b7d 100644 --- a/go.mod +++ b/go.mod @@ -1,4 +1,4 @@ -module gitea.privcloud.tech/dizi/mtusi2026lab2 +module gitea.privcloud.tech/dizi/mtusi2026lab3 go 1.26.0 diff --git a/internal/config/config.go b/internal/config/config.go index 4804110..4457141 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -16,13 +16,13 @@ type Config struct { 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 - MigrationTimeout time.Duration RequestTimeout time.Duration HTTPReadHeaderTimeout time.Duration HTTPReadTimeout time.Duration @@ -37,6 +37,27 @@ type Config struct { 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() @@ -49,7 +70,7 @@ func Load() (Config, error) { if err != nil { return Config{}, err } - databaseURL, err := requiredString(values, "DATABASE_URL") + database, err := loadDatabaseConfig(values) if err != nil { return Config{}, err } @@ -69,31 +90,7 @@ func Load() (Config, error) { if err != nil { return Config{}, err } - maxConns, err := integer(values, "DB_MAX_CONNS", 1, 100) - if err != nil { - return Config{}, err - } - minConns, err := integer(values, "DB_MIN_CONNS", 0, maxConns) - if err != nil { - return Config{}, err - } - maxConnectionAge, err := seconds(values, "DB_MAX_CONNECTION_AGE_SECONDS", 1, 86400) - if err != nil { - return Config{}, err - } - maxConnectionIdle, err := seconds(values, "DB_MAX_CONNECTION_IDLE_SECONDS", 1, 86400) - if err != nil { - return Config{}, err - } - healthCheckPeriod, err := seconds(values, "DB_HEALTH_CHECK_SECONDS", 1, 3600) - if err != nil { - return Config{}, err - } - dependencyTimeout, err := seconds(values, "DEPENDENCY_TIMEOUT_SECONDS", 1, 60) - if err != nil { - return Config{}, err - } - migrationTimeout, err := seconds(values, "MIGRATION_TIMEOUT_SECONDS", 1, 600) + idempotencyTTL, err := seconds(values, "IDEMPOTENCY_TTL_SECONDS", 86400, 86400*30) if err != nil { return Config{}, err } @@ -147,11 +144,12 @@ func Load() (Config, error) { } return Config{ - Address: net.JoinHostPort(host, port), DatabaseURL: databaseURL, CacheURL: cacheURL, - SessionTTL: sessionTTL, DBMaxConns: int32(maxConns), DBMinConns: int32(minConns), - DBMaxConnectionAge: maxConnectionAge, DBMaxConnectionIdle: maxConnectionIdle, - DBHealthCheckPeriod: healthCheckPeriod, DependencyTimeout: dependencyTimeout, - MigrationTimeout: migrationTimeout, RequestTimeout: requestTimeout, + 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), @@ -161,6 +159,61 @@ func Load() (Config, error) { }, 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 == "" { diff --git a/internal/database/database.go b/internal/database/database.go index a690415..a02ff7c 100644 --- a/internal/database/database.go +++ b/internal/database/database.go @@ -8,7 +8,7 @@ import ( "github.com/jackc/pgx/v5/pgxpool" - "gitea.privcloud.tech/dizi/mtusi2026lab2/migrations" + "gitea.privcloud.tech/dizi/mtusi2026lab3/migrations" ) var ( @@ -20,7 +20,6 @@ var ( 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") - errMigrationTimeout = errors.New("database migration timeout must be positive") ) type Config struct { @@ -31,7 +30,6 @@ type Config struct { MaxConnectionIdle time.Duration HealthCheckPeriod time.Duration ConnectTimeout time.Duration - MigrationTimeout time.Duration } func Open(ctx context.Context, config Config) (*pgxpool.Pool, error) { @@ -59,15 +57,18 @@ func Open(ctx context.Context, config Config) (*pgxpool.Pool, error) { return nil, fmt.Errorf("ping database: %w", err) } - migrationCtx, cancel := context.WithTimeout(ctx, config.MigrationTimeout) - defer cancel() - if err := applyMigrations(migrationCtx, pool, migrations.FS); err != nil { - pool.Close() - return nil, 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 == "": @@ -86,8 +87,6 @@ func validateConfig(config Config) error { return errHealthCheckPeriod case config.ConnectTimeout <= 0: return errConnectionTimeout - case config.MigrationTimeout <= 0: - return errMigrationTimeout default: return nil } diff --git a/internal/messenger/auth.go b/internal/messenger/auth.go index 5bf621d..5c6eb57 100644 --- a/internal/messenger/auth.go +++ b/internal/messenger/auth.go @@ -6,9 +6,9 @@ import ( "net/http" "strings" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/session" ) func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { diff --git a/internal/messenger/handlers.go b/internal/messenger/handlers.go index 1b0fc9b..e9ad0fd 100644 --- a/internal/messenger/handlers.go +++ b/internal/messenger/handlers.go @@ -9,8 +9,8 @@ import ( "time" "unicode/utf8" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" ) var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) @@ -202,6 +202,10 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { 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"` } @@ -211,13 +215,21 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { if !validText(input.Text, 4000) { return invalidRequest() } - message, err := s.messengerStore.CreateMessage(r.Context(), chatID, user.ID, input.Text) + 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 } diff --git a/internal/messenger/messenger_interface.go b/internal/messenger/messenger_interface.go index ed56628..1761254 100644 --- a/internal/messenger/messenger_interface.go +++ b/internal/messenger/messenger_interface.go @@ -4,7 +4,7 @@ import ( "context" "time" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" ) type MessengerStore interface { @@ -15,7 +15,7 @@ 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) (model.Message, 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) } diff --git a/internal/messenger/metrics.go b/internal/messenger/metrics.go index 1f6272d..8073542 100644 --- a/internal/messenger/metrics.go +++ b/internal/messenger/metrics.go @@ -15,6 +15,7 @@ type metrics struct { requests *prometheus.CounterVec duration *prometheus.HistogramVec inFlight prometheus.Gauge + replays prometheus.Counter handler http.Handler } @@ -40,11 +41,18 @@ func newMetrics() *metrics { 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{}), ) diff --git a/internal/messenger/model.go b/internal/messenger/model.go index 65474b6..acbe99d 100644 --- a/internal/messenger/model.go +++ b/internal/messenger/model.go @@ -1,7 +1,7 @@ package messenger import ( - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" "github.com/google/uuid" ) diff --git a/internal/messenger/request.go b/internal/messenger/request.go index 8b9a7cc..da264ec 100644 --- a/internal/messenger/request.go +++ b/internal/messenger/request.go @@ -9,6 +9,7 @@ import ( "mime" "net/http" "net/url" + "regexp" "strconv" "strings" "time" @@ -17,6 +18,8 @@ import ( 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")) { @@ -54,6 +57,14 @@ 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"` diff --git a/internal/messenger/server.go b/internal/messenger/server.go index da676b9..3cc2ba0 100644 --- a/internal/messenger/server.go +++ b/internal/messenger/server.go @@ -13,7 +13,9 @@ type Server struct { sessions SessionStore passwords PasswordService sessionTTL time.Duration + idempotencyTTL time.Duration requestTTL time.Duration + instanceID string logger *slog.Logger swaggerPort string metrics *metrics @@ -30,10 +32,21 @@ func (w *statusWriter) WriteHeader(status int) { w.ResponseWriter.WriteHeader(status) } -func NewServer(logger *slog.Logger, messages MessengerStore, sessions SessionStore, passwords PasswordService, sessionTTL, requestTTL time.Duration, swaggerPort string) *Server { +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, requestTTL: requestTTL, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), + sessionTTL: sessionTTL, idempotencyTTL: idempotencyTTL, requestTTL: requestTTL, + instanceID: instanceID, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), } s.ready.Store(true) return s @@ -48,6 +61,7 @@ func (s *Server) Handler() http.Handler { } 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) @@ -70,8 +84,8 @@ func (s *Server) serve(w http.ResponseWriter, r *http.Request) { 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, OPTIONS") - wrapped.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type") + 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 } @@ -92,7 +106,7 @@ func (s *Server) allowSwaggerOrigin(w http.ResponseWriter, r *http.Request) bool return false } w.Header().Set("Access-Control-Allow-Origin", origin) - w.Header().Set("Access-Control-Expose-Headers", "X-Request-Id") + 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 index 9d521c9..fe97aa5 100644 --- a/internal/messenger/server_test.go +++ b/internal/messenger/server_test.go @@ -3,6 +3,7 @@ package messenger import ( "context" "errors" + "fmt" "io" "log/slog" "net/http" @@ -11,7 +12,8 @@ import ( "testing" "time" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" ) var errDependency = errors.New("dependency unavailable") @@ -22,6 +24,9 @@ type messengerStoreStub struct { userByIDErr error credentials model.UserCredentials credentialsErr error + message model.Message + messageReplay bool + messageErr error } func (s messengerStoreStub) Ping(context.Context) error { return s.pingErr } @@ -43,8 +48,8 @@ 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 (messengerStoreStub) CreateMessage(context.Context, string, string, string) (model.Message, error) { - return model.Message{}, 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 @@ -157,9 +162,66 @@ func TestRegistrationRejectsWhitespacePassword(t *testing.T) { } } +func TestInstanceHeaderIsSetOnSuccessAndError(t *testing.T) { + server := 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 TestMessageCreationValidatesIdempotencyKey(t *testing.T) { + store := messengerStoreStub{userByID: model.User{ID: "user-id"}} + server := 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 TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody(t *testing.T) { + store := messengerStoreStub{ + userByID: model.User{ID: "user-id"}, + messageErr: fmt.Errorf("create message: %w", postgres.ErrIdempotencyConflict), + } + server := 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 newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { logger := slog.New(slog.NewTextHandler(io.Discard, nil)) - return NewServer(logger, messages, sessions, passwords, time.Hour, time.Second, "8081") + return NewServer(logger, messages, sessions, passwords, time.Hour, 24*time.Hour, time.Second, "test-instance", "8081") } func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { diff --git a/internal/postgres/errors.go b/internal/postgres/errors.go index f90becb..4e0c378 100644 --- a/internal/postgres/errors.go +++ b/internal/postgres/errors.go @@ -3,8 +3,9 @@ package postgres import "errors" var ( - ErrConflict = errors.New("conflict") - ErrNotFound = errors.New("not found") - ErrInvalidMembers = errors.New("invalid members") - ErrInvalidCursor = errors.New("invalid cursor") + 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/store.go b/internal/postgres/store.go index 949171d..8096d7e 100644 --- a/internal/postgres/store.go +++ b/internal/postgres/store.go @@ -1,16 +1,19 @@ package postgres import ( + "bytes" "context" + "crypto/sha256" "errors" "fmt" + "time" "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/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" ) type Store struct { @@ -114,7 +117,7 @@ func (s *Store) CreateChat( if err != nil { return model.Chat{}, fmt.Errorf("begin create chat transaction: %w", err) } - defer func() { _ = tx.Rollback(ctx) }() + defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() valid, err := allUsersExist(ctx, tx, memberIDs) if err != nil { @@ -324,19 +327,201 @@ func (s *Store) CreateMessage( chatID string, senderID string, text string, + idempotencyKey string, + idempotencyTTL time.Duration, +) (model.Message, bool, error) { + 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 + } + + 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 { + 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 + } +} + +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 := 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 := 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) - SELECT $1, $2, $3, $4 - WHERE EXISTS ( - SELECT 1 - FROM chat_members - WHERE chat_id = $2 AND user_id = $3 - ) + VALUES ($1, $2, $3, $4) RETURNING id, chat_id, sender_id, text, created_at` var message model.Message - err := s.pool.QueryRow(ctx, query, uuid.NewString(), chatID, senderID, text).Scan( + 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 := tx.QueryRow(ctx, query, messageID).Scan( &message.ID, &message.ChatID, &message.SenderID, @@ -344,12 +529,11 @@ func (s *Store) CreateMessage( &message.CreatedAt, ) if errors.Is(err, pgx.ErrNoRows) { - return model.Message{}, ErrNotFound + return model.Message{}, fmt.Errorf("idempotency result message not found") } if err != nil { - return model.Message{}, fmt.Errorf("create message: %w", err) + return model.Message{}, fmt.Errorf("get idempotency result message: %w", err) } - return message, nil } diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index cc1112e..b0efe22 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -12,8 +12,9 @@ import ( "github.com/google/uuid" "github.com/jackc/pgx/v5/pgxpool" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/database" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" ) func TestConcurrentUsernameCreation(t *testing.T) { @@ -69,6 +70,140 @@ func TestCreateChatRollsBackForUnknownMember(t *testing.T) { } } +func TestMessageIdempotencyReplayAndConflict(t *testing.T) { + pool := openTestDatabase(t) + store := postgres.New(pool) + 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 TestConcurrentMessageIdempotency(t *testing.T) { + pool := openTestDatabase(t) + 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 TestMessageIdempotencyScopeAndExpiry(t *testing.T) { + pool := openTestDatabase(t) + store := postgres.New(pool) + 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 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") @@ -76,11 +211,14 @@ func openTestDatabase(t *testing.T) *pgxpool.Pool { URL: url, MinConnections: 0, MaxConnections: 10, MaxConnectionAge: time.Minute, MaxConnectionIdle: time.Minute, HealthCheckPeriod: time.Minute, ConnectTimeout: 5 * time.Second, - MigrationTimeout: 30 * 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) + } t.Cleanup(pool.Close) return pool } diff --git a/internal/session/session_integration_test.go b/internal/session/session_integration_test.go index 8a19a4b..8016b3f 100644 --- a/internal/session/session_integration_test.go +++ b/internal/session/session_integration_test.go @@ -10,7 +10,7 @@ import ( "github.com/google/uuid" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/session" ) func TestSessionLifecycle(t *testing.T) { diff --git a/migrations/0002_message_idempotency.sql b/migrations/0002_message_idempotency.sql new file mode 100644 index 0000000..91443a4 --- /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);