feat: add shared idempotency and replica identity

This commit is contained in:
2026-10-02 15:59:16 +03:00
parent 32d21ec135
commit da1ab2d216
18 changed files with 630 additions and 90 deletions
+13 -8
View File
@@ -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{
+34
View File
@@ -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)
}
+1 -1
View File
@@ -1,4 +1,4 @@
module gitea.privcloud.tech/dizi/mtusi2026lab2
module gitea.privcloud.tech/dizi/mtusi2026lab3
go 1.26.0
+85 -32
View File
@@ -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 == "" {
+10 -11
View File
@@ -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
}
+3 -3
View File
@@ -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 {
+15 -3
View File
@@ -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
}
+2 -2
View File
@@ -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)
}
+8
View File
@@ -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{}),
)
+1 -1
View File
@@ -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"
)
+11
View File
@@ -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"`
+19 -5
View File
@@ -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
}
+66 -4
View File
@@ -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 {
+5 -4
View File
@@ -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")
)
+196 -12
View File
@@ -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
}
+141 -3
View File
@@ -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
}
+1 -1
View File
@@ -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) {
+19
View File
@@ -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);