Merge pull request #102 from martijnboland/85-distributedcache

Use IDistributedCache instead of IMemoryCache to support multi-instan…

Author: martijnboland

src/AppText.Localization/AppTextBridge.cs

@@ -1,7 +1,9 @@
 using AppText.Features.Application;
 using AppText.Features.ContentManagement;
+using AppText.Shared.Extensions;
 using AppText.Shared.Infrastructure;
 using AppText.Storage;
+using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -25,13 +27,13 @@ public class AppTextBridge
 
         private readonly ILogger<AppTextBridge> _logger;
         private readonly AppTextLocalizationOptions _options;
-        private readonly IMemoryCache _cache;
+        private readonly IDistributedCache _cache;
         private readonly IServiceProvider _serviceProvider;
         private ISet<string> _cacheKeys;
 
         public AppTextBridge(
             IServiceProvider serviceProvider,
-            IMemoryCache cache,
+            IDistributedCache cache,
             IOptions<AppTextLocalizationOptions> options,
             ILogger<AppTextBridge> logger
         )
@@ -83,27 +85,34 @@ private Dictionary<string, string> GetTranslationsDictionary(string culture)
             // When culture is invariant, the name is an empty string. Use the default language in that case.
             if (culture == String.Empty)
             {
-                var currentApp = _cache.GetOrCreate(AppCacheKey, c => new Lazy<App>(LoadApp, LazyThreadSafetyMode.ExecutionAndPublication)).Value;
+                var currentApp = _cache.Get<App>(AppCacheKey);
+                if (currentApp == null)
+                {
+                    currentApp = LoadApp();
+                    _cache.Set(AppCacheKey, currentApp);
+                }
                 if (currentApp == null)
                 {
                     throw new InvalidOperationException($"Can not get the translations because the AppText app {_options.AppId} is not found");
                 }
                 culture = currentApp.DefaultLanguage;
             }
 
-            var cachedDictionary = _cache.GetOrCreate(CacheKeyPrefix + culture, c => new Lazy<Dictionary<string, string>>(() =>
+            var cacheKey = CacheKeyPrefix + culture;
+            var cachedDictionary = _cache.Get<Dictionary<string, string>>(cacheKey);
+            if (cachedDictionary == null)
             {
                 _logger.LogInformation("Initializing translations dictionary for culture {0}", culture);
-                var dictionary = new Dictionary<string, string>();
-                LoadTranslationsIntoDictionary(culture, dictionary);
-                if (! _cacheKeys.Contains(c.Key))
+                cachedDictionary = new Dictionary<string, string>();
+                LoadTranslationsIntoDictionary(culture, cachedDictionary);
+                if (! _cacheKeys.Contains(cacheKey))
                 {
-                    _cacheKeys.Add(c.Key.ToString());
+                    _cacheKeys.Add(cacheKey);
                 }
-                return dictionary;
-            }, LazyThreadSafetyMode.ExecutionAndPublication));
+                _cache.Set(cacheKey, cachedDictionary);
+            }
 
-            return cachedDictionary.Value;
+            return cachedDictionary;
         }
 
         private App LoadApp()

src/AppText/Configuration/AppTextBuilder.cs

@@ -91,7 +91,7 @@ private void RegisterCoreServices()
                 () => sp.GetRequiredService<IScopedServiceFactory>().GetService<IContentStore>());
 
             // Cache
-            Services.AddMemoryCache();
+            Services.AddDistributedMemoryCache();
 
             // ApiKey authentication scheme
             var authenticationBuilder = Services.AddAuthentication();

src/AppText/Features/GraphQL/SchemaResolver.cs

@@ -1,5 +1,7 @@
-using AppText.Storage;
+using AppText.Shared.Extensions;
+using AppText.Storage;
 using GraphQL.Types;
+using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using System;
@@ -12,12 +14,12 @@ public class SchemaResolver
         private readonly ILogger<SchemaResolver> _logger;
         private readonly Func<IContentStore> _getContentStore;
         private readonly Func<IApplicationStore> _getApplicationStore;
-        private readonly IMemoryCache _memoryCache;
+        private readonly IDistributedCache _cache;
 
-        public SchemaResolver(ILogger<SchemaResolver> logger, IMemoryCache memoryCache, Func<IApplicationStore> getApplicationStore, Func<IContentStore> getContentStore)
+        public SchemaResolver(ILogger<SchemaResolver> logger, IDistributedCache cache, Func<IApplicationStore> getApplicationStore, Func<IContentStore> getContentStore)
         {
             _logger = logger;
-            _memoryCache = memoryCache;
+            _cache = cache;
             _getApplicationStore = getApplicationStore;
             _getContentStore = getContentStore;
         }
@@ -29,20 +31,21 @@ public SchemaResolver(ILogger<SchemaResolver> logger, IMemoryCache memoryCache,
         public async Task<ISchema> Resolve(string appId)
         {
             var cacheKey = $"Schema_{appId}";
-
-            return await _memoryCache.GetOrCreateAsync(cacheKey, async cacheEntry =>
+            var schema = _cache.Get<ISchema>(cacheKey);
+            if (schema == null)
             {
                 _logger.LogInformation("GraphQL schema for app {0} is not found in the cache. Creating new instance...", appId);
-                return await CreateSchema(appId);
-            });
+                schema = await CreateSchema(appId);
+            }
+            return schema;
         }
 
         public void Clear(string appId)
         {
             _logger.LogInformation("Clearing GraphQL schema for app {0}", appId);
 
             var cacheKey = $"Schema_{appId}";
-            _memoryCache.Remove(cacheKey);
+            _cache.Remove(cacheKey);
         }
 
         private async Task<Schema> CreateSchema(string appId)

src/AppText/Shared/Extensions/IDistributedCacheExtensions.cs

@@ -0,0 +1,38 @@
+using Microsoft.Extensions.Caching.Distributed;
+using Newtonsoft.Json;
+using System;
+using System.Threading.Tasks;
+
+namespace AppText.Shared.Extensions
+{
+    public static class IDistributedCacheExtensions
+    {
+        public static void Set<T>(this IDistributedCache cache,
+                                           string cacheKey,
+                                           T data,
+                                           TimeSpan? absoluteExpireTime = null,
+                                           TimeSpan? slidingExpireTime = null)
+        {
+            var options = new DistributedCacheEntryOptions
+            {
+                AbsoluteExpirationRelativeToNow = absoluteExpireTime ?? TimeSpan.FromMinutes(1),
+                SlidingExpiration = slidingExpireTime
+            };
+
+            var jsonData = JsonConvert.SerializeObject(data);
+            cache.SetString(cacheKey, jsonData, options);
+        }
+
+        public static T Get<T>(this IDistributedCache cache, string cacheKey)
+        {
+            var jsonData = cache.GetString(cacheKey);
+
+            if (jsonData is null)
+            {
+                return default;
+            }
+
+            return JsonConvert.DeserializeObject<T>(jsonData);
+        }
+    }
+}