Merge pull request #194 from kroymann/enable_null_cache

Restore ability to use null cache

Author: JimBobSquarePants

src/ImageSharp.Web/DependencyInjection/ServiceCollectionExtensions.cs

@@ -11,6 +11,7 @@
 using SixLabors.ImageSharp.Web.Middleware;
 using SixLabors.ImageSharp.Web.Processors;
 using SixLabors.ImageSharp.Web.Providers;
+using SixLabors.ImageSharp.Web.Synchronization;
 
 namespace SixLabors.ImageSharp.Web.DependencyInjection
 {
@@ -57,6 +58,8 @@ private static void AddDefaultServices(
 
             builder.Services.AddSingleton<FormatUtilities>();
 
+            builder.Services.AddSingleton<AsyncKeyReaderWriterLock<string>>();
+
             builder.SetRequestParser<QueryCollectionRequestParser>();
 
             builder.SetCache<PhysicalFileSystemCache>();

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+#nullable enable
+
+namespace SixLabors.ImageSharp.Web.Synchronization
+{
+    /// <summary>
+    /// Extension of the <see cref="AsyncLock"/> that enables fine-grained locking on a given key.
+    /// Concurrent lock requests using different keys can execute simultaneously, while requests to lock
+    /// using the same key will be forced to wait. This object is thread-safe and internally uses a pooling
+    /// mechanism to minimize allocation of new locks.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    public class AsyncKeyLock<TKey> : IDisposable
+        where TKey : notnull
+    {
+        private readonly RefCountedConcurrentDictionary<TKey, AsyncLock> activeLocks;
+        private readonly ConcurrentBag<AsyncLock> pool;
+        private readonly int maxPoolSize;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncKeyLock{TKey}"/> class.
+        /// </summary>
+        /// <param name="maxPoolSize">The maximum number of locks that should be pooled for reuse.</param>
+        public AsyncKeyLock(int maxPoolSize = 64)
+        {
+            this.pool = new ConcurrentBag<AsyncLock>();
+            this.activeLocks = new RefCountedConcurrentDictionary<TKey, AsyncLock>(this.CreateLeasedLock, this.ReturnLeasedLock);
+            this.maxPoolSize = maxPoolSize;
+        }
+
+        /// <summary>
+        /// Locks the current thread asynchronously.
+        /// </summary>
+        /// <param name="key">The key identifying the specific object to lock against.</param>
+        /// <returns>
+        /// The <see cref="IDisposable"/> that will release the lock.
+        /// </returns>
+        public Task<IDisposable> LockAsync(TKey key)
+            => this.activeLocks.Get(key).LockAsync();
+
+        /// <summary>
+        /// Releases all resources used by the current instance of the <see cref="AsyncKeyLock{TKey}"/> class.
+        /// </summary>
+        public void Dispose()
+        {
+            // Dispose of all the locks in the pool
+            while (this.pool.TryTake(out AsyncLock? asyncLock))
+            {
+                asyncLock.Dispose();
+            }
+
+            // activeLocks SHOULD be empty at this point so we don't need to try and clear it out.
+            // If it's not empty, then this object is being disposed of prematurely!
+        }
+
+        private AsyncLock CreateLeasedLock(TKey key)
+        {
+            if (!this.pool.TryTake(out AsyncLock? asyncLock))
+            {
+                asyncLock = new AsyncLock();
+            }
+
+            asyncLock.OnRelease = () => this.activeLocks.Release(key);
+            return asyncLock;
+        }
+
+        private void ReturnLeasedLock(AsyncLock asyncLock)
+        {
+            if (this.pool.Count < this.maxPoolSize)
+            {
+                this.pool.Add(asyncLock);
+            }
+            else
+            {
+                asyncLock.Dispose();
+            }
+        }
+    }
+}

src/ImageSharp.Web/Synchronization/AsyncKeyLock.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+#nullable enable
+
+namespace SixLabors.ImageSharp.Web.Synchronization
+{
+    /// <summary>
+    /// Extension of the <see cref="AsyncReaderWriterLock"/> that enables fine-grained locking on a given key.
+    /// Concurrent write lock requests using different keys can execute simultaneously, while requests to lock
+    /// using the same key will be forced to wait. This object is thread-safe and internally uses a pooling
+    /// mechanism to minimize allocation of new locks.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the key.</typeparam>
+    public class AsyncKeyReaderWriterLock<TKey>
+        where TKey : notnull
+    {
+        private readonly RefCountedConcurrentDictionary<TKey, AsyncReaderWriterLock> activeLocks;
+        private readonly ConcurrentBag<AsyncReaderWriterLock> pool;
+        private readonly int maxPoolSize;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncKeyReaderWriterLock{TKey}"/> class.
+        /// </summary>
+        /// <param name="maxPoolSize">The maximum number of locks that should be pooled for reuse.</param>
+        public AsyncKeyReaderWriterLock(int maxPoolSize = 64)
+        {
+            this.pool = new ConcurrentBag<AsyncReaderWriterLock>();
+            this.activeLocks = new RefCountedConcurrentDictionary<TKey, AsyncReaderWriterLock>(this.CreateLeasedLock, this.ReturnLeasedLock);
+            this.maxPoolSize = maxPoolSize;
+        }
+
+        /// <summary>
+        /// Locks the current thread in read mode asynchronously.
+        /// </summary>
+        /// <param name="key">The key identifying the specific object to lock against.</param>
+        /// <returns>
+        /// The <see cref="IDisposable"/> that will release the lock.
+        /// </returns>
+        public Task<IDisposable> ReaderLockAsync(TKey key)
+            => this.activeLocks.Get(key).ReaderLockAsync();
+
+        /// <summary>
+        /// Locks the current thread in write mode asynchronously.
+        /// </summary>
+        /// <param name="key">The key identifying the specific object to lock against.</param>
+        /// <returns>
+        /// The <see cref="IDisposable"/> that will release the lock.
+        /// </returns>
+        public Task<IDisposable> WriterLockAsync(TKey key)
+            => this.activeLocks.Get(key).WriterLockAsync();
+
+        private AsyncReaderWriterLock CreateLeasedLock(TKey key)
+        {
+            if (!this.pool.TryTake(out AsyncReaderWriterLock? asyncLock))
+            {
+                asyncLock = new AsyncReaderWriterLock();
+            }
+
+            asyncLock.OnRelease = () => this.activeLocks.Release(key);
+            return asyncLock;
+        }
+
+        private void ReturnLeasedLock(AsyncReaderWriterLock asyncLock)
+        {
+            if (this.pool.Count < this.maxPoolSize)
+            {
+                this.pool.Add(asyncLock);
+            }
+        }
+    }
+}

src/ImageSharp.Web/Synchronization/AsyncKeyReaderWriterLock.cs

@@ -0,0 +1,92 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+#nullable enable
+
+namespace SixLabors.ImageSharp.Web.Synchronization
+{
+    /// <summary>
+    /// An asynchronous locker that uses an IDisposable pattern for releasing the lock.
+    /// </summary>
+    public class AsyncLock : IDisposable
+    {
+        private readonly SemaphoreSlim semaphore;
+#pragma warning disable IDE0069 // Disposable fields should be disposed
+        private readonly IDisposable releaser;
+#pragma warning restore IDE0069 // Disposable fields should be disposed
+        private readonly Task<IDisposable> releaserTask;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncLock"/> class.
+        /// </summary>
+        public AsyncLock()
+        {
+            this.semaphore = new SemaphoreSlim(1, 1);
+            this.releaser = new Releaser(this);
+            this.releaserTask = Task.FromResult(this.releaser);
+        }
+
+        /// <summary>
+        /// Gets or sets the callback that should be invoked whenever this lock is released.
+        /// </summary>
+        public Action? OnRelease { get; set; }
+
+        /// <summary>
+        /// Asynchronously obtains the lock. Dispose the returned <see cref="IDisposable"/> to release the lock.
+        /// </summary>
+        /// <returns>
+        /// The <see cref="IDisposable"/> that will release the lock.
+        /// </returns>
+        public Task<IDisposable> LockAsync()
+        {
+            Task wait = this.semaphore.WaitAsync();
+
+            // No-allocation fast path when the semaphore wait completed synchronously
+            return (wait.Status == TaskStatus.RanToCompletion)
+                ? this.releaserTask
+                : AwaitThenReturn(wait, this.releaser);
+
+            static async Task<IDisposable> AwaitThenReturn(Task t, IDisposable r)
+            {
+                await t;
+                return r;
+            }
+        }
+
+        private void Release()
+        {
+            try
+            {
+                this.semaphore.Release();
+            }
+            finally
+            {
+                this.OnRelease?.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// Releases all resources used by the current instance of the <see cref="AsyncLock"/> class.
+        /// </summary>
+        public void Dispose() => this.semaphore.Dispose();
+
+        /// <summary>
+        /// Utility class that releases an <see cref="AsyncLock"/> on disposal.
+        /// </summary>
+        private sealed class Releaser : IDisposable
+        {
+            private readonly AsyncLock toRelease;
+
+            internal Releaser(AsyncLock toRelease) => this.toRelease = toRelease;
+
+            /// <summary>
+            /// Releases the <see cref="AsyncLock"/> associated with this <see cref="Releaser"/>.
+            /// </summary>
+            public void Dispose() => this.toRelease?.Release();
+        }
+    }
+}