feat: add Connection method to RedisStoreBuilder for external Redis connections (#147)

Author: gor-st

pkgs/dotnet-server-sdk-redis/src/RedisBigSegmentStoreImpl.cs

@@ -17,10 +17,10 @@ internal sealed class RedisBigSegmentStoreImpl : RedisStoreImplBase, IBigSegment
         private readonly string _excludedKeyPrefix;
 
         internal RedisBigSegmentStoreImpl(
-            ConfigurationOptions redisConfig,
+            Func<IConnectionMultiplexer> connectionFactory,
             string prefix,
             Logger log
-            ) : base(redisConfig, prefix, log)
+            ) : base(connectionFactory, prefix, log)
         {
             _syncTimeKey = prefix + ":big_segments_synchronized_on";
             _includedKeyPrefix = prefix + ":big_segment_include:";

pkgs/dotnet-server-sdk-redis/src/RedisDataStoreImpl.cs

@@ -40,10 +40,10 @@ internal sealed class RedisDataStoreImpl : RedisStoreImplBase, IPersistentDataSt
         private readonly string _initedKey;
 
         internal RedisDataStoreImpl(
-            ConfigurationOptions redisConfig,
+            Func<IConnectionMultiplexer> connectionFactory,
             string prefix,
             Logger log
-            ) : base(redisConfig, prefix, log)
+            ) : base(connectionFactory, prefix, log)
         {
             _initedKey = prefix + ":$inited";
         }
@@ -70,7 +70,7 @@ public void Init(FullDataSet<SerializedItemDescriptor> allData)
             txn.StringSetAsync(_initedKey, "");
             txn.Execute();
         }
-        
+
         public SerializedItemDescriptor? Get(DataKind kind, string key)
         {
             IDatabase db = _redis.GetDatabase();

pkgs/dotnet-server-sdk-redis/src/RedisStoreBuilder.cs

@@ -57,6 +57,7 @@ namespace LaunchDarkly.Sdk.Server.Integrations
     public abstract class RedisStoreBuilder<T> : IComponentConfigurer<T>, IDiagnosticDescription
     {
         internal ConfigurationOptions _redisConfig = new ConfigurationOptions();
+        internal IConnectionMultiplexer _externalConnection;
         internal string _prefix = Redis.DefaultPrefix;
 
         internal RedisStoreBuilder()
@@ -224,6 +225,35 @@ public RedisStoreBuilder<T> RedisConfigChanges(Action<ConfigurationOptions> modi
             return this;
         }
 
+        /// <summary>
+        /// Specifies a pre-configured Redis connection multiplexer to use and will ignore
+        /// all other redis configuration options. Once you provide a multiplexer the SDK
+        /// will own it and will dispose it.
+        /// </summary>
+        /// <param name="connection">the pre-configured connection multiplexer</param>
+        /// <returns>the builder</returns>
+        public RedisStoreBuilder<T> Connection(IConnectionMultiplexer connection)
+        {
+            _externalConnection = connection ?? throw new ArgumentNullException(nameof(connection));
+            return this;
+        }
+
+        /// <summary>
+        /// Gets the connection to use - either the externally provided one or creates a new one
+        /// from configuration.
+        /// </summary>
+        /// <returns>the Redis connection multiplexer to use</returns>
+        protected IConnectionMultiplexer ConnectionMultiplexerFactory()
+        {
+            if (_externalConnection != null)
+            {
+                return _externalConnection;
+            }
+
+            var redisConfigCopy = _redisConfig.Clone();
+            return ConnectionMultiplexer.Connect(redisConfigCopy);
+        }
+
         /// <inheritdoc/>
         public abstract T Build(LdClientContext context);
 
@@ -234,13 +264,23 @@ public LdValue DescribeConfiguration(LdClientContext context) =>
 
     internal sealed class BuilderForDataStore : RedisStoreBuilder<IPersistentDataStore>
     {
-        public override IPersistentDataStore Build(LdClientContext context) =>
-            new RedisDataStoreImpl(_redisConfig, _prefix, context.Logger.SubLogger("DataStore.Redis"));
+        public override IPersistentDataStore Build(LdClientContext context)
+        {
+            return new RedisDataStoreImpl(
+                ConnectionMultiplexerFactory,
+                _prefix,
+                context.Logger.SubLogger("DataStore.Redis"));
+        }
     }
 
     internal sealed class BuilderForBigSegments : RedisStoreBuilder<IBigSegmentStore>
     {
-        public override IBigSegmentStore Build(LdClientContext context) =>
-            new RedisBigSegmentStoreImpl(_redisConfig, _prefix, context.Logger.SubLogger("BigSegments.Redis"));
+        public override IBigSegmentStore Build(LdClientContext context)
+        {
+            return new RedisBigSegmentStoreImpl(
+                ConnectionMultiplexerFactory,
+                _prefix,
+                context.Logger.SubLogger("BigSegments.Redis"));
+        }
     }
 }

pkgs/dotnet-server-sdk-redis/src/RedisStoreImplBase.cs

@@ -10,22 +10,21 @@ namespace LaunchDarkly.Sdk.Server.Integrations
 {
     internal abstract class RedisStoreImplBase : IDisposable
     {
-        protected readonly ConnectionMultiplexer _redis;
+        protected readonly IConnectionMultiplexer _redis;
         protected readonly string _prefix;
         protected readonly Logger _log;
 
         protected RedisStoreImplBase(
-            ConfigurationOptions redisConfig,
+            Func<IConnectionMultiplexer> connectionFactory,
             string prefix,
             Logger log
             )
         {
             _log = log;
-            var redisConfigCopy = redisConfig.Clone();
-            _redis = ConnectionMultiplexer.Connect(redisConfigCopy);
             _prefix = prefix;
+            _redis = connectionFactory();
             _log.Info("Using Redis data store at {0} with prefix \"{1}\"",
-                string.Join(", ", redisConfig.EndPoints.Select(DescribeEndPoint)), prefix);
+                string.Join(", ", _redis.GetEndPoints().Select(DescribeEndPoint)), prefix);
         }
 
         public void Dispose()

pkgs/dotnet-server-sdk-redis/test/RedisBigSegmentStoreBuilderTest.cs

@@ -0,0 +1,48 @@
+using System;
+using StackExchange.Redis;
+using Xunit;
+
+namespace LaunchDarkly.Sdk.Server.Integrations
+{
+    public class RedisBigSegmentStoreBuilderTest
+    {
+        [Fact]
+        public void ConnectionWithNull()
+        {
+            var builder = Redis.BigSegmentStore();
+
+            // Setting null connection should throw ArgumentNullException
+            Assert.Throws<ArgumentNullException>(() => builder.Connection(null));
+        }
+
+        [Fact]
+        public void ConnectionMethodSetsExternalConnection()
+        {
+            var builder = Redis.BigSegmentStore();
+            var connection = ConnectionMultiplexer.Connect(new ConfigurationOptions()
+            {
+                EndPoints = { "localhost:6379" }
+            });
+
+            // Initially no external connection
+            Assert.Null(builder._externalConnection);
+
+            // Set the connection
+            builder.Connection(connection);
+
+            // Verify the connection was set
+            Assert.Same(connection, builder._externalConnection);
+        }
+
+        [Fact]
+        public void ConnectionWorksWithOtherBuilderMethods()
+        {
+            var builder = Redis.BigSegmentStore();
+
+            // Chain with other builder methods
+            builder.Prefix("test-prefix");
+
+            Assert.Equal("test-prefix", builder._prefix);
+        }
+    }
+}

pkgs/dotnet-server-sdk-redis/test/RedisDataStoreBuilderTest.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
+using StackExchange.Redis;
 using Xunit;
 
 namespace LaunchDarkly.Sdk.Server.Integrations
@@ -113,5 +114,48 @@ public void Prefix()
             builder.Prefix(null);
             Assert.Equal(Redis.DefaultPrefix, builder._prefix);
         }
+
+        [Fact]
+        public void ConnectionWithNull()
+        {
+            var builder = Redis.DataStore();
+
+            // Setting null connection should throw ArgumentNullException
+            Assert.Throws<ArgumentNullException>(() => builder.Connection(null));
+        }
+
+        [Fact]
+        public void ConnectionMethodSetsExternalConnection()
+        {
+            var builder = Redis.DataStore();
+            var connection = ConnectionMultiplexer.Connect(new ConfigurationOptions()
+            {
+                EndPoints = { "localhost:6379" }
+            });
+
+            // Initially no external connection
+            Assert.Null(builder._externalConnection);
+
+            // Set the connection
+            builder.Connection(connection);
+
+            // Verify the connection was set
+            Assert.Same(connection, builder._externalConnection);
+        }
+
+        [Fact]
+        public void ConnectionWorksWithOtherBuilderMethods()
+        {
+            var builder = Redis.DataStore();
+
+            // Chain with other builder methods
+            builder.HostAndPort("test", 9999)
+                   .Prefix("test-prefix");
+
+            // Config should be set
+            Assert.Collection(builder._redisConfig.EndPoints,
+                e => Assert.Equal(new DnsEndPoint("test", 9999), e));
+            Assert.Equal("test-prefix", builder._prefix);
+        }
     }
 }