feat: use postgres

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() {