feat: use postgres

gateway/internal/events/client_subscriber.go

@@ -3,7 +3,6 @@ package events
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
 	"errors"
 	"fmt"
 	"strings"
@@ -39,26 +38,23 @@ type RedisClientEventSubscriber struct {
 	logger           *zap.Logger
 	metrics          *telemetry.Runtime
 
-	closeOnce   sync.Once
 	startedOnce sync.Once
 	started     chan struct{}
 }
 
-// NewRedisClientEventSubscriber constructs a Redis Stream subscriber that
-// reuses the SessionCache Redis connection settings and forwards decoded
-// client-facing events to publisher.
-func NewRedisClientEventSubscriber(sessionCfg config.SessionCacheRedisConfig, eventsCfg config.ClientEventsRedisConfig, publisher ClientEventPublisher) (*RedisClientEventSubscriber, error) {
-	return NewRedisClientEventSubscriberWithObservability(sessionCfg, eventsCfg, publisher, nil, nil)
+// NewRedisClientEventSubscriber constructs a Redis Stream subscriber that uses
+// client and forwards decoded client-facing events to publisher.
+func NewRedisClientEventSubscriber(client *redis.Client, sessionCfg config.SessionCacheRedisConfig, eventsCfg config.ClientEventsRedisConfig, publisher ClientEventPublisher) (*RedisClientEventSubscriber, error) {
+	return NewRedisClientEventSubscriberWithObservability(client, sessionCfg, eventsCfg, publisher, nil, nil)
 }
 
 // NewRedisClientEventSubscriberWithObservability constructs a Redis Stream
-// subscriber that also records malformed or dropped internal events.
-func NewRedisClientEventSubscriberWithObservability(sessionCfg config.SessionCacheRedisConfig, eventsCfg config.ClientEventsRedisConfig, publisher ClientEventPublisher, logger *zap.Logger, metrics *telemetry.Runtime) (*RedisClientEventSubscriber, error) {
-	if strings.TrimSpace(sessionCfg.Addr) == "" {
-		return nil, errors.New("new redis client event subscriber: redis addr must not be empty")
-	}
-	if sessionCfg.DB < 0 {
-		return nil, errors.New("new redis client event subscriber: redis db must not be negative")
+// subscriber that also records malformed or dropped internal events. The
+// subscriber does not own the client; the runtime supplies a shared
+// *redis.Client.
+func NewRedisClientEventSubscriberWithObservability(client *redis.Client, sessionCfg config.SessionCacheRedisConfig, eventsCfg config.ClientEventsRedisConfig, publisher ClientEventPublisher, logger *zap.Logger, metrics *telemetry.Runtime) (*RedisClientEventSubscriber, error) {
+	if client == nil {
+		return nil, errors.New("new redis client event subscriber: nil redis client")
 	}
 	if sessionCfg.LookupTimeout <= 0 {
 		return nil, errors.New("new redis client event subscriber: lookup timeout must be positive")
@@ -73,23 +69,12 @@ func NewRedisClientEventSubscriberWithObservability(sessionCfg config.SessionCac
 		return nil, errors.New("new redis client event subscriber: nil publisher")
 	}
 
-	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}
-	}
 	if logger == nil {
 		logger = zap.NewNop()
 	}
 
 	return &RedisClientEventSubscriber{
-		client:           redis.NewClient(options),
+		client:           client,
 		stream:           eventsCfg.Stream,
 		pingTimeout:      sessionCfg.LookupTimeout,
 		readBlockTimeout: eventsCfg.ReadBlockTimeout,
@@ -100,26 +85,6 @@ func NewRedisClientEventSubscriberWithObservability(sessionCfg config.SessionCac
 	}, nil
 }
 
-// Ping verifies that the Redis backend used for client-facing event fan-out is
-// reachable within the configured timeout budget.
-func (s *RedisClientEventSubscriber) Ping(ctx context.Context) error {
-	if s == nil || s.client == nil {
-		return errors.New("ping redis client event subscriber: nil subscriber")
-	}
-	if ctx == nil {
-		return errors.New("ping redis client event subscriber: nil context")
-	}
-
-	pingCtx, cancel := context.WithTimeout(ctx, s.pingTimeout)
-	defer cancel()
-
-	if err := s.client.Ping(pingCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis client event subscriber: %w", err)
-	}
-
-	return nil
-}
-
 // Run consumes client-facing events until ctx is canceled or Redis returns an
 // unexpected error.
 func (s *RedisClientEventSubscriber) Run(ctx context.Context) error {
@@ -184,28 +149,21 @@ func (s *RedisClientEventSubscriber) resolveStartID(ctx context.Context) (string
 	return messages[0].ID, nil
 }
 
-// Shutdown closes the Redis client so a blocking stream read can terminate
-// promptly during gateway shutdown.
+// Shutdown is a no-op kept for App framework compatibility. The blocking
+// XRead loop terminates when its context is cancelled by the parent runtime,
+// which also owns and closes the shared Redis client.
 func (s *RedisClientEventSubscriber) Shutdown(ctx context.Context) error {
 	if ctx == nil {
 		return errors.New("shutdown redis client event subscriber: nil context")
 	}
 
-	return s.Close()
+	return nil
 }
 
-// Close releases the underlying Redis client resources.
+// Close is a no-op kept for backwards-compatible cleanup wiring; the
+// subscriber does not own the shared Redis client.
 func (s *RedisClientEventSubscriber) Close() error {
-	if s == nil || s.client == nil {
-		return nil
-	}
-
-	var err error
-	s.closeOnce.Do(func() {
-		err = s.client.Close()
-	})
-
-	return err
+	return nil
 }
 
 func (s *RedisClientEventSubscriber) signalStarted() {

gateway/internal/events/client_subscriber_test.go

@@ -153,8 +153,9 @@ func TestRedisClientEventSubscriberLogsAndCountsMalformedEvents(t *testing.T) {
 	telemetryRuntime := testutil.NewTelemetryRuntime(t, logger)
 
 	subscriber, err := NewRedisClientEventSubscriberWithObservability(
+		newTestRedisClient(t, server),
 		config.SessionCacheRedisConfig{
-			Addr:          server.Addr(),
+			KeyPrefix:     "gateway:session:",
 			LookupTimeout: 250 * time.Millisecond,
 		},
 		config.ClientEventsRedisConfig{
@@ -166,9 +167,6 @@ func TestRedisClientEventSubscriberLogsAndCountsMalformedEvents(t *testing.T) {
 		telemetryRuntime,
 	)
 	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, subscriber.Close())
-	})
 
 	running := runTestClientEventSubscriber(t, subscriber)
 	defer running.stop(t)
@@ -195,8 +193,9 @@ func newTestRedisClientEventSubscriber(t *testing.T, server *miniredis.Miniredis
 	t.Helper()
 
 	subscriber, err := NewRedisClientEventSubscriber(
+		newTestRedisClient(t, server),
 		config.SessionCacheRedisConfig{
-			Addr:          server.Addr(),
+			KeyPrefix:     "gateway:session:",
 			LookupTimeout: 250 * time.Millisecond,
 		},
 		config.ClientEventsRedisConfig{
@@ -207,10 +206,6 @@ func newTestRedisClientEventSubscriber(t *testing.T, server *miniredis.Miniredis
 	)
 	require.NoError(t, err)
 
-	t.Cleanup(func() {
-		assert.NoError(t, subscriber.Close())
-	})
-
 	return subscriber
 }
 

gateway/internal/events/subscriber.go

@@ -5,7 +5,6 @@ package events
 
 import (
 	"context"
-	"crypto/tls"
 	"errors"
 	"fmt"
 	"strconv"
@@ -43,33 +42,30 @@ type RedisSessionSubscriber struct {
 	logger            *zap.Logger
 	metrics           *telemetry.Runtime
 
-	closeOnce   sync.Once
 	startedOnce sync.Once
 	started     chan struct{}
 }
 
-// NewRedisSessionSubscriber constructs a Redis Stream subscriber that reuses
-// the SessionCache Redis connection settings and applies updates to store.
-func NewRedisSessionSubscriber(sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore) (*RedisSessionSubscriber, error) {
-	return NewRedisSessionSubscriberWithObservability(sessionCfg, eventsCfg, store, nil, nil, nil)
+// NewRedisSessionSubscriber constructs a Redis Stream subscriber that uses
+// client and applies updates to store.
+func NewRedisSessionSubscriber(client *redis.Client, sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore) (*RedisSessionSubscriber, error) {
+	return NewRedisSessionSubscriberWithObservability(client, sessionCfg, eventsCfg, store, nil, nil, nil)
 }
 
 // NewRedisSessionSubscriberWithRevocationHandler constructs a Redis Stream
-// subscriber that reuses the SessionCache Redis connection settings, applies
-// updates to store, and optionally tears down active resources for revoked
-// sessions.
-func NewRedisSessionSubscriberWithRevocationHandler(sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore, revocationHandler SessionRevocationHandler) (*RedisSessionSubscriber, error) {
-	return NewRedisSessionSubscriberWithObservability(sessionCfg, eventsCfg, store, revocationHandler, nil, nil)
+// subscriber that uses client, applies updates to store, and optionally tears
+// down active resources for revoked sessions.
+func NewRedisSessionSubscriberWithRevocationHandler(client *redis.Client, sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore, revocationHandler SessionRevocationHandler) (*RedisSessionSubscriber, error) {
+	return NewRedisSessionSubscriberWithObservability(client, sessionCfg, eventsCfg, store, revocationHandler, nil, nil)
 }
 
 // NewRedisSessionSubscriberWithObservability constructs a Redis Stream
-// subscriber that also logs and counts malformed internal session events.
-func NewRedisSessionSubscriberWithObservability(sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore, revocationHandler SessionRevocationHandler, logger *zap.Logger, metrics *telemetry.Runtime) (*RedisSessionSubscriber, error) {
-	if strings.TrimSpace(sessionCfg.Addr) == "" {
-		return nil, errors.New("new redis session subscriber: redis addr must not be empty")
-	}
-	if sessionCfg.DB < 0 {
-		return nil, errors.New("new redis session subscriber: redis db must not be negative")
+// subscriber that also logs and counts malformed internal session events. The
+// subscriber does not own the client; the runtime supplies a shared
+// *redis.Client.
+func NewRedisSessionSubscriberWithObservability(client *redis.Client, sessionCfg config.SessionCacheRedisConfig, eventsCfg config.SessionEventsRedisConfig, store session.SnapshotStore, revocationHandler SessionRevocationHandler, logger *zap.Logger, metrics *telemetry.Runtime) (*RedisSessionSubscriber, error) {
+	if client == nil {
+		return nil, errors.New("new redis session subscriber: nil redis client")
 	}
 	if sessionCfg.LookupTimeout <= 0 {
 		return nil, errors.New("new redis session subscriber: lookup timeout must be positive")
@@ -84,23 +80,12 @@ func NewRedisSessionSubscriberWithObservability(sessionCfg config.SessionCacheRe
 		return nil, errors.New("new redis session subscriber: nil session snapshot store")
 	}
 
-	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}
-	}
 	if logger == nil {
 		logger = zap.NewNop()
 	}
 
 	return &RedisSessionSubscriber{
-		client:            redis.NewClient(options),
+		client:            client,
 		stream:            eventsCfg.Stream,
 		pingTimeout:       sessionCfg.LookupTimeout,
 		readBlockTimeout:  eventsCfg.ReadBlockTimeout,
@@ -112,26 +97,6 @@ func NewRedisSessionSubscriberWithObservability(sessionCfg config.SessionCacheRe
 	}, nil
 }
 
-// Ping verifies that the Redis backend used for session lifecycle events is
-// reachable within the configured timeout budget.
-func (s *RedisSessionSubscriber) Ping(ctx context.Context) error {
-	if s == nil || s.client == nil {
-		return errors.New("ping redis session subscriber: nil subscriber")
-	}
-	if ctx == nil {
-		return errors.New("ping redis session subscriber: nil context")
-	}
-
-	pingCtx, cancel := context.WithTimeout(ctx, s.pingTimeout)
-	defer cancel()
-
-	if err := s.client.Ping(pingCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis session subscriber: %w", err)
-	}
-
-	return nil
-}
-
 // Run consumes session lifecycle events until ctx is canceled or Redis returns
 // an unexpected error.
 func (s *RedisSessionSubscriber) Run(ctx context.Context) error {
@@ -196,28 +161,21 @@ func (s *RedisSessionSubscriber) resolveStartID(ctx context.Context) (string, er
 	return messages[0].ID, nil
 }
 
-// Shutdown closes the Redis client so a blocking stream read can terminate
-// promptly during gateway shutdown.
+// Shutdown is a no-op kept for App framework compatibility. The blocking
+// XRead loop terminates when its context is cancelled by the parent runtime,
+// which also owns and closes the shared Redis client.
 func (s *RedisSessionSubscriber) Shutdown(ctx context.Context) error {
 	if ctx == nil {
 		return errors.New("shutdown redis session subscriber: nil context")
 	}
 
-	return s.Close()
+	return nil
 }
 
-// Close releases the underlying Redis client resources.
+// Close is a no-op kept for backwards-compatible cleanup wiring; the
+// subscriber does not own the shared Redis client.
 func (s *RedisSessionSubscriber) Close() error {
-	if s == nil || s.client == nil {
-		return nil
-	}
-
-	var err error
-	s.closeOnce.Do(func() {
-		err = s.client.Close()
-	})
-
-	return err
+	return nil
 }
 
 func (s *RedisSessionSubscriber) signalStarted() {

gateway/internal/events/subscriber_test.go

@@ -10,6 +10,7 @@ import (
 	"galaxy/gateway/internal/session"
 
 	"github.com/alicebob/miniredis/v2"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -262,9 +263,12 @@ func newTestRedisSessionSubscriber(t *testing.T, server *miniredis.Miniredis, st
 func newTestRedisSessionSubscriberWithRevocationHandler(t *testing.T, server *miniredis.Miniredis, store session.SnapshotStore, revocationHandler SessionRevocationHandler) *RedisSessionSubscriber {
 	t.Helper()
 
+	client := newTestRedisClient(t, server)
+
 	subscriber, err := NewRedisSessionSubscriberWithRevocationHandler(
+		client,
 		config.SessionCacheRedisConfig{
-			Addr:          server.Addr(),
+			KeyPrefix:     "gateway:session:",
 			LookupTimeout: 250 * time.Millisecond,
 		},
 		config.SessionEventsRedisConfig{
@@ -276,11 +280,22 @@ func newTestRedisSessionSubscriberWithRevocationHandler(t *testing.T, server *mi
 	)
 	require.NoError(t, err)
 
+	return subscriber
+}
+
+func newTestRedisClient(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, subscriber.Close())
+		assert.NoError(t, client.Close())
 	})
 
-	return subscriber
+	return client
 }
 
 type recordingSessionRevocationHandler struct {