finalized

Author: HaikAsatryan

.github/workflows/main.yml

@@ -1,7 +1,7 @@
 name: Deploy NuGet Package
 
 env:
-  PROJECT_PATH: './src/PandaNuGet/PandaNuGet.csproj'
+  PROJECT_PATH: './src/DistributedCache/DistributedCache.csproj'
   OUTPUT_DIR: 'nupkgs'
   NUGET_SOURCE: 'https://api.nuget.org/v3/index.json'
   NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}

Readme.md

@@ -9,7 +9,6 @@ caching solution with advanced features such as typed cache services, distribute
 
 - **Typed Cache Service:** Supports strongly-typed caching with MessagePack serialization.
 - **Distributed Locking:** Ensures data consistency with distributed locks.
-- **Health Checks:** Monitors Redis availability and handles cache reset scenarios.
 - **Key Isolation:** Modular monolith support by prefixing keys with assembly names.
 - **Stampede Protection:** Protects against cache stampede in the `GetOrCreateAsync` method.
 - **No Serializer Override:** Enforces MessagePack serialization for performance and readability.
@@ -40,8 +39,6 @@ builder.AddDistributedCache(options =>
     options.DistributedLockDuration = TimeSpan.FromSeconds(5); //Default is 5 seconds
     options.DefaultExpiration = TimeSpan.FromMinutes(5); //Default is 15 minutes
     options.CacheResetMode = CacheResetMode.ResetFrequentTagsAfterHealthCheckFail; //Default is ResetAllAfterHealthCheckFail
-    options.HealthCheckInterval = TimeSpan.FromSeconds(1); //Default is 100 milliseconds
-    options.KeyPrefixForIsolation = KeyPrefix.AssemblyNamePrefix //Default is None
 });
 
 var app = builder.Build();
@@ -57,16 +54,6 @@ cross ClassLibrary cache access.
 options.KeyPrefixForIsolation = KeyPrefix.AssemblyNamePrefix;
 ```
 
-**Health Check Service**
-
-The `RedisHealthCheckService` monitors Redis availability and resets cache entries tagged as `Frequent` after a Redis
-outage:
-
-```csharp
- options.CacheResetMode = CacheResetMode.ResetFrequentTagsAfterHealthCheckFail;
- options.HealthCheckInterval = TimeSpan.FromMilliseconds(100);
-```
-
 ### 2. Cached Entity Preparation
 
 Create your cache entity/model in order to inject it in the actual service:
@@ -99,13 +86,13 @@ public class CacheTestsService(ICacheService<TestCacheEntity> cacheService)
         await cacheService.GetOrCreateAsync("test2",
            async _ => await GetFromPostgres(token),
            TimeSpan.FromMinutes(1),
-           [CacheTag.Frequent],
+           ["vazgen"],
            token);
 
         await cacheService.GetOrCreateAsync("test3",
            async _ => await GetFromPostgres(token),
            TimeSpan.FromMinutes(1),
-           ["test", CacheTag.Frequent],
+           ["test", "vazgen"],
            token);
     }
 

src/DistributedCache/Class1.cs

@@ -37,7 +37,7 @@ public static WebApplicationBuilder AddDistributedCache(this WebApplicationBuild
         var redisConfiguration = new RedisConfiguration { ConnectionString = configurations.RedisConnectionString };
 
         builder.Services.AddStackExchangeRedisExtensions<RedisMsgPackObjectSerializer>(redisConfiguration);
-        builder.Services.AddHostedService<RedisHealthCheckService>();
+        //builder.Services.AddHostedService<RedisHealthCheckService>(); //Discontinued feature
 
         return builder;
     }
@@ -78,7 +78,7 @@ private static void ValidateOptions(WebApplicationBuilder builder)
             }
 
             if (options.CacheResetMode == CacheResetMode.ResetFrequentTagsAfterHealthCheckFail &&
-                options.HealthCheckInterval <= TimeSpan.Zero)
+                options.HealthCheckInterval <= TimeSpan.Zero) //Discontinued feature
             {
                 throw new ArgumentException(
                     "AddCacheService options: HealthCheckInterval must be greater than 0 when CacheResetMode is ResetFrequentTagsAfterHealthCheckFail.");

src/DistributedCache/Extensions/WebApplicationBuilderExtension.cs

@@ -1,6 +1,6 @@
 namespace DistributedCache.Helpers;
 
-public static class CacheTag
+internal static class CacheTag //Discontinued feature
 {
     public const string Frequent = "Frequent";
 }

src/DistributedCache/Helpers/CacheTag.cs

@@ -11,8 +11,11 @@ internal static IEnumerable<string> GetPrefixedKeys(IEnumerable<string> keys, st
     internal static IEnumerable<string> GetPrefixedKeys(IEnumerable<string> keys) => keys.Select(GetPrefixedKey);
 
     internal static string GetTagKey(string tag) => $"tags:{tag}";
+    
+    internal static string GetTagKey(string tag, string moduleName) => $"tags:{moduleName}:{tag}";
 
-    internal static string GetTagKey(string tag, string moduleName)
+    internal static string GetLockKey(string key) => $"{key}:lock";
+    private static string GetTagKey(string tag, string moduleName, object somethingForNoConflict) //Discontinued feature
     {
         return tag == CacheTag.Frequent ? $"tags:{tag}" : $"tags:{moduleName}:{tag}";
     }

src/DistributedCache/Helpers/KeyFormatHelper.cs

@@ -9,6 +9,7 @@ public class CacheConfigurationOptions
     public TimeSpan SyncTimeout { get; set; } = TimeSpan.FromSeconds(5);
     public TimeSpan DistributedLockDuration { get; set; } = TimeSpan.FromSeconds(5);
     public TimeSpan DefaultExpiration { get; set; } = TimeSpan.FromMinutes(15);
-    public CacheResetMode CacheResetMode { get; set; } = CacheResetMode.ResetFrequentTagsAfterHealthCheckFail;
-    public TimeSpan HealthCheckInterval { get; set; } = TimeSpan.FromMilliseconds(100);
+    
+    internal CacheResetMode CacheResetMode { get; set; } = CacheResetMode.ResetFrequentTagsAfterHealthCheckFail; //Discontinued feature
+    internal TimeSpan HealthCheckInterval { get; set; } = TimeSpan.FromMilliseconds(100); //Discontinued feature
 }

src/DistributedCache/Options/CacheConfigurationOptions.cs

@@ -1,6 +1,6 @@
 namespace DistributedCache.Options;
 
-public enum CacheResetMode
+internal enum CacheResetMode //Discontinued feature
 {
     None = 1,
     ResetFrequentTagsAfterHealthCheckFail = 2

src/DistributedCache/Options/CacheResetMode.cs

@@ -15,7 +15,7 @@ internal class RedisCacheService<T>(IRedisClient redisClient, IOptions<CacheConf
     private readonly CacheConfigurationOptions _config = options.Value;
     private readonly string _moduleName = typeof(T).Assembly.GetName().Name!;
     private readonly TimeSpan _lockExpiry = options.Value.DistributedLockDuration;
-    private readonly TimeSpan _lockRetryDelay = TimeSpan.FromMilliseconds(20);
+    private readonly TimeSpan _lockRetryDelay = TimeSpan.FromMilliseconds(10);
 
     public async ValueTask<T> GetOrCreateAsync(string key, Func<CancellationToken, ValueTask<T>> factory,
         TimeSpan? expiration = null, IReadOnlyCollection<string>? tags = null, CancellationToken token = default)
@@ -24,29 +24,35 @@ public async ValueTask<T> GetOrCreateAsync(string key, Func<CancellationToken, V
             ? KeyFormatHelper.GetPrefixedKey(key)
             : KeyFormatHelper.GetPrefixedKey(key, _moduleName);
 
-        var lockKey = $"{prefixedKey}:lock";
+        var lockKey = KeyFormatHelper.GetLockKey(prefixedKey);
         var lockValue = Guid.NewGuid().ToString();
 
         while (true)
         {
             token.ThrowIfCancellationRequested();
 
-            // Acquire lock before getting the value
-            var lockAcquired = await AcquireLockAsync(lockKey, lockValue);
+            var isLocked = await _redisDatabase.Database.KeyExistsAsync(lockKey);
 
-            if (!lockAcquired)
+            if (isLocked)
             {
                 await WaitForLockReleaseAsync(lockKey, token);
                 continue;
             }
 
             var cachedValue = await _redisDatabase.GetAsync<T>(prefixedKey);
-
             if (cachedValue != null)
             {
-                await ReleaseLockAsync(lockKey, lockValue);
                 return cachedValue;
             }
+
+            var lockAcquired = await AcquireLockAsync(lockKey, lockValue);
+
+            if (!lockAcquired)
+            {
+                await WaitForLockReleaseAsync(lockKey, token);
+                continue;
+            }
+
             break;
         }
 
@@ -58,7 +64,6 @@ public async ValueTask<T> GetOrCreateAsync(string key, Func<CancellationToken, V
         }
         finally
         {
-            // Release the lock
             await ReleaseLockAsync(lockKey, lockValue);
         }
     }
@@ -119,7 +124,7 @@ public async ValueTask RemoveByTagAsync(string tag, CancellationToken token = de
         var tagKey = _config.KeyPrefixForIsolation == KeyPrefix.None
             ? KeyFormatHelper.GetTagKey(tag)
             : KeyFormatHelper.GetTagKey(tag, _moduleName);
-        
+
         var keys = await _redisDatabase.SetMembersAsync<string>(tagKey);
         if (keys.Length > 0)
         {

src/DistributedCache/Services/Implementations/RedisCacheService.cs

@@ -10,14 +10,14 @@ namespace DistributedCache.Services.Implementations;
 public class RedisHealthCheckService(
     IRedisClient redisClient,
     ILogger<RedisHealthCheckService> logger,
-    IOptions<CacheConfigurationOptions> options)
+    IOptions<CacheConfigurationOptions> options) // Discontinued Feature
     : BackgroundService
 {
     private readonly IRedisDatabase _redisDatabase = redisClient.GetDefaultDatabase();
     private readonly CacheConfigurationOptions _config = options.Value;
     private bool _resetRedis;
 
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken) //todo test as not working
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         if (_config.CacheResetMode == CacheResetMode.None)
         {