Abstract cache key creation to ICacheKey

Author: ronaldbarendse

samples/ImageSharp.Web.Sample/Startup.cs

@@ -54,6 +54,7 @@ public void ConfigureServices(IServiceCollection services)
                                 provider.GetRequiredService<IOptions<ImageSharpMiddlewareOptions>>(),
                                 provider.GetRequiredService<FormatUtilities>());
                 })
+                .SetCacheKey<CacheKey>()
                 .SetCacheHash<CacheHash>()
                 .AddProvider<PhysicalFileSystemProvider>()
                 .AddProcessor<ResizeWebProcessor>()
@@ -129,6 +130,7 @@ private void ConfigureCustomServicesAndCustomOptions(IServiceCollection services
                         provider.GetRequiredService<IOptions<ImageSharpMiddlewareOptions>>(),
                         provider.GetRequiredService<FormatUtilities>());
                 })
+                .SetCacheKey<CacheKey>()
                 .SetCacheHash<CacheHash>()
                 .ClearProviders()
                 .AddProvider<PhysicalFileSystemProvider>()

src/ImageSharp.Web/Caching/CacheKey.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Text;
+using Microsoft.AspNetCore.Http;
+using SixLabors.ImageSharp.Web.Commands;
+
+namespace SixLabors.ImageSharp.Web.Caching
+{
+    /// <summary>
+    /// Creates a cache key based on the lowercased request host, path and commands.
+    /// </summary>
+    public class CacheKey : ICacheKey
+    {
+        /// <inheritdoc/>
+        public string Create(HttpContext context, CommandCollection commands)
+        {
+            var sb = new StringBuilder(context.Request.Host.ToString());
+
+            string pathBase = context.Request.PathBase.ToString();
+            if (!string.IsNullOrWhiteSpace(pathBase))
+            {
+                sb.AppendFormat("{0}/", pathBase);
+            }
+
+            string path = context.Request.Path.ToString();
+            if (!string.IsNullOrWhiteSpace(path))
+            {
+                sb.Append(path);
+            }
+
+            sb.Append(QueryString.Create(commands));
+
+            return sb.ToString().ToLowerInvariant();
+        }
+    }
+}

src/ImageSharp.Web/Caching/ICacheKey.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using Microsoft.AspNetCore.Http;
+using SixLabors.ImageSharp.Web.Commands;
+
+namespace SixLabors.ImageSharp.Web.Caching
+{
+    /// <summary>
+    /// Defines a contract that allows the creation of cache keys (used by <see cref="ICacheHash"/> to create hashed file names for storing cached images).
+    /// </summary>
+    public interface ICacheKey
+    {
+        /// <summary>
+        /// Creates the cache key based on the specified context and commands.
+        /// </summary>
+        /// <param name="context">The HTTP context.</param>
+        /// <param name="commands">The commands.</param>
+        /// <returns>
+        /// The cache key.
+        /// </returns>
+        string Create(HttpContext context, CommandCollection commands);
+    }
+}

src/ImageSharp.Web/DependencyInjection/ImageSharpBuilderExtensions.cs

@@ -96,6 +96,33 @@ public static IImageSharpBuilder SetCache(this IImageSharpBuilder builder, Func<
             return builder;
         }
 
+        /// <summary>
+        /// Sets the given <see cref="ICacheKey"/> adding it to the service collection.
+        /// </summary>
+        /// <typeparam name="T">The type of class implementing <see cref="ICacheKey"/> to add.</typeparam>
+        /// <param name="builder">The core builder.</param>
+        /// <returns>The <see cref="IImageSharpBuilder"/>.</returns>
+        public static IImageSharpBuilder SetCacheKey<T>(this IImageSharpBuilder builder)
+            where T : class, ICacheKey
+        {
+            var descriptor = new ServiceDescriptor(typeof(ICacheKey), typeof(T), ServiceLifetime.Singleton);
+            builder.Services.Replace(descriptor);
+            return builder;
+        }
+
+        /// <summary>
+        /// Sets the given <see cref="ICacheKey"/> adding it to the service collection.
+        /// </summary>
+        /// <param name="builder">The core builder.</param>
+        /// <param name="implementationFactory">The factory method for returning a <see cref="ICacheKey"/>.</param>
+        /// <returns>The <see cref="IImageSharpBuilder"/>.</returns>
+        public static IImageSharpBuilder SetCacheKey(this IImageSharpBuilder builder, Func<IServiceProvider, ICacheKey> implementationFactory)
+        {
+            var descriptor = new ServiceDescriptor(typeof(ICacheKey), implementationFactory, ServiceLifetime.Singleton);
+            builder.Services.Replace(descriptor);
+            return builder;
+        }
+
         /// <summary>
         /// Sets the given <see cref="ICacheHash"/> adding it to the service collection.
         /// </summary>

src/ImageSharp.Web/DependencyInjection/ServiceCollectionExtensions.cs

@@ -64,6 +64,8 @@ private static void AddDefaultServices(
 
             builder.SetCache<PhysicalFileSystemCache>();
 
+            builder.SetCacheKey<CacheKey>();
+
             builder.SetCacheHash<CacheHash>();
 
             builder.AddProvider<PhysicalFileSystemProvider>();

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -70,6 +70,11 @@ private static readonly ConcurrentTLruCache<string, ImageMetadata> SourceMetadat
         /// </summary>
         private readonly IImageWebProcessor[] processors;
 
+        /// <summary>
+        /// The cache key.
+        /// </summary>
+        private readonly ICacheKey cacheKey;
+
         /// <summary>
         /// The image cache.
         /// </summary>
@@ -115,6 +120,7 @@ private static readonly ConcurrentTLruCache<string, ImageMetadata> SourceMetadat
         /// <param name="resolvers">A collection of <see cref="IImageProvider"/> instances used to resolve images.</param>
         /// <param name="processors">A collection of <see cref="IImageWebProcessor"/> instances used to process images.</param>
         /// <param name="cache">An <see cref="IImageCache"/> instance used for caching images.</param>
+        /// <param name="cacheKey">An <see cref="ICacheKey"/> instance used for creating cache keys.</param>
         /// <param name="cacheHash">An <see cref="ICacheHash"/>instance used for calculating cached file names.</param>
         /// <param name="commandParser">The command parser</param>
         /// <param name="formatUtilities">Contains various format helper methods based on the current configuration.</param>
@@ -127,6 +133,7 @@ public ImageSharpMiddleware(
             IEnumerable<IImageProvider> resolvers,
             IEnumerable<IImageWebProcessor> processors,
             IImageCache cache,
+            ICacheKey cacheKey,
             ICacheHash cacheHash,
             CommandParser commandParser,
             FormatUtilities formatUtilities,
@@ -139,6 +146,7 @@ public ImageSharpMiddleware(
             Guard.NotNull(resolvers, nameof(resolvers));
             Guard.NotNull(processors, nameof(processors));
             Guard.NotNull(cache, nameof(cache));
+            Guard.NotNull(cacheKey, nameof(cacheKey));
             Guard.NotNull(cacheHash, nameof(cacheHash));
             Guard.NotNull(commandParser, nameof(commandParser));
             Guard.NotNull(formatUtilities, nameof(formatUtilities));
@@ -150,6 +158,7 @@ public ImageSharpMiddleware(
             this.providers = resolvers as IImageProvider[] ?? resolvers.ToArray();
             this.processors = processors as IImageWebProcessor[] ?? processors.ToArray();
             this.cache = cache;
+            this.cacheKey = cacheKey;
             this.cacheHash = cacheHash;
             this.commandParser = commandParser;
             this.parserCulture = this.options.UseInvariantParsingCulture
@@ -259,21 +268,21 @@ private async Task ProcessRequestAsync(
             ImageContext imageContext,
             CommandCollection commands)
         {
-            // Create a cache key based on all the components of the requested url
-            string uri = GetUri(context, commands);
-            string key = this.cacheHash.Create(uri, this.options.CachedNameLength);
+            // Create a cache key and hash
+            string cacheKey = this.cacheKey.Create(context, commands);
+            string cacheHash = this.cacheHash.Create(cacheKey, this.options.CachedNameLength);
 
             // Check the cache, if present, not out of date and not requiring an update
             // we'll simply serve the file from there.
             ImageWorkerResult readResult = default;
-            using (await this.asyncKeyLock.ReaderLockAsync(key))
+            using (await this.asyncKeyLock.ReaderLockAsync(cacheHash))
             {
-                readResult = await this.IsNewOrUpdatedAsync(sourceImageResolver, key);
+                readResult = await this.IsNewOrUpdatedAsync(sourceImageResolver, cacheHash);
             }
 
             if (!readResult.IsNewOrUpdated)
             {
-                await this.SendResponseAsync(imageContext, key, readResult.CacheImageMetadata, readResult.Resolver, null);
+                await this.SendResponseAsync(imageContext, cacheHash, readResult.CacheImageMetadata, readResult.Resolver, null);
                 return;
             }
 
@@ -285,7 +294,7 @@ private async Task ProcessRequestAsync(
             RecyclableMemoryStream outStream = null;
             try
             {
-                Task<IDisposable> takeLockTask = this.asyncKeyLock.WriterLockAsync(key);
+                Task<IDisposable> takeLockTask = this.asyncKeyLock.WriterLockAsync(cacheHash);
                 bool lockWasAlreadyHeld = takeLockTask.Status != TaskStatus.RanToCompletion;
                 using (await takeLockTask)
                 {
@@ -294,7 +303,7 @@ private async Task ProcessRequestAsync(
                     // the cache one more time
                     if (lockWasAlreadyHeld)
                     {
-                        readResult = await this.IsNewOrUpdatedAsync(sourceImageResolver, key);
+                        readResult = await this.IsNewOrUpdatedAsync(sourceImageResolver, cacheHash);
                     }
 
                     if (readResult.IsNewOrUpdated)
@@ -356,12 +365,12 @@ private async Task ProcessRequestAsync(
                                 outStream.Length);
 
                             // Save the image to the cache and send the response to the caller.
-                            await this.cache.SetAsync(key, outStream, cachedImageMetadata);
+                            await this.cache.SetAsync(cacheHash, outStream, cachedImageMetadata);
                             outStream.Position = 0;
 
                             // Remove any resolver from the cache so we always resolve next request
                             // for the same key.
-                            CacheResolverLru.TryRemove(key);
+                            CacheResolverLru.TryRemove(cacheHash);
 
                             readResult = new ImageWorkerResult(cachedImageMetadata, null);
                         }
@@ -375,7 +384,7 @@ private async Task ProcessRequestAsync(
                     }
                 }
 
-                await this.SendResponseAsync(imageContext, key, readResult.CacheImageMetadata, readResult.Resolver, outStream);
+                await this.SendResponseAsync(imageContext, cacheHash, readResult.CacheImageMetadata, readResult.Resolver, outStream);
             }
             finally
             {
@@ -507,26 +516,5 @@ private async Task SendResponseAsync(
                     throw exception;
             }
         }
-
-        private static string GetUri(HttpContext context, CommandCollection commands)
-        {
-            var sb = new StringBuilder(context.Request.Host.ToString());
-
-            string pathBase = context.Request.PathBase.ToString();
-            if (!string.IsNullOrWhiteSpace(pathBase))
-            {
-                sb.AppendFormat("{0}/", pathBase);
-            }
-
-            string path = context.Request.Path.ToString();
-            if (!string.IsNullOrWhiteSpace(path))
-            {
-                sb.Append(path);
-            }
-
-            sb.Append(QueryString.Create(commands));
-
-            return sb.ToString().ToLowerInvariant();
-        }
     }
 }