fix: LockMs/SleepMs only for TiSvc

billhong-just · Sep 12, 2023 · 428f598 · 428f598
1 parent c74ad32
commit 428f598
Show file tree

Hide file tree

Showing 15 changed files with 199 additions and 40 deletions.
diff --git a/build/version.props b/build/version.props
@@ -1,11 +1,11 @@
 <Project>
 	<PropertyGroup>
-		<EasyCachingCorePackageVersion>1.9.1</EasyCachingCorePackageVersion>
+		<EasyCachingCorePackageVersion>1.9.2</EasyCachingCorePackageVersion>
 		<EasyCachingMemcachedPackageVersion>1.9.1</EasyCachingMemcachedPackageVersion>
-		<EasyCachingRedisPackageVersion>1.9.1</EasyCachingRedisPackageVersion>
+		<EasyCachingRedisPackageVersion>1.9.2</EasyCachingRedisPackageVersion>
 		<EasyCachingSQLitePackageVersion>1.9.1</EasyCachingSQLitePackageVersion>
-		<EasyCachingInMemoryPackageVersion>1.9.1</EasyCachingInMemoryPackageVersion>
-		<EasyCachingHybridPackageVersion>1.9.1</EasyCachingHybridPackageVersion>
+		<EasyCachingInMemoryPackageVersion>1.9.2</EasyCachingInMemoryPackageVersion>
+		<EasyCachingHybridPackageVersion>1.9.2</EasyCachingHybridPackageVersion>
 		<EasyCachingAspectCorePackageVersion>1.9.1</EasyCachingAspectCorePackageVersion>
 		<EasyCachingCastlePackageVersion>1.9.1</EasyCachingCastlePackageVersion>
 		<EasyCachingResponseCachingPackageVersion>1.9.1</EasyCachingResponseCachingPackageVersion>

diff --git a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs
@@ -10,6 +10,10 @@
 
     public partial class DefaultCSRedisCachingProvider : EasyCachingAbstractProvider
     {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         /// <summary>
         /// Existses the async.
         /// </summary>

diff --git a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs
@@ -54,6 +54,7 @@ protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseP
         public abstract IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<string> cacheKeys);
         public abstract Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default);
         public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default);
+        public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default);
         public abstract Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default);
         public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default);
         public abstract IDictionary<string, CacheValue<T>> BaseGetByPrefix<T>(string prefix);
@@ -363,6 +364,13 @@ public async Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable
             }
         }
 
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            if (_lockFactory == null) return await BaseGetAsync<T>(cacheKey, dataRetriever, expirationRetriever, cancellationToken);
+            // TiSvc 沒用到，不實作
+            throw new NotImplementedException();
+        }
+
         public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey }, expiration));

diff --git a/src/EasyCaching.Core/IEasyCachingProviderBase.cs b/src/EasyCaching.Core/IEasyCachingProviderBase.cs
@@ -153,6 +153,17 @@ public interface IEasyCachingProviderBase
         /// <typeparam name="T">The 1st type parameter.</typeparam>
         Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Gets the specified cacheKey, dataRetriever and expirationRetriever async.
+        /// </summary>
+        /// <returns>The async.</returns>
+        /// <param name="cacheKey">Cache key.</param>
+        /// <param name="dataRetriever">Data retriever.</param>
+        /// <param name="expirationRetriever">Expiration retriever.</param>
+        /// <param name="cancellationToken"></param>
+        /// <typeparam name="T">The 1st type parameter.</typeparam>
+        Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Removes cached item by cachekey's prefix.
         /// </summary>

diff --git a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs
@@ -10,7 +10,11 @@
     using Microsoft.Extensions.Logging;
 
     public partial class DefaultDiskCachingProvider : EasyCachingAbstractProvider
-    {   
+    {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));

diff --git a/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs b/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs
@@ -9,6 +9,10 @@ namespace EasyCaching.FasterKv
 {
     public partial class DefaultFasterKvCachingProvider
     {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));

diff --git a/src/EasyCaching.HybridCache/HybridCachingProvider.cs b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
@@ -304,42 +304,26 @@ public CacheValue<T> Get<T>(string cacheKey)
         public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
-
-            var cacheValue = await _localCache.GetAsync<T>(cacheKey, cancellationToken);
-
-            if (cacheValue.HasValue)
-            {
-                return cacheValue;
-            }
-
-            LogMessage($"local cache can not get the value of {cacheKey}");
-
-            try
-            {
-                cacheValue = await _distributedCache.GetAsync<T>(cacheKey, cancellationToken);
-            }
-            catch (Exception ex)
-            {
-                LogMessage($"distributed cache get error, [{cacheKey}]", ex);
-
-                if (_options.ThrowIfDistributedCacheError)
+            var result = await _localCache.GetAsync(
+                cacheKey,
+                async () =>
                 {
-                    throw;
-                }
-            }
-
-            if (cacheValue.HasValue)
-            {
-                TimeSpan ts = await GetExpirationAsync(cacheKey, cancellationToken);
-
-                await _localCache.SetAsync(cacheKey, cacheValue.Value, ts, cancellationToken);
-
-                return cacheValue;
-            }
-
-            LogMessage($"distributed cache can not get the value of {cacheKey}");
-
-            return CacheValue<T>.NoValue;
+                    var value = default(T);
+                    try
+                    {
+                        value = (await _distributedCache.GetAsync<T>(cacheKey, cancellationToken)).Value;
+                    }
+                    catch (Exception ex)
+                    {
+                        LogMessage($"distributed cache get error, [{cacheKey}]", ex);
+                        if (_options.ThrowIfDistributedCacheError)
+                            throw;
+                    }
+                    return value;
+                },
+                () => GetExpirationAsync(cacheKey, cancellationToken),
+                cancellationToken);
+            return result;
         }
 
         /// <summary>
@@ -780,6 +764,21 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> data
             return CacheValue<T>.NoValue;
         }
 
+        /// <summary>
+        /// Gets the specified cacheKey, dataRetriever and expirationRetriever async.
+        /// </summary>
+        /// <returns>The async.</returns>
+        /// <param name="cacheKey">Cache key.</param>
+        /// <param name="dataRetriever">Data retriever.</param>
+        /// <param name="expirationRetriever">Expiration retriever.</param>
+        /// <param name="cancellationToken"></param>
+        /// <typeparam name="T">The 1st type parameter.</typeparam>
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            // TiSvc 沒用到，不實作
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// Removes the by prefix.
         /// </summary>

diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs
@@ -76,6 +76,61 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             }
         }
 
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
+
+            var result = _cache.Get<T>(cacheKey);
+            if (result.HasValue)
+            {
+                if (_options.EnableLogging)
+                    _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
+
+                CacheStats.OnHit();
+
+                return result;
+            }
+
+            CacheStats.OnMiss();
+
+            if (_options.EnableLogging)
+                _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}");
+
+            if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs)))
+            {
+                //wait for some ms
+                await Task.Delay(_options.SleepMs, cancellationToken);
+                return await GetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken);
+            }
+
+            try
+            {
+                var res = await dataRetriever();
+
+                if (res != null || _options.CacheNulls)
+                {
+                    TimeSpan expiration = await expirationRetriever();
+                    await SetAsync(cacheKey, res, expiration, cancellationToken);
+                    //remove mutex key
+                    _cache.Remove($"{cacheKey}_Lock");
+
+                    return new CacheValue<T>(res, true);
+                }
+                else
+                {
+                    //remove mutex key
+                    _cache.Remove($"{cacheKey}_Lock");
+                    return CacheValue<T>.NoValue;
+                }
+            }
+            catch
+            {
+                //remove mutex key
+                _cache.Remove($"{cacheKey}_Lock");
+                throw;
+            }
+        }
+
         /// <summary>
         /// Gets the specified cacheKey async.
         /// </summary>

diff --git a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs
@@ -12,6 +12,10 @@
     /// </summary>
     public partial class DefaultLiteDBCachingProvider : EasyCachingAbstractProvider
     {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         /// <summary>
         /// Existses the specified cacheKey async.
         /// </summary>

diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs
@@ -13,6 +13,10 @@
     /// </summary>
     public partial class DefaultMemcachedCachingProvider : EasyCachingAbstractProvider
     {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         /// <summary>
         /// Gets the specified cacheKey, dataRetriever and expiration async.
         /// </summary>

diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs
@@ -103,6 +103,53 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             }
         }
 
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
+
+            var result = await _cache.StringGetAsync(cacheKey);
+            if (!result.IsNull)
+            {
+                CacheStats.OnHit();
+
+                if (_options.EnableLogging)
+                    _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
+
+                var value = _serializer.Deserialize<T>(result);
+                return new CacheValue<T>(value, true);
+            }
+
+            CacheStats.OnMiss();
+
+            if (_options.EnableLogging)
+                _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}");
+
+            var flag = await _cache.StringSetAsync($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs), When.NotExists);
+
+            if (!flag)
+            {
+                await Task.Delay(_options.SleepMs, cancellationToken);
+                return await GetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken);
+            }
+
+            var item = await dataRetriever();
+            if (item != null || _options.CacheNulls)
+            {
+                TimeSpan expiration = await expirationRetriever();
+                await SetAsync(cacheKey, item, expiration, cancellationToken);
+
+                //remove mutex key
+                await _cache.KeyDeleteAsync($"{cacheKey}_Lock");
+                return new CacheValue<T>(item, true);
+            }
+            else
+            {
+                //remove mutex key
+                await _cache.KeyDeleteAsync($"{cacheKey}_Lock");
+                return CacheValue<T>.NoValue;
+            }
+        }
+
         /// <summary>
         /// Gets the specified cacheKey async.
         /// </summary>

diff --git a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs
@@ -14,6 +14,10 @@
     /// </summary>
     public partial class DefaultSQLiteCachingProvider : EasyCachingAbstractProvider
     {
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
         /// <summary>
         /// Existses the specified cacheKey async.
         /// </summary>

diff --git a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs
@@ -18,6 +18,11 @@ public MyCachingProvider()
             this.IsDistributedProvider = false;
         }
 
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
         public override bool BaseExists(string cacheKey)
         {
             return true;

diff --git a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs
@@ -205,5 +205,10 @@ public virtual Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan
         {
             return Task.FromResult(true);
         }
+
+        public Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs
@@ -205,5 +205,10 @@ public Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expirat
         {
             return Task.FromResult(true);
         }
+
+        public Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, Func<Task<TimeSpan>> expirationRetriever, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
     }
 }