bugfix: connection multiplexer should not be scoped

repository factory is scoped in non-test-mode, so the connection multiplexer part needs to be factored out

Author: the-avid-engineer

src/EntityDb.Redis/ConnectionMultiplexers/ConnectionMultiplexerPool.cs

@@ -0,0 +1,41 @@
+using EntityDb.Common.Disposables;
+using StackExchange.Redis;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityDb.Redis.ConnectionMultiplexers;
+
+internal class ConnectionMultiplexerFactory : DisposableResourceBaseClass
+{
+    private readonly SemaphoreSlim _connectionSemaphore = new(1);
+    private readonly ConcurrentDictionary<string, IConnectionMultiplexer> _connectionMultiplexers = new();
+
+    public async Task<IConnectionMultiplexer> CreateConnectionMultiplexer(string connectionString, CancellationToken cancellationToken)
+    {
+        await _connectionSemaphore.WaitAsync(cancellationToken);
+        
+        var connectionMultiplexer = _connectionMultiplexers.GetOrAdd(connectionString, _ =>
+        {
+            var configurationOptions = ConfigurationOptions.Parse(connectionString);
+
+            return ConnectionMultiplexer.Connect(configurationOptions);
+        });
+        
+        _connectionSemaphore.Release();
+
+        return connectionMultiplexer;
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        await _connectionSemaphore.WaitAsync();
+
+        foreach (var connectionMultiplexer in _connectionMultiplexers.Values)
+        {
+            connectionMultiplexer.Dispose();
+        }
+
+        _connectionSemaphore.Release();
+    }
+}

src/EntityDb.Redis/Extensions/ServiceCollectionExtensions.cs

@@ -1,6 +1,7 @@
 using EntityDb.Abstractions.Snapshots;
 using EntityDb.Common.Envelopes;
 using EntityDb.Common.Extensions;
+using EntityDb.Redis.ConnectionMultiplexers;
 using EntityDb.Redis.Envelopes;
 using EntityDb.Redis.Snapshots;
 using Microsoft.Extensions.Configuration;
@@ -35,6 +36,8 @@ public static void AddRedisSnapshots<TSnapshot>(this IServiceCollection serviceC
         Func<IConfiguration, string> getConnectionString, bool testMode = false)
     {
         serviceCollection.AddJsonElementEnvelopeService();
+
+        serviceCollection.AddSingleton<ConnectionMultiplexerFactory>();
 
         serviceCollection.Add
         (

src/EntityDb.Redis/Snapshots/RedisSnapshotRepositoryFactory.cs

@@ -3,6 +3,7 @@
 using EntityDb.Common.Envelopes;
 using EntityDb.Common.Snapshots;
 using EntityDb.Common.TypeResolvers;
+using EntityDb.Redis.ConnectionMultiplexers;
 using EntityDb.Redis.Sessions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
@@ -17,17 +18,16 @@ namespace EntityDb.Redis.Snapshots;
 internal class RedisSnapshotRepositoryFactory<TSnapshot> : DisposableResourceBaseClass, ISnapshotRepositoryFactory<TSnapshot>
 {
     private readonly IServiceProvider _serviceProvider;
+    private readonly ConnectionMultiplexerFactory _connectionMultiplexerFactory;
     private readonly IOptionsFactory<SnapshotSessionOptions> _optionsFactory;
     private readonly IEnvelopeService<JsonElement> _envelopeService;
     private readonly string _connectionString;
     private readonly string _keyNamespace;
-    private readonly SemaphoreSlim _connectionSemaphore = new(1);
-    
-    private IConnectionMultiplexer? _connectionMultiplexer;
 
     public RedisSnapshotRepositoryFactory
     (
         IServiceProvider serviceProvider,
+        ConnectionMultiplexerFactory connectionMultiplexerFactory,
         IOptionsFactory<SnapshotSessionOptions> optionsFactory,
         IEnvelopeService<JsonElement> envelopeService,
         ITypeResolver typeResolver,
@@ -36,35 +36,17 @@ string keyNamespace
     )
     {
         _serviceProvider = serviceProvider;
+        _connectionMultiplexerFactory = connectionMultiplexerFactory;
         _optionsFactory = optionsFactory;
         _envelopeService = envelopeService;
         _connectionString = connectionString;
         _keyNamespace = keyNamespace;
     }
 
-    private async Task<IConnectionMultiplexer> OpenConnectionMultiplexer(CancellationToken cancellationToken)
-    {
-        await _connectionSemaphore.WaitAsync(cancellationToken);
-        
-        if (_connectionMultiplexer != null)
-        {
-            _connectionSemaphore.Release();
-            
-            return _connectionMultiplexer;
-        }
-        
-        var configurationOptions = ConfigurationOptions.Parse(_connectionString);
-        
-        _connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions).WaitAsync(cancellationToken);
-
-        _connectionSemaphore.Release();
-
-        return _connectionMultiplexer;
-    }
 
     private async Task<IRedisSession> CreateSession(SnapshotSessionOptions snapshotSessionOptions, CancellationToken cancellationToken)
     {
-        var connectionMultiplexer = await OpenConnectionMultiplexer(cancellationToken);
+        var connectionMultiplexer = await _connectionMultiplexerFactory.CreateConnectionMultiplexer(_connectionString, cancellationToken);
 
         return RedisSession.Create(_serviceProvider, connectionMultiplexer.GetDatabase(), snapshotSessionOptions);
     }
@@ -95,11 +77,4 @@ public static RedisSnapshotRepositoryFactory<TSnapshot> Create(IServiceProvider
             keyNamespace
         );
     }
-
-    public override ValueTask DisposeAsync()
-    {
-        _connectionMultiplexer?.Dispose();
-        
-        return ValueTask.CompletedTask;
-    }
 }