Merge pull request #225 from ronaldbarendse/feature/remove-fileprovider-abstraction

Replace PhysicalFileProvider with File in PhysicalFileSystemCache and PhysicalFileSystemProvider

Author: JimBobSquarePants

samples/ImageSharp.Web.Sample/Startup.cs

@@ -8,7 +8,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Options;
 using SixLabors.ImageSharp.Web.Caching;
 using SixLabors.ImageSharp.Web.Commands;
 using SixLabors.ImageSharp.Web.DependencyInjection;
@@ -43,17 +42,17 @@ public void ConfigureServices(IServiceCollection services)
                 .SetRequestParser<QueryCollectionRequestParser>()
                 .Configure<PhysicalFileSystemCacheOptions>(options =>
                 {
+                    options.CacheRootPath = null;
                     options.CacheFolder = "is-cache";
+                    options.CacheFolderDepth = 8;
                 })
-                .SetCache(provider =>
-                {
-                    return new PhysicalFileSystemCache(
-                                provider.GetRequiredService<IOptions<PhysicalFileSystemCacheOptions>>(),
-                                provider.GetRequiredService<IWebHostEnvironment>(),
-                                provider.GetRequiredService<FormatUtilities>());
-                })
+                .SetCache<PhysicalFileSystemCache>()
                 .SetCacheKey<UriRelativeLowerInvariantCacheKey>()
                 .SetCacheHash<SHA256CacheHash>()
+                .Configure<PhysicalFileSystemProviderOptions>(options =>
+                {
+                    options.ProviderRootPath = null;
+                })
                 .AddProvider<PhysicalFileSystemProvider>()
                 .AddProcessor<ResizeWebProcessor>()
                 .AddProcessor<FormatWebProcessor>()
@@ -80,18 +79,17 @@ public void ConfigureServices(IServiceCollection services)
 
         private void ConfigureDefaultServicesAndCustomOptions(IServiceCollection services)
         {
-            services.AddImageSharp(
-                options =>
-                    {
-                        options.Configuration = Configuration.Default;
-                        options.BrowserMaxAge = TimeSpan.FromDays(7);
-                        options.CacheMaxAge = TimeSpan.FromDays(365);
-                        options.CacheHashLength = 8;
-                        options.OnParseCommandsAsync = _ => Task.CompletedTask;
-                        options.OnBeforeSaveAsync = _ => Task.CompletedTask;
-                        options.OnProcessedAsync = _ => Task.CompletedTask;
-                        options.OnPrepareResponseAsync = _ => Task.CompletedTask;
-                    });
+            services.AddImageSharp(options =>
+            {
+                options.Configuration = Configuration.Default;
+                options.BrowserMaxAge = TimeSpan.FromDays(7);
+                options.CacheMaxAge = TimeSpan.FromDays(365);
+                options.CacheHashLength = 8;
+                options.OnParseCommandsAsync = _ => Task.CompletedTask;
+                options.OnBeforeSaveAsync = _ => Task.CompletedTask;
+                options.OnProcessedAsync = _ => Task.CompletedTask;
+                options.OnPrepareResponseAsync = _ => Task.CompletedTask;
+            });
         }
 
         private void ConfigureCustomServicesAndDefaultOptions(IServiceCollection services)
@@ -103,30 +101,23 @@ private void ConfigureCustomServicesAndDefaultOptions(IServiceCollection service
 
         private void ConfigureCustomServicesAndCustomOptions(IServiceCollection services)
         {
-            services.AddImageSharp(
-                options =>
-                    {
-                        options.Configuration = Configuration.Default;
-                        options.BrowserMaxAge = TimeSpan.FromDays(7);
-                        options.CacheMaxAge = TimeSpan.FromDays(365);
-                        options.CacheHashLength = 8;
-                        options.OnParseCommandsAsync = _ => Task.CompletedTask;
-                        options.OnBeforeSaveAsync = _ => Task.CompletedTask;
-                        options.OnProcessedAsync = _ => Task.CompletedTask;
-                        options.OnPrepareResponseAsync = _ => Task.CompletedTask;
-                    })
+            services.AddImageSharp(options =>
+            {
+                options.Configuration = Configuration.Default;
+                options.BrowserMaxAge = TimeSpan.FromDays(7);
+                options.CacheMaxAge = TimeSpan.FromDays(365);
+                options.CacheHashLength = 8;
+                options.OnParseCommandsAsync = _ => Task.CompletedTask;
+                options.OnBeforeSaveAsync = _ => Task.CompletedTask;
+                options.OnProcessedAsync = _ => Task.CompletedTask;
+                options.OnPrepareResponseAsync = _ => Task.CompletedTask;
+            })
                 .SetRequestParser<QueryCollectionRequestParser>()
                 .Configure<PhysicalFileSystemCacheOptions>(options =>
                 {
                     options.CacheFolder = "different-cache";
                 })
-                .SetCache(provider =>
-                {
-                    return new PhysicalFileSystemCache(
-                        provider.GetRequiredService<IOptions<PhysicalFileSystemCacheOptions>>(),
-                        provider.GetRequiredService<IWebHostEnvironment>(),
-                        provider.GetRequiredService<FormatUtilities>());
-                })
+                .SetCache<PhysicalFileSystemCache>()
                 .SetCacheKey<UriRelativeLowerInvariantCacheKey>()
                 .SetCacheHash<SHA256CacheHash>()
                 .ClearProviders()

src/Directory.Build.targets

@@ -35,6 +35,5 @@
     <PackageReference Update="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
     <PackageReference Update="Microsoft.Extensions.Caching.Abstractions" Version="2.2.0" />
     <PackageReference Update="Microsoft.Extensions.Options.ConfigurationExtensions" Version="2.2.0" />
-    <PackageReference Update="Microsoft.Extensions.FileProviders.Physical" Version="2.2.0"/>
   </ItemGroup>
 </Project>

src/ImageSharp.Web/Caching/PhysicalFileSystemCache.cs

@@ -7,7 +7,6 @@
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Options;
 using SixLabors.ImageSharp.Web.Resolvers;
 
@@ -28,11 +27,6 @@ public class PhysicalFileSystemCache : IImageCache
         /// </summary>
         private readonly int cacheFolderDepth;
 
-        /// <summary>
-        /// The file provider abstraction.
-        /// </summary>
-        private readonly IFileProvider fileProvider;
-
         /// <summary>
         /// Contains various format helper methods based on the current configuration.
         /// </summary>
@@ -53,19 +47,11 @@ public PhysicalFileSystemCache(
 #endif
             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
-            PhysicalFileSystemCacheOptions cacheOptions = options != null ? options.Value : new();
-            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);
+            Guard.NotNull(environment, nameof(environment));
 
-            this.fileProvider = new PhysicalFileProvider(this.cacheRootPath);
+            this.cacheRootPath = GetCacheRoot(options.Value, environment.WebRootPath, environment.ContentRootPath);
+            this.cacheFolderDepth = (int)options.Value.CacheFolderDepth;
             this.formatUtilities = formatUtilities;
         }
 
@@ -78,21 +64,29 @@ public PhysicalFileSystemCache(
         /// <returns><see cref="string"/> representing the fully qualified cache root path.</returns>
         internal static string GetCacheRoot(PhysicalFileSystemCacheOptions cacheOptions, string webRootPath, string contentRootPath)
         {
-            string cacheRoot = string.IsNullOrWhiteSpace(cacheOptions.CacheRootPath)
-                ? webRootPath
-                : cacheOptions.CacheRootPath;
+            string cacheRootPath = cacheOptions.CacheRootPath ?? webRootPath;
+            if (string.IsNullOrEmpty(cacheRootPath))
+            {
+                throw new InvalidOperationException("The cache root path can't be determined, make sure it's explicitly configured or the webroot is set.");
+            }
+
+            if (!Path.IsPathFullyQualified(cacheRootPath))
+            {
+                // Ensure this is an absolute path (resolved to the content root path)
+                cacheRootPath = Path.GetFullPath(cacheRootPath, contentRootPath);
+            }
 
-            return Path.IsPathFullyQualified(cacheRoot)
-                ? Path.Combine(cacheRoot, cacheOptions.CacheFolder)
-                : Path.GetFullPath(Path.Combine(cacheRoot, cacheOptions.CacheFolder), contentRootPath);
+            string cacheFolderPath = Path.Combine(cacheRootPath, cacheOptions.CacheFolder);
+
+            return PathUtils.EnsureTrailingSlash(cacheFolderPath);
         }
 
         /// <inheritdoc/>
         public Task<IImageCacheResolver> GetAsync(string key)
         {
             string path = ToFilePath(key, this.cacheFolderDepth);
 
-            IFileInfo metaFileInfo = this.fileProvider.GetFileInfo(this.ToMetaDataFilePath(path));
+            var metaFileInfo = new FileInfo(this.ToMetaDataFilePath(path));
             if (!metaFileInfo.Exists)
             {
                 return Task.FromResult<IImageCacheResolver>(null);
@@ -110,7 +104,10 @@ public async Task SetAsync(string key, Stream stream, ImageCacheMetadata metadat
             string directory = Path.GetDirectoryName(path);
 
             // Ensure cache directory is created before creating files
-            Directory.CreateDirectory(directory);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
 
             using (FileStream fileStream = File.Create(imagePath))
             {

src/ImageSharp.Web/Caching/PhysicalFileSystemCacheOptions.cs

@@ -8,16 +8,6 @@ namespace SixLabors.ImageSharp.Web.Caching
     /// </summary>
     public class PhysicalFileSystemCacheOptions
     {
-        /// <summary>
-        /// Gets or sets the cache folder name.
-        /// </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 path.
         /// <para>
@@ -31,5 +21,15 @@ public class PhysicalFileSystemCacheOptions
         /// </para>
         /// </summary>
         public string CacheRootPath { get; set; }
+
+        /// <summary>
+        /// Gets or sets the cache folder name.
+        /// </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;
     }
 }

src/ImageSharp.Web/ImageSharp.Web.csproj

@@ -32,7 +32,6 @@
     <PackageReference Include="Microsoft.AspNetCore.WebUtilities" />
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
-    <PackageReference Include="Microsoft.Extensions.FileProviders.Physical" />
   </ItemGroup>
 
   <ItemGroup>

src/ImageSharp.Web/PathUtils.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.IO;
+
+namespace SixLabors.ImageSharp.Web
+{
+    internal static class PathUtils
+    {
+        /// <summary>
+        /// Ensures the path ends with a trailing slash (directory separator).
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>
+        /// The path with a trailing slash.
+        /// </returns>
+        internal static string EnsureTrailingSlash(string path)
+        {
+            if (!string.IsNullOrEmpty(path) &&
+                path[path.Length - 1] != Path.DirectorySeparatorChar)
+            {
+                return path + Path.DirectorySeparatorChar;
+            }
+
+            return path;
+        }
+
+        /// <summary>
+        /// Determines whether the <paramref name="path" /> is located underneath the specified <paramref name="rootPath" />.
+        /// </summary>
+        /// <param name="path">The fully qualified path to test.</param>
+        /// <param name="rootPath">The root path (needs to end with a directory separator).</param>
+        /// <returns>
+        ///   <c>true</c> if the path is located underneath the specified root path; otherwise, <c>false</c>.
+        /// </returns>
+        internal static bool IsUnderneathRoot(string path, string rootPath)
+            => path.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase);
+    }
+}

src/ImageSharp.Web/Providers/PhysicalFileSystemProvider.cs

@@ -7,7 +7,6 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
-using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Options;
 using SixLabors.ImageSharp.Web.Resolvers;
 
@@ -19,9 +18,9 @@ namespace SixLabors.ImageSharp.Web.Providers
     public class PhysicalFileSystemProvider : IImageProvider
     {
         /// <summary>
-        /// The file provider abstraction.
+        /// The root path for the provider.
         /// </summary>
-        private readonly IFileProvider fileProvider;
+        private readonly string providerRootPath;
 
         /// <summary>
         /// Contains various format helper methods based on the current configuration.
@@ -43,19 +42,10 @@ public PhysicalFileSystemProvider(
 #endif
             FormatUtilities formatUtilities)
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(environment, nameof(environment));
 
-            // ContentRootPath is never null.
-            // https://github.com/dotnet/aspnetcore/blob/b89eba6c3cda331ee98063e3c4a04267ec540315/src/Hosting/Hosting/src/WebHostBuilder.cs#L262
-            Guard.NotNullOrWhiteSpace(environment.WebRootPath, nameof(environment.WebRootPath));
-
-            // Allow configuration of the provider without having to register everything
-            PhysicalFileSystemProviderOptions providerOptions = options != null ? options.Value : new();
-            string providerRootPath = GetProviderRoot(providerOptions, environment.WebRootPath, environment.ContentRootPath);
-
-            // Ensure provider directory is created before initializing the file provider
-            Directory.CreateDirectory(providerRootPath);
-            this.fileProvider = new PhysicalFileProvider(providerRootPath);
+            this.providerRootPath = GetProviderRoot(options.Value, environment.WebRootPath, environment.ContentRootPath);
             this.formatUtilities = formatUtilities;
         }
 
@@ -72,17 +62,20 @@ public bool IsValidRequest(HttpContext context)
         /// <inheritdoc/>
         public Task<IImageResolver> GetAsync(HttpContext context)
         {
-            // Path has already been correctly parsed before here.
-            IFileInfo fileInfo = this.fileProvider.GetFileInfo(context.Request.Path.Value);
-
-            // Check to see if the file exists.
-            if (!fileInfo.Exists)
+            // Use Join because request path starts with a slash
+            string fullPath = Path.GetFullPath(Path.Join(this.providerRootPath, context.Request.Path.Value));
+            if (PathUtils.IsUnderneathRoot(fullPath, this.providerRootPath))
             {
-                return Task.FromResult<IImageResolver>(null);
+                // Check to see if the file exists
+                var fileInfo = new FileInfo(fullPath);
+                if (fileInfo.Exists)
+                {
+                    var metadata = new ImageMetadata(fileInfo.LastWriteTimeUtc, fileInfo.Length);
+                    return Task.FromResult<IImageResolver>(new PhysicalFileSystemResolver(fileInfo, metadata));
+                }
             }
 
-            var metadata = new ImageMetadata(fileInfo.LastModified.UtcDateTime, fileInfo.Length);
-            return Task.FromResult<IImageResolver>(new PhysicalFileSystemResolver(fileInfo, metadata));
+            return Task.FromResult<IImageResolver>(null);
         }
 
         /// <summary>
@@ -94,13 +87,19 @@ public Task<IImageResolver> GetAsync(HttpContext context)
         /// <returns><see cref="string"/> representing the fully qualified provider root path.</returns>
         internal static string GetProviderRoot(PhysicalFileSystemProviderOptions providerOptions, string webRootPath, string contentRootPath)
         {
-            string providerRoot = string.IsNullOrWhiteSpace(providerOptions.ProviderRootPath)
-                ? webRootPath
-                : providerOptions.ProviderRootPath;
+            string providerRootPath = providerOptions.ProviderRootPath ?? webRootPath;
+            if (string.IsNullOrEmpty(providerRootPath))
+            {
+                throw new InvalidOperationException("The provider root path can't be determined, make sure it's explicitly configured or the webroot is set.");
+            }
+
+            if (!Path.IsPathFullyQualified(providerRootPath))
+            {
+                // Ensure this is an absolute path (resolved to the content root path)
+                providerRootPath = Path.GetFullPath(providerRootPath, contentRootPath);
+            }
 
-            return Path.IsPathFullyQualified(providerRoot)
-                ? providerRoot
-                : Path.GetFullPath(providerRoot, contentRootPath);
+            return PathUtils.EnsureTrailingSlash(providerRootPath);
         }
     }
 }