Merge pull request #56 from solidify-project/feature/lazy-cache-mutex

Feature/lazy cache mutex

Author: boyko-ant

src/SolidifyProject.Engine.Services/ContentReaderService/FileSystemBinaryContentReaderService.cs

@@ -11,7 +11,7 @@ public FileSystemBinaryContentReaderService(string root)
         {
         }
 
-        public override async Task<T> LoadContentByIdAsync(string id)
+        protected override async Task<T> LoadContentByIdAsyncInternal(string id)
         {
             var path = Path.Combine(_root, id);
 

src/SolidifyProject.Engine.Services/ContentReaderService/FileSystemTextContentReaderService.cs

@@ -11,7 +11,7 @@ public FileSystemTextContentReaderService(string root)
         {
         }
 
-        public override async Task<T> LoadContentByIdAsync(string id)
+        protected override async Task<T> LoadContentByIdAsyncInternal(string id)
         {
             var path = Path.Combine(_root, id);
 

src/SolidifyProject.Engine.Services/ContentReaderService/_FileSystemContentReaderServiceBase.cs

@@ -7,7 +7,7 @@
 
 namespace SolidifyProject.Engine.Services.ContentReaderService
 {
-    public abstract class _FileSystemContentReaderServiceBase<T> : IContentReaderService<T> where T : class
+    public abstract class _FileSystemContentReaderServiceBase<T> : _FileSystemContentServiceBase, IContentReaderService<T> where T : class
     {
         public readonly string[] IGNORED_FILES = {"README.md", ".DS_Store"};
         protected readonly string _root;
@@ -53,6 +53,20 @@ public async Task<IEnumerable<string>> LoadContentsIdsAsync(bool includeIgnored
         /// </summary>
         /// <param name="id"></param>
         /// <returns>File content or null, if file wasn't found.</returns>
-        public abstract Task<T> LoadContentByIdAsync(string id);
+        public async Task<T> LoadContentByIdAsync(string id)
+        {
+            LockFileByKey(id);
+
+            try
+            {
+                return await LoadContentByIdAsyncInternal(id);
+            }
+            finally
+            {
+                ReleaseFileByKey(id);
+            }
+        }
+
+        protected abstract Task<T> LoadContentByIdAsyncInternal(string id);
     }
 }

src/SolidifyProject.Engine.Services/ContentWriterService/FileSystemBinaryContentWriterService.cs

@@ -11,7 +11,7 @@ public FileSystemBinaryContentWriterService(string root)
         {
         }
 
-        public override async Task SaveContentAsync(string id, T content)
+        protected override async Task SaveContentAsyncInternal(string id, T content)
         {
             var path = Path.Combine(_root, id);
             EnsureDirectoryExists(path);

src/SolidifyProject.Engine.Services/ContentWriterService/FileSystemTextContentWriterService.cs

@@ -11,7 +11,7 @@ public FileSystemTextContentWriterService(string root)
         {
         }
 
-        public override async Task SaveContentAsync(string id, T content)
+        protected override async Task SaveContentAsyncInternal(string id, T content)
         {
             var path = Path.Combine(_root, id);
             EnsureDirectoryExists(path);

src/SolidifyProject.Engine.Services/ContentWriterService/_FileSystemContentWriterServiceBase.cs

@@ -1,10 +1,11 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Threading.Tasks;
 using SolidifyProject.Engine.Infrastructure.Interfaces;
 
 namespace SolidifyProject.Engine.Services.ContentWriterService
 {
-    public abstract class _FileSystemContentWriterServiceBase<T> : IContentWriterService<T> where T : class 
+    public abstract class _FileSystemContentWriterServiceBase<T> : _FileSystemContentServiceBase, IContentWriterService<T> where T : class 
     {
         protected readonly string _root;
 
@@ -43,6 +44,20 @@ public Task CleanFolderAsync(string path)
             return Task.CompletedTask;
         }
 
-        public abstract Task SaveContentAsync(string id, T content);
+        public async Task SaveContentAsync(string id, T content)
+        {
+            LockFileByKey(id);
+
+            try
+            {
+                await SaveContentAsyncInternal(id, content);
+            }
+            finally
+            {
+                ReleaseFileByKey(id);
+            }
+        }
+
+        protected abstract Task SaveContentAsyncInternal(string id, T content);
     }
 }

src/SolidifyProject.Engine.Services/_FileSystemContentServiceBase.cs

@@ -0,0 +1,43 @@
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace SolidifyProject.Engine.Services
+{
+    public abstract class _FileSystemContentServiceBase
+    {
+        private static readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphores = new ConcurrentDictionary<string, SemaphoreSlim>();
+
+        protected _FileSystemContentServiceBase(string root = null)
+        {
+        }
+
+        protected void LockFileByKey(string key)
+        {
+            var fileLock = _getLockByKey(key);
+            fileLock.Wait();
+        }
+
+        protected void ReleaseFileByKey(string key)
+        {
+            var fileLock = _getLockByKey(key);
+            fileLock.Release(); 
+        }
+
+        private static SemaphoreSlim _getLockByKey(string key)
+        {
+            SemaphoreSlim result;
+            if (_semaphores.TryGetValue(key, out result))
+            {
+                return result;
+            }
+
+            result = new SemaphoreSlim(1, 1);
+            if (_semaphores.TryAdd(key, result))
+            {
+                return result;
+            }
+
+            return _getLockByKey(key);
+        }
+    }
+}

src/SolidifyProject.Engine.Utils/Cache/LazyCache.cs

@@ -11,7 +11,7 @@ public sealed class LazyCache<T> where T : class
         private readonly LoadToCacheAsyncDelegate _loadToCache;
 
         private readonly ConcurrentDictionary<string, Lazy<Task<T>>> _cache= new ConcurrentDictionary<string, Lazy<Task<T>>>();
-
+        
         public LazyCache(LoadToCacheAsyncDelegate loadToCache)
         {
             _loadToCache = loadToCache;
@@ -23,9 +23,9 @@ public async Task<T> GetFromCacheAsync(string key)
             {
                 return await result.Value.ConfigureAwait(false);
             }
-
-            result = new Lazy<Task<T>>(() => _loadToCache(key));
 
+            result = new Lazy<Task<T>>(() => _loadToCache(key));
+
             _cache.AddOrUpdate(key, result, (k, r) => result);
 
             return await GetFromCacheAsync(key).ConfigureAwait(false);