Some minor config changes (#399)

Michael Conrad · web-flow · commit b5a9b39a6777 · 2026-02-18T08:54:47.000+01:00
diff --git a/benchmarks/CacheManager.Config.Tests/Program.cs b/benchmarks/CacheManager.Config.Tests/Program.cs
@@ -7,6 +7,7 @@
 using Garnet.server;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Configuration;
 
 namespace CacheManager.Config.Tests;
 
@@ -34,8 +35,16 @@ public static async Task Main(string[] args)
         var iterations = 100;
         try
         {
+            var configuration = new ConfigurationBuilder()
+                .AddJsonFile("cache.json")
+                .Build();
+
+
             var services = new ServiceCollection();
 
+            services.AddCacheManager();
+            services.AddCacheManagerConfiguration(configuration, c => c.WithJsonSerializer());
+
             services.AddLogging(c =>
             {
                 c.AddSystemdConsole();
@@ -47,49 +56,51 @@ public static async Task Main(string[] args)
 
             using var server = StartServer(loggerFactory);
 
-            var builder = new Core.CacheConfigurationBuilder("myCache");
+            var cacheA = provider.GetRequiredService<ICacheManager<string>>();
 
-            builder
-                .WithRetryTimeout(500)
-                .WithMaxRetries(3);
+            //var builder = new Core.CacheConfigurationBuilder("myCache");
 
-            builder
-                .WithDictionaryHandle()
-                .WithExpiration(ExpirationMode.Absolute, TimeSpan.FromSeconds(20))
-                .DisableStatistics();
+            //builder
+            //    .WithRetryTimeout(500)
+            //    .WithMaxRetries(3);
 
-            builder
-                .WithRedisCacheHandle("redis", true)
-                .WithExpiration(ExpirationMode.Absolute, TimeSpan.FromMinutes(60))
-                .DisableStatistics();
+            //builder
+            //    .WithDictionaryHandle()
+            //    .WithExpiration(ExpirationMode.Absolute, TimeSpan.FromSeconds(20))
+            //    .DisableStatistics();
 
-            builder.WithRedisBackplane("redis");
+            //builder
+            //    .WithRedisCacheHandle("redis", true)
+            //    .WithExpiration(ExpirationMode.Absolute, TimeSpan.FromMinutes(60))
+            //    .DisableStatistics();
 
-            builder.WithRedisConfiguration("redis", config =>
-            {
-                config
-                    //.UseTwemproxy()
-                    //.UseCompatibilityMode("2.4")
-                    .WithAllowAdmin()
-                    .WithDatabase(0)
-                    .WithConnectionTimeout(5000)
-                    .EnableKeyspaceEvents()
-                    .WithEndpoint("127.0.0.1", 6379);
-            });
+            //builder.WithRedisBackplane("redis");
+
+            //builder.WithRedisConfiguration("redis", config =>
+            //{
+            //    config
+            //        //.UseTwemproxy()
+            //        //.UseCompatibilityMode("2.4")
+            //        .WithAllowAdmin()
+            //        .WithDatabase(0)
+            //        .WithConnectionTimeout(5000)
+            //        .EnableKeyspaceEvents()
+            //        .WithEndpoint("127.0.0.1", 6379);
+            //});
 
             //builder.WithRedisConfiguration("redis", "localhost:22121");
 
-            builder.WithBondCompactBinarySerializer();
+            //builder.WithBondCompactBinarySerializer();
 
-            var cacheA = new BaseCacheManager<string>(builder.Build());
-            var cacheB = new BaseCacheManager<string>(builder.Build());
+            //var cacheA = new BaseCacheManager<string>(builder.Build());
+            //var cacheB = new BaseCacheManager<string>(builder.Build());
             cacheA.Clear();
 
             cacheA.Add("key", "value", "region");
 
             var val = cacheA.Get("key", "region");
 
-            var val2 = cacheB.AddOrUpdate("key", "region", "added?", (v) => v + "updated");
+            //var val2 = cacheB.AddOrUpdate("key", "region", "added?", (v) => v + "updated");
 
             await Task.Delay(100);
 
diff --git a/benchmarks/CacheManager.Config.Tests/Tests.cs b/benchmarks/CacheManager.Config.Tests/Tests.cs
@@ -76,7 +76,7 @@ public static void CacheThreadTest(ICacheManager<string> cache, int seed = 42)
         public static async Task PumpData(ICacheManager<string> cache, int runForSeconds = 300)
         {
             var source = new CancellationTokenSource(TimeSpan.FromSeconds(runForSeconds));
-            var maxItems = 500000;
+            var maxItems = 1000;
             var numReaders = 10;
             var puts = 0;
             var hits = 0;
@@ -92,14 +92,19 @@ public static async Task PumpData(ICacheManager<string> cache, int runForSeconds
                         try
                         {
                             count++;
-                            cache.Put("key" + count, Guid.NewGuid().ToString());
+                            cache.Put("key" + count, Guid.NewGuid().ToString(), "_region");
 
                             Interlocked.Increment(ref puts);
 
+                            if (count % 100 == 0)
+                            {
+                                cache.Remove("key" + count, "_region");
+                            }
+
                             if (count == maxItems)
                             {
                                 count = 0;
-                                cache.Clear();
+                                // cache.ClearRegion("_region");
                                 Interlocked.Increment(ref putIterations);
                             }
                         }
@@ -142,7 +147,7 @@ async Task Read()
                 {
                     try
                     {
-                        var value = cache.Get("key" + rnd.Next(0, maxItems));
+                        var value = cache.Get("key" + rnd.Next(0, maxItems), "_region");
                         if (value == null)
                         {
                             Interlocked.Increment(ref misses);
diff --git a/benchmarks/CacheManager.Config.Tests/cache.json b/benchmarks/CacheManager.Config.Tests/cache.json
@@ -2,50 +2,40 @@
   "$schema": "http://cachemanager.michaco.net/schemas/cachemanager.json#",
   "redis": [
     {
-      "key": "redisConnection",      
-      "endpoints": [
-        {
-          "host": "localhost",
-          "port": 6379
-        }
-      ],
-      "allowAdmin": true,
-      "database": 11
+      "key": "redisConnection",
+      "connectionString": "localhost:6379,defaultDatabase=0,allowAdmin=true,abortConnect=false,connectRetry=5,connectTimeout=15000"
     }
   ],
   "cacheManagers": [
     {
       "maxRetries": 1000,
-      "name": "cachename",
+      "name": "default",
       "retryTimeout": 100,
       "updateMode": "Up",
       "backplane": {
         "key": "redisConnection",
         "knownType": "Redis",
-        "channelName": "test"
-      },
-      "loggerFactory": {
-        "knownType": "Microsoft"
-      },
-      "serializer": {
-        "knownType": "Json"
+        "channelName": "default"
       },
       "handles": [
-        //{
-        //  "knownType": "Dictionary",
-        //  "enablePerformanceCounters": true,
-        //  "enableStatistics": true,
-        //  "expirationMode": "Absolute",
-        //  "expirationTimeout": "0:0:23",
-        //  "isBackplaneSource": false,
-        //  "name": "sys cache"
-        //},
+        {
+          "knownType": "Dictionary",
+          "enablePerformanceCounters": false,
+          "enableStatistics": false,
+          "expirationMode": "Absolute",
+          // 1 minute
+          "expirationTimeout": "0:1:00",
+          "isBackplaneSource": false,
+          "name": "memory"
+        },
         {
           "knownType": "Redis",
           "key": "redisConnection",
           "isBackplaneSource": true,
           "expirationMode": "Sliding",
-          "expirationTimeout": "00:10:00"
+          // 10 minutes
+          "expirationTimeout": "0.00:10:00",
+          "name": "redis"
         }
       ]
     }
diff --git a/src/CacheManager.Core/CacheManagerConfiguration.cs b/src/CacheManager.Core/CacheManagerConfiguration.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace CacheManager.Core
 {
@@ -42,10 +41,10 @@ public CacheManagerConfiguration()
 
         /// <summary>
         /// Gets or sets the limit of the number of retry operations per action.
-        /// <para>Default is 50.</para>
+        /// <para>Default is 10.</para>
         /// </summary>
         /// <value>The maximum retries.</value>
-        public int MaxRetries { get; set; } = 50;
+        public int MaxRetries { get; set; } = 10;
 
         /// <summary>
         /// Gets or sets the number of milliseconds the cache should wait before it will retry an action.
@@ -127,4 +126,4 @@ public override string ToString()
             return $"{Name}: {string.Join(", ", CacheHandleConfigurations)}";
         }
     }
-}
+}
diff --git a/src/CacheManager.Core/Configuration/CacheConfigurationBuilder.cs b/src/CacheManager.Core/Configuration/CacheConfigurationBuilder.cs
@@ -260,7 +260,7 @@ internal static CacheManagerConfiguration LoadFromSection(CacheManagerSection se
             var cfg = new CacheManagerConfiguration()
             {
                 UpdateMode = managerCfg.UpdateMode,
-                MaxRetries = maxRetries ?? 50,
+                MaxRetries = maxRetries ?? 10,
                 RetryTimeout = retryTimeout ?? 100
             };
 
@@ -651,7 +651,7 @@ public ConfigurationBuilderCacheHandlePart WithHandle(Type cacheHandleBaseType)
 
         /// <summary>
         /// Sets the maximum number of retries per action.
-        /// <para>Default is 50.</para>
+        /// <para>Default is 10.</para>
         /// <para>
         /// Not every cache handle implements this, usually only distributed caches will use it.
         /// </para>
diff --git a/src/CacheManager.Core/ICacheManagerConfiguration.cs b/src/CacheManager.Core/ICacheManagerConfiguration.cs
@@ -77,7 +77,7 @@ public interface IReadOnlyCacheManagerConfiguration
 
         /// <summary>
         /// Gets the limit of the number of retry operations per action.
-        /// <para>Default is 50.</para>
+        /// <para>Default is 10.</para>
         /// </summary>
         /// <value>The maximum retries.</value>
         int MaxRetries { get; }
diff --git a/test/CacheManager.Tests/SyntheticCacheHandleTests.cs b/test/CacheManager.Tests/SyntheticCacheHandleTests.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Threading;
 using CacheManager.Core;
 using CacheManager.Core.Internal;
 
@@ -11,8 +12,89 @@
 namespace CacheManager.Tests
 {
     [ExcludeFromCodeCoverage]
-    public class CacheManagerAdvancedUpdateTests : IClassFixture<RedisTestFixture>
+    public class SyntheticCacheHandleTests : IClassFixture<RedisTestFixture>
     {
+        [Fact]
+        public void TryGetOrAdd_Retry_Test()
+        {
+            // test that configuring x retries does exactly that many retries.
+            var countCalls = 0;
+            var cache = CacheFactory.Build<string>(settings =>
+            {
+                settings.WithHandle(typeof(MockCacheHandle<>));
+                settings.WithMaxRetries(5);
+            });
+
+            var handle = cache.CacheHandles.ElementAt(0) as MockCacheHandle<string>;
+
+            handle.GetCallValue = null; // always fail to trigger retry;
+
+            handle.AddCall = () =>
+            {
+                Interlocked.Increment(ref countCalls);
+                return false; // always fail to trigger retry;
+            };
+
+            cache.TryGetOrAdd("key", old => old + "new", out string newValue);
+
+            // Expecting one normal exec + retries
+            Assert.Equal(6, countCalls);
+        }
+
+        [Fact]
+        public void GetOrAdd_Retry_Test()
+        {
+            // test that configuring x retries does exactly that many retries.
+            var countCalls = 0;
+            var cache = CacheFactory.Build<string>(settings =>
+            {
+                settings.WithHandle(typeof(MockCacheHandle<>));
+                settings.WithMaxRetries(5);
+            });
+
+            var handle = cache.CacheHandles.ElementAt(0) as MockCacheHandle<string>;
+
+            handle.GetCallValue = null; // always fail to trigger retry;
+
+            handle.AddCall = () =>
+            {
+                Interlocked.Increment(ref countCalls);
+                return false; // always fail to trigger retry;
+            };
+
+            Assert.Throws<InvalidOperationException>(() => cache.GetOrAdd("key", old => old + "new"));
+
+            // Expecting one normal exec + retries
+            Assert.Equal(6, countCalls);
+        }
+
+        [Fact]
+        public void AddOrUpdate_Retry_Test()
+        {
+            // test that configuring x retries does exactly that many retries.
+            var countCalls = 0;
+            var cache = CacheFactory.Build<string>(settings =>
+            {
+                settings.WithHandle(typeof(MockCacheHandle<>));
+                settings.WithMaxRetries(5);
+            });
+
+            var handle = cache.CacheHandles.ElementAt(0) as MockCacheHandle<string>;
+
+            handle.GetCallValue = null; // always fail to trigger retry;
+            handle.UpdateValue = UpdateItemResult.ForFactoryReturnedNull<string>();
+            handle.AddCall = () =>
+            {
+                Interlocked.Increment(ref countCalls);
+                return false; // always fail to trigger retry;
+            };
+
+            Assert.Throws<InvalidOperationException>(() => cache.AddOrUpdate("key", "addValue", old => old + "new"));
+
+            // Expecting one normal exec + retries
+            Assert.Equal(6, countCalls);
+        }
+
         [Theory]
         [ClassData(typeof(TestCacheManagers))]
         public void Update_ThrowsIf_FactoryReturnsNull(ICacheManager<object> cache)
diff --git a/test/CacheManager.Tests/ValidConfigurationValidationTests.cs b/test/CacheManager.Tests/ValidConfigurationValidationTests.cs
@@ -148,7 +148,7 @@ public void Cfg_Valid_CfgFile_AllDefaults()
             cache.Configuration.LoggerFactoryType.Should().BeNull();
             cache.Configuration.BackplaneType.Should().BeNull();
             cache.Configuration.RetryTimeout.Should().Be(100);
-            cache.Configuration.MaxRetries.Should().Be(50);
+            cache.Configuration.MaxRetries.Should().Be(10);
             cache.CacheHandles.Count().Should().Be(1);
             AssertCacheHandleConfig(cache.CacheHandles.ElementAt(0), "defaultsHandle", ExpirationMode.None, TimeSpan.Zero);
         }

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public static void CacheThreadTest(ICacheManager<string> cache, int seed = 42)`
`76`	`76`	`public static async Task PumpData(ICacheManager<string> cache, int runForSeconds = 300)`
`77`	`77`	`{`
`78`	`78`	`var source = new CancellationTokenSource(TimeSpan.FromSeconds(runForSeconds));`
`79`		`- var maxItems = 500000;`
	`79`	`+ var maxItems = 1000;`
`80`	`80`	`var numReaders = 10;`
`81`	`81`	`var puts = 0;`
`82`	`82`	`var hits = 0;`
`@@ -92,14 +92,19 @@ public static async Task PumpData(ICacheManager<string> cache, int runForSeconds`
`92`	`92`	`try`
`93`	`93`	`{`
`94`	`94`	`count++;`
`95`		`- cache.Put("key" + count, Guid.NewGuid().ToString());`
	`95`	`+ cache.Put("key" + count, Guid.NewGuid().ToString(), "_region");`
`96`	`96`
`97`	`97`	`Interlocked.Increment(ref puts);`
`98`	`98`
	`99`	`+ if (count % 100 == 0)`
	`100`	`+ {`
	`101`	`+ cache.Remove("key" + count, "_region");`
	`102`	`+ }`
	`103`	`+`
`99`	`104`	`if (count == maxItems)`
`100`	`105`	`{`
`101`	`106`	`count = 0;`
`102`		`- cache.Clear();`
	`107`	`+ // cache.ClearRegion("_region");`
`103`	`108`	`Interlocked.Increment(ref putIterations);`
`104`	`109`	`}`
`105`	`110`	`}`
`@@ -142,7 +147,7 @@ async Task Read()`
`142`	`147`	`{`
`143`	`148`	`try`
`144`	`149`	`{`
`145`		`- var value = cache.Get("key" + rnd.Next(0, maxItems));`
	`150`	`+ var value = cache.Get("key" + rnd.Next(0, maxItems), "_region");`
`146`	`151`	`if (value == null)`
`147`	`152`	`{`
`148`	`153`	`Interlocked.Increment(ref misses);`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ public void Cfg_Valid_CfgFile_AllDefaults()`
`148`	`148`	`cache.Configuration.LoggerFactoryType.Should().BeNull();`
`149`	`149`	`cache.Configuration.BackplaneType.Should().BeNull();`
`150`	`150`	`cache.Configuration.RetryTimeout.Should().Be(100);`
`151`		`- cache.Configuration.MaxRetries.Should().Be(50);`
	`151`	`+ cache.Configuration.MaxRetries.Should().Be(10);`
`152`	`152`	`cache.CacheHandles.Count().Should().Be(1);`
`153`	`153`	`AssertCacheHandleConfig(cache.CacheHandles.ElementAt(0), "defaultsHandle", ExpirationMode.None, TimeSpan.Zero);`
`154`	`154`	`}`