feat: use postgres

2026-04-26 20:34:39 +02:00
parent 48b0056b49
commit fe829285a6
365 changed files with 29223 additions and 24049 deletions
@@ -2,7 +2,6 @@ package replay

 import (
 	"context"
-	"crypto/tls"
 	"encoding/base64"
 	"errors"
 	"fmt"
@@ -22,15 +21,13 @@ type RedisStore struct {
 	reserveTimeout time.Duration
 }

-// NewRedisStore constructs a Redis-backed replay store that reuses the
-// SessionCache Redis deployment settings and applies the replay-specific key
-// namespace and timeout controls from replayCfg.
-func NewRedisStore(sessionCfg config.SessionCacheRedisConfig, replayCfg config.ReplayRedisConfig) (*RedisStore, error) {
-	if strings.TrimSpace(sessionCfg.Addr) == "" {
-		return nil, errors.New("new redis replay store: redis addr must not be empty")
-	}
-	if sessionCfg.DB < 0 {
-		return nil, errors.New("new redis replay store: redis db must not be negative")
+// NewRedisStore constructs a Redis-backed replay store that uses client and
+// applies the replay-specific namespace and timeout controls from replayCfg.
+// The store does not own the client; the runtime supplies a shared
+// *redis.Client.
+func NewRedisStore(client *redis.Client, replayCfg config.ReplayRedisConfig) (*RedisStore, error) {
+	if client == nil {
+		return nil, errors.New("new redis replay store: nil redis client")
 	}
 	if strings.TrimSpace(replayCfg.KeyPrefix) == "" {
 		return nil, errors.New("new redis replay store: replay key prefix must not be empty")
@@ -39,54 +36,13 @@ func NewRedisStore(sessionCfg config.SessionCacheRedisConfig, replayCfg config.R
 		return nil, errors.New("new redis replay store: reserve timeout must be positive")
 	}

-	options := &redis.Options{
-		Addr:            sessionCfg.Addr,
-		Username:        sessionCfg.Username,
-		Password:        sessionCfg.Password,
-		DB:              sessionCfg.DB,
-		Protocol:        2,
-		DisableIdentity: true,
-	}
-	if sessionCfg.TLSEnabled {
-		options.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
-	}
-
 	return &RedisStore{
-		client:         redis.NewClient(options),
+		client:         client,
 		keyPrefix:      replayCfg.KeyPrefix,
 		reserveTimeout: replayCfg.ReserveTimeout,
 	}, nil
 }

-// Close releases the underlying Redis client resources.
-func (s *RedisStore) Close() error {
-	if s == nil || s.client == nil {
-		return nil
-	}
-
-	return s.client.Close()
-}
-
-// Ping verifies that the configured Redis backend is reachable within the
-// replay reserve timeout budget.
-func (s *RedisStore) Ping(ctx context.Context) error {
-	if s == nil || s.client == nil {
-		return errors.New("ping redis replay store: nil store")
-	}
-	if ctx == nil {
-		return errors.New("ping redis replay store: nil context")
-	}
-
-	pingCtx, cancel := context.WithTimeout(ctx, s.reserveTimeout)
-	defer cancel()
-
-	if err := s.client.Ping(pingCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis replay store: %w", err)
-	}
-
-	return nil
-}
-
 // Reserve records the authenticated deviceSessionID and requestID pair for
 // ttl. It rejects duplicates while the reservation remains active.
 func (s *RedisStore) Reserve(ctx context.Context, deviceSessionID string, requestID string, ttl time.Duration) error {
@@ -10,81 +10,64 @@ import (
 	"galaxy/gateway/internal/config"

 	"github.com/alicebob/miniredis/v2"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

+func newRedisClient(t *testing.T, addr string) *redis.Client {
+	t.Helper()
+
+	client := redis.NewClient(&redis.Options{
+		Addr:            addr,
+		Protocol:        2,
+		DisableIdentity: true,
+	})
+	t.Cleanup(func() {
+		assert.NoError(t, client.Close())
+	})
+
+	return client
+}
+
 func TestNewRedisStore(t *testing.T) {
 	t.Parallel()

 	server := miniredis.RunT(t)
+	client := newRedisClient(t, server.Addr())
+
+	validCfg := config.ReplayRedisConfig{
+		KeyPrefix:      "gateway:replay:",
+		ReserveTimeout: 250 * time.Millisecond,
+	}

 	tests := []struct {
-		name       string
-		sessionCfg config.SessionCacheRedisConfig
-		replayCfg  config.ReplayRedisConfig
-		wantErr    string
+		name    string
+		client  *redis.Client
+		cfg     config.ReplayRedisConfig
+		wantErr string
 	}{
+		{name: "valid config", client: client, cfg: validCfg},
+		{name: "nil client", client: nil, cfg: validCfg, wantErr: "nil redis client"},
 		{
-			name: "valid config",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-				DB:   2,
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-		},
-		{
-			name: "empty redis addr",
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis addr must not be empty",
-		},
-		{
-			name: "negative redis db",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-				DB:   -1,
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis db must not be negative",
-		},
-		{
-			name: "empty replay key prefix",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-			},
-			replayCfg: config.ReplayRedisConfig{
-				ReserveTimeout: 250 * time.Millisecond,
-			},
+			name:    "empty replay key prefix",
+			client:  client,
+			cfg:     config.ReplayRedisConfig{ReserveTimeout: 250 * time.Millisecond},
 			wantErr: "replay key prefix must not be empty",
 		},
 		{
-			name: "non-positive reserve timeout",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix: "gateway:replay:",
-			},
+			name:    "non-positive reserve timeout",
+			client:  client,
+			cfg:     config.ReplayRedisConfig{KeyPrefix: "gateway:replay:"},
 			wantErr: "reserve timeout must be positive",
 		},
 	}

 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()

-			store, err := NewRedisStore(tt.sessionCfg, tt.replayCfg)
+			store, err := NewRedisStore(tt.client, tt.cfg)
 			if tt.wantErr != "" {
 				require.Error(t, err)
 				require.ErrorContains(t, err, tt.wantErr)
@@ -92,28 +75,16 @@ func TestNewRedisStore(t *testing.T) {
 			}

 			require.NoError(t, err)
-			t.Cleanup(func() {
-				assert.NoError(t, store.Close())
-			})
+			require.NotNil(t, store)
 		})
 	}
 }

-func TestRedisStorePing(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	store := newTestRedisStore(t, server, config.SessionCacheRedisConfig{}, config.ReplayRedisConfig{})
-
-	require.NoError(t, store.Ping(context.Background()))
-}
-
 func TestRedisStoreReserve(t *testing.T) {
 	t.Parallel()

 	tests := []struct {
 		name            string
-		sessionCfg      config.SessionCacheRedisConfig
 		replayCfg       config.ReplayRedisConfig
 		deviceSessionID string
 		requestID       string
@@ -170,13 +141,11 @@ func TestRedisStoreReserve(t *testing.T) {
 	}

 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()

 			server := miniredis.RunT(t)
-			store := newTestRedisStore(t, server, tt.sessionCfg, tt.replayCfg)
+			store := newTestRedisStore(t, server, tt.replayCfg)

 			err := store.Reserve(context.Background(), tt.deviceSessionID, tt.requestID, tt.ttl)
 			if tt.wantErrIs != nil || tt.wantErrText != "" {
@@ -201,17 +170,12 @@ func TestRedisStoreReserve(t *testing.T) {
 func TestRedisStoreReserveReturnsBackendError(t *testing.T) {
 	t.Parallel()

-	store, err := NewRedisStore(
-		config.SessionCacheRedisConfig{Addr: unusedTCPAddr(t)},
-		config.ReplayRedisConfig{
-			KeyPrefix:      "gateway:replay:",
-			ReserveTimeout: 100 * time.Millisecond,
-		},
-	)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, store.Close())
+	client := newRedisClient(t, unusedTCPAddr(t))
+	store, err := NewRedisStore(client, config.ReplayRedisConfig{
+		KeyPrefix:      "gateway:replay:",
+		ReserveTimeout: 100 * time.Millisecond,
 	})
+	require.NoError(t, err)

 	err = store.Reserve(context.Background(), "device-session-123", "request-123", 5*time.Second)
 	require.Error(t, err)
@@ -219,12 +183,9 @@ func TestRedisStoreReserveReturnsBackendError(t *testing.T) {
 	assert.ErrorContains(t, err, "reserve replay request in redis")
 }

-func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, sessionCfg config.SessionCacheRedisConfig, replayCfg config.ReplayRedisConfig) *RedisStore {
+func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, replayCfg config.ReplayRedisConfig) *RedisStore {
 	t.Helper()

-	if sessionCfg.Addr == "" {
-		sessionCfg.Addr = server.Addr()
-	}
 	if replayCfg.KeyPrefix == "" {
 		replayCfg.KeyPrefix = "gateway:replay:"
 	}
@@ -232,11 +193,8 @@ func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, sessionCfg con
 		replayCfg.ReserveTimeout = 250 * time.Millisecond
 	}

-	store, err := NewRedisStore(sessionCfg, replayCfg)
+	store, err := NewRedisStore(newRedisClient(t, server.Addr()), replayCfg)
 	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, store.Close())
-	})

 	return store
 }