Merge branch 'lock-temp-solution-only-for-tisvc' into dev

billhong-just · Sep 25, 2023 · d852b8b · d852b8b
2 parents c74ad32 + ec03330
commit d852b8b
Show file tree

Hide file tree

Showing 21 changed files with 245 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/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj b/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj
@@ -24,6 +24,7 @@
 	<PropertyGroup>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<NoWarn>$(NoWarn);1591</NoWarn>
+		<AssemblyName>Fix.Stampede.$(MSBuildProjectName)</AssemblyName>
 	</PropertyGroup>
 
 	<ItemGroup>

diff --git a/...zation/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj b/...zation/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj
@@ -24,6 +24,7 @@
 	<PropertyGroup>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<NoWarn>$(NoWarn);1591</NoWarn>
+		<AssemblyName>Fix.Stampede.$(MSBuildProjectName)</AssemblyName>
 	</PropertyGroup>
 
 	<ItemGroup>

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/EasyCaching.Core.csproj b/src/EasyCaching.Core/EasyCaching.Core.csproj
@@ -24,6 +24,7 @@
 	<PropertyGroup>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<NoWarn>$(NoWarn);1591</NoWarn>
+		<AssemblyName>Fix.Stampede.$(MSBuildProjectName)</AssemblyName>
 	</PropertyGroup>
 
 	<ItemGroup>

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,66 @@ 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)
+        {
+            var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey }));
+            Exception e = null;
+            try
+            {
+                if (_lockFactory == null) return await BaseGetAsync<T>(cacheKey, dataRetriever, expirationRetriever, cancellationToken);
+
+                var value = await BaseGetAsync<T>(cacheKey, cancellationToken);
+                if (value.HasValue) return value;
+
+                var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock");
+                try
+                {
+                    if (!await @lock.LockAsync(_options.SleepMs, cancellationToken)) throw new TimeoutException();
+
+                    value = await BaseGetAsync<T>(cacheKey, cancellationToken);
+                    if (value.HasValue) return value;
+
+                    var task = dataRetriever();
+                    if (!task.IsCompleted &&
+                        await Task.WhenAny(task, Task.Delay(_options.LockMs, cancellationToken)) != task)
+                        throw new TimeoutException();
+
+                    var item = await task;
+                    if (item != null || _options.CacheNulls)
+                    {
+                        TimeSpan expiration = await expirationRetriever();
+                        await BaseSetAsync(cacheKey, item, expiration, cancellationToken);
+
+                        return new CacheValue<T>(item, true);
+                    }
+                    else
+                    {
+                        return CacheValue<T>.NoValue;
+                    }
+                }
+                finally
+                {
+                    await @lock.DisposeAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                e = ex;
+                throw;
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    s_diagnosticListener.WriteGetCacheError(operationId, e);
+                }
+                else
+                {
+                    s_diagnosticListener.WriteGetCacheAfter(operationId);
+                }
+            }
+        }
+
         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/EasyCaching.HybridCache.csproj b/src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj
@@ -24,6 +24,7 @@
 	<PropertyGroup>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<NoWarn>$(NoWarn);1591</NoWarn>
+		<AssemblyName>Fix.Stampede.$(MSBuildProjectName)</AssemblyName>
 	</PropertyGroup>
 
 	<ItemGroup>

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,48 @@ 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));
+            bool getLock = false;
+            do
+            {
+                var result = _cache.Get<T>(cacheKey);
+                if (result.HasValue)
+                    return result;
+                getLock = _cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs));
+                if (!getLock)
+                    await Task.Delay(_options.SleepMs, cancellationToken);
+            }
+            while (!getLock);
+            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.InMemory/EasyCaching.InMemory.csproj b/src/EasyCaching.InMemory/EasyCaching.InMemory.csproj
@@ -24,6 +24,7 @@
 	<PropertyGroup>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<NoWarn>$(NoWarn);1591</NoWarn>
+		<AssemblyName>Fix.Stampede.$(MSBuildProjectName)</AssemblyName>
 	</PropertyGroup>
 
 	<ItemGroup>

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>