Merge pull request #213 from ronaldbarendse/feature/cache-folderdepth

Add CacheFolderDepth option and create shorter file names

Author: JimBobSquarePants

samples/ImageSharp.Web.Sample/Startup.cs

@@ -51,11 +51,10 @@ public void ConfigureServices(IServiceCollection services)
                     return new PhysicalFileSystemCache(
                                 provider.GetRequiredService<IOptions<PhysicalFileSystemCacheOptions>>(),
                                 provider.GetRequiredService<IWebHostEnvironment>(),
-                                provider.GetRequiredService<IOptions<ImageSharpMiddlewareOptions>>(),
                                 provider.GetRequiredService<FormatUtilities>());
                 })
                 .SetCacheKey<UriRelativeLowerInvariantCacheKey>()
-                .SetCacheHash<CacheHash>()
+                .SetCacheHash<SHA256CacheHash>()
                 .AddProvider<PhysicalFileSystemProvider>()
                 .AddProcessor<ResizeWebProcessor>()
                 .AddProcessor<FormatWebProcessor>()
@@ -88,7 +87,7 @@ private void ConfigureDefaultServicesAndCustomOptions(IServiceCollection service
                         options.Configuration = Configuration.Default;
                         options.BrowserMaxAge = TimeSpan.FromDays(7);
                         options.CacheMaxAge = TimeSpan.FromDays(365);
-                        options.CachedNameLength = 8;
+                        options.CacheHashLength = 8;
                         options.OnParseCommandsAsync = _ => Task.CompletedTask;
                         options.OnBeforeSaveAsync = _ => Task.CompletedTask;
                         options.OnProcessedAsync = _ => Task.CompletedTask;
@@ -111,7 +110,7 @@ private void ConfigureCustomServicesAndCustomOptions(IServiceCollection services
                         options.Configuration = Configuration.Default;
                         options.BrowserMaxAge = TimeSpan.FromDays(7);
                         options.CacheMaxAge = TimeSpan.FromDays(365);
-                        options.CachedNameLength = 8;
+                        options.CacheHashLength = 8;
                         options.OnParseCommandsAsync = _ => Task.CompletedTask;
                         options.OnBeforeSaveAsync = _ => Task.CompletedTask;
                         options.OnProcessedAsync = _ => Task.CompletedTask;
@@ -127,11 +126,10 @@ private void ConfigureCustomServicesAndCustomOptions(IServiceCollection services
                     return new PhysicalFileSystemCache(
                         provider.GetRequiredService<IOptions<PhysicalFileSystemCacheOptions>>(),
                         provider.GetRequiredService<IWebHostEnvironment>(),
-                        provider.GetRequiredService<IOptions<ImageSharpMiddlewareOptions>>(),
                         provider.GetRequiredService<FormatUtilities>());
                 })
                 .SetCacheKey<UriRelativeLowerInvariantCacheKey>()
-                .SetCacheHash<CacheHash>()
+                .SetCacheHash<SHA256CacheHash>()
                 .ClearProviders()
                 .AddProvider<PhysicalFileSystemProvider>()
                 .ClearProcessors()

src/ImageSharp.Web/Caching/PhysicalFileSystemCache.cs

@@ -9,7 +9,6 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Options;
-using SixLabors.ImageSharp.Web.Middleware;
 using SixLabors.ImageSharp.Web.Resolvers;
 
 namespace SixLabors.ImageSharp.Web.Caching
@@ -25,25 +24,15 @@ public class PhysicalFileSystemCache : IImageCache
         private readonly string cacheRootPath;
 
         /// <summary>
-        /// The length of the filename to use (minus the extension) when storing images in the image cache.
+        /// The depth of the nested cache folders structure to store the images.
         /// </summary>
-        private readonly int cachedNameLength;
+        private readonly int cacheFolderDepth;
 
         /// <summary>
         /// The file provider abstraction.
         /// </summary>
         private readonly IFileProvider fileProvider;
 
-        /// <summary>
-        /// The cache configuration options.
-        /// </summary>
-        private readonly PhysicalFileSystemCacheOptions cacheOptions;
-
-        /// <summary>
-        /// The middleware configuration options.
-        /// </summary>
-        private readonly ImageSharpMiddlewareOptions options;
-
         /// <summary>
         /// Contains various format helper methods based on the current configuration.
         /// </summary>
@@ -52,35 +41,31 @@ public class PhysicalFileSystemCache : IImageCache
         /// <summary>
         /// Initializes a new instance of the <see cref="PhysicalFileSystemCache"/> class.
         /// </summary>
-        /// <param name="cacheOptions">The cache configuration options.</param>
+        /// <param name="options">The cache configuration options.</param>
         /// <param name="environment">The hosting environment the application is running in.</param>
-        /// <param name="options">The middleware configuration options.</param>
         /// <param name="formatUtilities">Contains various format helper methods based on the current configuration.</param>
         public PhysicalFileSystemCache(
-            IOptions<PhysicalFileSystemCacheOptions> cacheOptions,
+            IOptions<PhysicalFileSystemCacheOptions> options,
 #if NETCOREAPP2_1
             IHostingEnvironment environment,
 #else
             IWebHostEnvironment environment,
 #endif
-            IOptions<ImageSharpMiddlewareOptions> options,
             FormatUtilities formatUtilities)
         {
             Guard.NotNull(environment, nameof(environment));
             Guard.NotNull(options, nameof(options));
             Guard.NotNullOrWhiteSpace(environment.WebRootPath, nameof(environment.WebRootPath));
 
-            // Allow configuration of the cache without having to register everything.
-            this.cacheOptions = cacheOptions != null ? cacheOptions.Value : new PhysicalFileSystemCacheOptions();
-            this.cacheRootPath = GetCacheRoot(this.cacheOptions, environment.WebRootPath, environment.ContentRootPath);
-            if (!Directory.Exists(this.cacheRootPath))
-            {
-                Directory.CreateDirectory(this.cacheRootPath);
-            }
+            // Allow configuration of the cache without having to register everything
+            PhysicalFileSystemCacheOptions cacheOptions = options != null ? options.Value : new PhysicalFileSystemCacheOptions();
+            this.cacheRootPath = GetCacheRoot(cacheOptions, environment.WebRootPath, environment.ContentRootPath);
+            this.cacheFolderDepth = (int)cacheOptions.CacheFolderDepth;
+
+            // Ensure cache directory is created before initializing the file provider
+            Directory.CreateDirectory(this.cacheRootPath);
 
             this.fileProvider = new PhysicalFileProvider(this.cacheRootPath);
-            this.options = options.Value;
-            this.cachedNameLength = (int)this.options.CachedNameLength;
             this.formatUtilities = formatUtilities;
         }
 
@@ -105,7 +90,7 @@ internal static string GetCacheRoot(PhysicalFileSystemCacheOptions cacheOptions,
         /// <inheritdoc/>
         public Task<IImageCacheResolver> GetAsync(string key)
         {
-            string path = ToFilePath(key, this.cachedNameLength);
+            string path = ToFilePath(key, this.cacheFolderDepth);
 
             IFileInfo metaFileInfo = this.fileProvider.GetFileInfo(this.ToMetaDataFilePath(path));
             if (!metaFileInfo.Exists)
@@ -119,15 +104,13 @@ public Task<IImageCacheResolver> GetAsync(string key)
         /// <inheritdoc/>
         public async Task SetAsync(string key, Stream stream, ImageCacheMetadata metadata)
         {
-            string path = Path.Combine(this.cacheRootPath, ToFilePath(key, this.cachedNameLength));
+            string path = Path.Combine(this.cacheRootPath, ToFilePath(key, this.cacheFolderDepth));
             string imagePath = this.ToImageFilePath(path, metadata);
             string metaPath = this.ToMetaDataFilePath(path);
             string directory = Path.GetDirectoryName(path);
 
-            if (!Directory.Exists(directory))
-            {
-                Directory.CreateDirectory(directory);
-            }
+            // Ensure cache directory is created before creating files
+            Directory.CreateDirectory(directory);
 
             using (FileStream fileStream = File.Create(imagePath))
             {
@@ -162,13 +145,35 @@ private string ToImageFilePath(string path, in ImageCacheMetadata metaData)
         /// Converts the key into a nested file path.
         /// </summary>
         /// <param name="key">The cache key.</param>
-        /// <param name="cachedNameLength">The length of the cached file name minus the extension.</param>
-        /// <returns>The <see cref="string"/>.</returns>
+        /// <param name="cacheFolderDepth">The depth of the nested cache folders structure to store the images.</param>
+        /// <returns>
+        /// The <see cref="string" />.
+        /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe string ToFilePath(string key, int cachedNameLength)
+        internal static unsafe string ToFilePath(string key, int cacheFolderDepth)
         {
-            // Each key substring char + separator + key
-            int length = (cachedNameLength * 2) + key.Length;
+            if (cacheFolderDepth == 0)
+            {
+                // Short-circuit when not nesting folders
+                return key;
+            }
+
+            int length;
+            int nameStartIndex;
+            if (cacheFolderDepth >= key.Length)
+            {
+                // Keep all characters in file name (legacy behavior)
+                cacheFolderDepth = key.Length;
+                length = (cacheFolderDepth * 2) + key.Length;
+                nameStartIndex = 0;
+            }
+            else
+            {
+                // Remove characters used in folders from file name
+                length = cacheFolderDepth + key.Length;
+                nameStartIndex = cacheFolderDepth;
+            }
+
             fixed (char* keyPtr = key)
             {
                 return string.Create(length, (Ptr: (IntPtr)keyPtr, key.Length), (chars, args) =>
@@ -179,13 +184,13 @@ internal static unsafe string ToFilePath(string key, int cachedNameLength)
                     ref char charRef = ref MemoryMarshal.GetReference(chars);
 
                     int index = 0;
-                    for (int i = 0; i < cachedNameLength; i++)
+                    for (int i = 0; i < cacheFolderDepth; i++)
                     {
                         Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
                         Unsafe.Add(ref charRef, index++) = separator;
                     }
 
-                    for (int i = 0; i < keySpan.Length; i++)
+                    for (int i = nameStartIndex; i < keySpan.Length; i++)
                     {
                         Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
                     }

src/ImageSharp.Web/Caching/PhysicalFileSystemCacheOptions.cs

@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Web.Caching
 {
     /// <summary>
-    /// Configuration options for the <see cref="PhysicalFileSystemCache"/>.
+    /// Configuration options for the <see cref="PhysicalFileSystemCache" />.
     /// </summary>
     public class PhysicalFileSystemCacheOptions
     {
@@ -13,6 +13,11 @@ public class PhysicalFileSystemCacheOptions
         /// </summary>
         public string CacheFolder { get; set; } = "is-cache";
 
+        /// <summary>
+        /// Gets or sets the depth of the nested cache folders structure to store the images. Defaults to 8.
+        /// </summary>
+        public uint CacheFolderDepth { get; set; } = 8;
+
         /// <summary>
         /// Gets or sets the optional cache root folder.
         /// <para>

src/ImageSharp.Web/Caching/CacheHash.cs …mageSharp.Web/Caching/SHA256CacheHash.cssrc/ImageSharp.Web/Caching/CacheHash.cs renamed to src/ImageSharp.Web/Caching/SHA256CacheHash.cs src/ImageSharp.Web/Caching/CacheHash.cs renamed to src/ImageSharp.Web/Caching/SHA256CacheHash.cs

@@ -16,16 +16,16 @@ namespace SixLabors.ImageSharp.Web.Caching
     /// Hashed keys are the result of the SHA256 computation of the input value for the given length.
     /// This ensures low collision rates with a shorter file name.
     /// </summary>
-    public sealed class CacheHash : ICacheHash
+    public sealed class SHA256CacheHash : ICacheHash
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="CacheHash"/> class.
+        /// Initializes a new instance of the <see cref="SHA256CacheHash"/> class.
         /// </summary>
         /// <param name="options">The middleware configuration options.</param>
-        public CacheHash(IOptions<ImageSharpMiddlewareOptions> options)
+        public SHA256CacheHash(IOptions<ImageSharpMiddlewareOptions> options)
         {
             Guard.NotNull(options, nameof(options));
-            Guard.MustBeBetweenOrEqualTo<uint>(options.Value.CachedNameLength, 2, 64, nameof(options.Value.CachedNameLength));
+            Guard.MustBeBetweenOrEqualTo<uint>(options.Value.CacheHashLength, 2, 64, nameof(options.Value.CacheHashLength));
         }
 
         /// <inheritdoc/>
@@ -34,8 +34,7 @@ public string Create(string value, uint length)
         {
             int byteCount = Encoding.ASCII.GetByteCount(value);
 
-            // Allocating a buffer from the pool is ~27% slower than stackalloc so use
-            // that for short strings
+            // Allocating a buffer from the pool is ~27% slower than stackalloc so use that for short strings
             if (byteCount < 257)
             {
                 return HashValue(value, length, stackalloc byte[byteCount]);
@@ -62,11 +61,11 @@ private static string HashValue(ReadOnlySpan<char> value, uint length, Span<byte
             using var hashAlgorithm = SHA256.Create();
             Encoding.ASCII.GetBytes(value, bufferSpan);
 
-            // Hashed output maxes out at 32 bytes @ 256bit/8 so we're safe to use stackalloc.
+            // Hashed output maxes out at 32 bytes @ 256bit/8 so we're safe to use stackalloc
             Span<byte> hash = stackalloc byte[32];
             hashAlgorithm.TryComputeHash(bufferSpan, hash, out int _);
 
-            // length maxes out at 64 since we throw if options is greater.
+            // Length maxes out at 64 since we throw if options is greater
             return HexEncoder.Encode(hash.Slice(0, (int)(length / 2)));
         }
     }

src/ImageSharp.Web/DependencyInjection/ServiceCollectionExtensions.cs

@@ -66,7 +66,7 @@ private static void AddDefaultServices(
 
             builder.SetCacheKey<UriRelativeLowerInvariantCacheKey>();
 
-            builder.SetCacheHash<CacheHash>();
+            builder.SetCacheHash<SHA256CacheHash>();
 
             builder.AddProvider<PhysicalFileSystemProvider>();
 

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -271,7 +271,7 @@ private async Task ProcessRequestAsync(
             // Create a hashed cache key
             string key = this.cacheHash.Create(
                 this.cacheKey.Create(context, commands),
-                this.options.CachedNameLength);
+                this.options.CacheHashLength);
 
             // Check the cache, if present, not out of date and not requiring an update
             // we'll simply serve the file from there.

src/ImageSharp.Web/Middleware/ImageSharpMiddlewareOptions.cs

@@ -88,7 +88,7 @@ public class ImageSharpMiddlewareOptions
         /// Gets or sets the length of the filename to use (minus the extension) when storing
         /// images in the image cache. Defaults to 12 characters.
         /// </summary>
-        public uint CachedNameLength { get; set; } = 12;
+        public uint CacheHashLength { get; set; } = 12;
 
         /// <summary>
         /// Gets or sets the additional command parsing method that can be used to used to augment commands.

tests/ImageSharp.Web.Benchmarks/Caching/CacheHashBenchmarks.cs

@@ -13,7 +13,7 @@ public class CacheHashBenchmarks
     {
         private const string URL = "http://testwebsite.com/image-12345.jpeg?width=400";
         private static readonly IOptions<ImageSharpMiddlewareOptions> MWOptions = Options.Create(new ImageSharpMiddlewareOptions());
-        private static readonly CacheHash Sha256Hasher = new CacheHash(MWOptions);
+        private static readonly SHA256CacheHash Sha256Hasher = new SHA256CacheHash(MWOptions);
         private static readonly CacheHashBaseline NaiveSha256Hasher = new CacheHashBaseline();
 
         [Benchmark(Baseline = true, Description = "Baseline Sha256Hasher")]

tests/ImageSharp.Web.Benchmarks/Caching/StringJoinBenchmarks.cs

@@ -12,11 +12,13 @@ namespace SixLabors.ImageSharp.Web.Benchmarks.Caching
     public class StringJoinBenchmarks
     {
         private const string Key = "abcdefghijkl";
-        private const int CachedNameLength = 12;
+
+        [Params(0, 8, 12)]
+        public int CacheFolderDepth { get; set; }
 
         [Benchmark(Baseline = true, Description = "String.Join")]
         public string JoinUsingString()
-            => $"{string.Join("/", Key.Substring(0, CachedNameLength).ToCharArray())}/{Key}";
+            => $"{string.Join("/", Key.Substring(0, this.CacheFolderDepth).ToCharArray())}/{Key}";
 
         [Benchmark(Description = "StringBuilder.Append")]
         public string JoinUsingStringBuilder()
@@ -25,8 +27,8 @@ public string JoinUsingStringBuilder()
             const char separator = '/';
 
             // Each key substring char + separator + key
-            var sb = new StringBuilder((CachedNameLength * 2) + Key.Length);
-            ReadOnlySpan<char> paths = keySpan.Slice(0, CachedNameLength);
+            var sb = new StringBuilder((this.CacheFolderDepth * 2) + Key.Length);
+            ReadOnlySpan<char> paths = keySpan.Slice(0, this.CacheFolderDepth);
             for (int i = 0; i < paths.Length; i++)
             {
                 sb.Append(paths[i]);
@@ -39,7 +41,7 @@ public string JoinUsingStringBuilder()
 
         [Benchmark(Description = "String.Create")]
         public string JoinUsingStringCreate()
-            => PhysicalFileSystemCache.ToFilePath(Key, CachedNameLength);
+            => PhysicalFileSystemCache.ToFilePath(Key, this.CacheFolderDepth);
 
         /*
         BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363

tests/ImageSharp.Web.Tests/Caching/CacheHashTests.cs

@@ -13,7 +13,7 @@ namespace SixLabors.ImageSharp.Web.Tests.Caching
     public class CacheHashTests
     {
         private static readonly IOptions<ImageSharpMiddlewareOptions> Options = MSOptions.Create(new ImageSharpMiddlewareOptions());
-        private static readonly ICacheHash CacheHash = new CacheHash(Options);
+        private static readonly ICacheHash CacheHash = new SHA256CacheHash(Options);
 
         [Fact]
         public void CacheHashProducesIdenticalResults()