feat: use postgres

gateway/internal/session/redis.go

@@ -3,7 +3,6 @@ package session
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -32,68 +31,27 @@ type redisRecord struct {
 	RevokedAtMS     *int64 `json:"revoked_at_ms,omitempty"`
 }
 
-// NewRedisCache constructs a Redis-backed SessionCache from cfg. The returned
-// cache is read-only from the gateway perspective and does not write or mutate
-// Redis state.
-func NewRedisCache(cfg config.SessionCacheRedisConfig) (*RedisCache, error) {
-	if strings.TrimSpace(cfg.Addr) == "" {
-		return nil, errors.New("new redis session cache: redis addr must not be empty")
+// NewRedisCache constructs a Redis-backed SessionCache that uses client and
+// applies the namespace and timeout settings from cfg. The cache does not own
+// the client; the runtime supplies a shared *redis.Client.
+func NewRedisCache(client *redis.Client, cfg config.SessionCacheRedisConfig) (*RedisCache, error) {
+	if client == nil {
+		return nil, errors.New("new redis session cache: nil redis client")
 	}
-	if cfg.DB < 0 {
-		return nil, errors.New("new redis session cache: redis db must not be negative")
+	if strings.TrimSpace(cfg.KeyPrefix) == "" {
+		return nil, errors.New("new redis session cache: redis key prefix must not be empty")
 	}
 	if cfg.LookupTimeout <= 0 {
 		return nil, errors.New("new redis session cache: lookup timeout must be positive")
 	}
 
-	options := &redis.Options{
-		Addr:            cfg.Addr,
-		Username:        cfg.Username,
-		Password:        cfg.Password,
-		DB:              cfg.DB,
-		Protocol:        2,
-		DisableIdentity: true,
-	}
-	if cfg.TLSEnabled {
-		options.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
-	}
-
 	return &RedisCache{
-		client:        redis.NewClient(options),
+		client:        client,
 		keyPrefix:     cfg.KeyPrefix,
 		lookupTimeout: cfg.LookupTimeout,
 	}, nil
 }
 
-// Close releases the underlying Redis client resources.
-func (c *RedisCache) Close() error {
-	if c == nil || c.client == nil {
-		return nil
-	}
-
-	return c.client.Close()
-}
-
-// Ping verifies that the configured Redis backend is reachable within the
-// cache lookup timeout budget.
-func (c *RedisCache) Ping(ctx context.Context) error {
-	if c == nil || c.client == nil {
-		return errors.New("ping redis session cache: nil cache")
-	}
-	if ctx == nil {
-		return errors.New("ping redis session cache: nil context")
-	}
-
-	pingCtx, cancel := context.WithTimeout(ctx, c.lookupTimeout)
-	defer cancel()
-
-	if err := c.client.Ping(pingCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis session cache: %w", err)
-	}
-
-	return nil
-}
-
 // Lookup resolves deviceSessionID from Redis, validates the cached JSON
 // payload strictly, and returns the decoded session record.
 func (c *RedisCache) Lookup(ctx context.Context, deviceSessionID string) (Record, error) {

gateway/internal/session/redis_test.go

@@ -10,61 +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, server *miniredis.Miniredis) *redis.Client {
+	t.Helper()
+
+	client := redis.NewClient(&redis.Options{
+		Addr:            server.Addr(),
+		Protocol:        2,
+		DisableIdentity: true,
+	})
+	t.Cleanup(func() {
+		assert.NoError(t, client.Close())
+	})
+
+	return client
+}
+
 func TestNewRedisCache(t *testing.T) {
 	t.Parallel()
 
 	server := miniredis.RunT(t)
+	client := newRedisClient(t, server)
+
+	validCfg := config.SessionCacheRedisConfig{
+		KeyPrefix:     "gateway:session:",
+		LookupTimeout: 250 * time.Millisecond,
+	}
 
 	tests := []struct {
 		name    string
+		client  *redis.Client
 		cfg     config.SessionCacheRedisConfig
 		wantErr string
 	}{
+		{name: "valid config", client: client, cfg: validCfg},
+		{name: "nil client", client: nil, cfg: validCfg, wantErr: "nil redis client"},
 		{
-			name: "valid config",
-			cfg: config.SessionCacheRedisConfig{
-				Addr:          server.Addr(),
-				DB:            2,
-				KeyPrefix:     "gateway:session:",
-				LookupTimeout: 250 * time.Millisecond,
-			},
+			name:    "empty key prefix",
+			client:  client,
+			cfg:     config.SessionCacheRedisConfig{LookupTimeout: 250 * time.Millisecond},
+			wantErr: "redis key prefix must not be empty",
 		},
 		{
-			name: "empty addr",
-			cfg: config.SessionCacheRedisConfig{
-				LookupTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis addr must not be empty",
-		},
-		{
-			name: "negative db",
-			cfg: config.SessionCacheRedisConfig{
-				Addr:          server.Addr(),
-				DB:            -1,
-				LookupTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis db must not be negative",
-		},
-		{
-			name: "non-positive lookup timeout",
-			cfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-			},
+			name:    "non-positive lookup timeout",
+			client:  client,
+			cfg:     config.SessionCacheRedisConfig{KeyPrefix: "gateway:session:"},
 			wantErr: "lookup timeout must be positive",
 		},
 	}
 
 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			cache, err := NewRedisCache(tt.cfg)
+			cache, err := NewRedisCache(tt.client, tt.cfg)
 			if tt.wantErr != "" {
 				require.Error(t, err)
 				require.ErrorContains(t, err, tt.wantErr)
@@ -72,22 +75,11 @@ func TestNewRedisCache(t *testing.T) {
 			}
 
 			require.NoError(t, err)
-			t.Cleanup(func() {
-				assert.NoError(t, cache.Close())
-			})
+			require.NotNil(t, cache)
 		})
 	}
 }
 
-func TestRedisCachePing(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	cache := newTestRedisCache(t, server, config.SessionCacheRedisConfig{})
-
-	require.NoError(t, cache.Ping(context.Background()))
-}
-
 func TestRedisCacheLookup(t *testing.T) {
 	t.Parallel()
 
@@ -259,8 +251,6 @@ func TestRedisCacheLookup(t *testing.T) {
 			server := miniredis.RunT(t)
 
 			cfg := tt.cfg
-			cfg.Addr = server.Addr()
-			cfg.DB = 0
 			cfg.LookupTimeout = 250 * time.Millisecond
 
 			if tt.seed != nil {
@@ -292,20 +282,16 @@ func TestRedisCacheLookup(t *testing.T) {
 func newTestRedisCache(t *testing.T, server *miniredis.Miniredis, cfg config.SessionCacheRedisConfig) *RedisCache {
 	t.Helper()
 
-	if cfg.Addr == "" {
-		cfg.Addr = server.Addr()
+	if cfg.KeyPrefix == "" {
+		cfg.KeyPrefix = "gateway:session:"
 	}
 	if cfg.LookupTimeout == 0 {
 		cfg.LookupTimeout = 250 * time.Millisecond
 	}
 
-	cache, err := NewRedisCache(cfg)
+	cache, err := NewRedisCache(newRedisClient(t, server), cfg)
 	require.NoError(t, err)
 
-	t.Cleanup(func() {
-		assert.NoError(t, cache.Close())
-	})
-
 	return cache
 }