Use image last updated time in cache key

[yringler]

We have a bunch of servers, all of which use the same filesystem for images.
If an image is updated, the name often stays the same, and we get an error when ImageSharp tries to update the cached image.

Exception: 
System.IO.IOException: The process cannot access the file '\\webfiles\images1\8\3\b\7\8\4\1\3\d\1\2\f\83b78413d12f.jpg' because it is being used by another process.
at System.IO.FileStream.ValidateFileHandle(SafeFileHandle fileHandle)
at System.IO.FileStream.CreateFileOpenHandle(FileMode mode, FileShare share, FileOptions options)
at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)
at SixLabors.ImageSharp.Web.Caching.PhysicalFileSystemCache.SetAsync(String key, Stream stream, ImageCacheMetadata metadata)

Because the cache key is based only on the URL, the write is happening when another server is reading, causing the exception.
The tricky thing here is that the key is built before we load the source image metadata (which only happens at

ImageSharp.Web/src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

Line 403 in d055952

ImageMetadata sourceImageMetadata = await

), so we don't know yet last update time etc, to be able to build a key from that.

Assuming that the metadata load has to happen there, and not earlier (IDK if that's the case), I think the only option here is to allow user to set a method CacheKeySourceModifier which would take the current URI which was used to create the first key and the ImageMetadata sourceImageMetadata, and return a URI, which would in turn be hashed into a key. The default implementation can be a NOOP which just returns the original URI.

This would mean that there are (if the user decides to implement CacheKeySourceModifier as such) now two keys: the source file key, and the cache file key.

That new URI returned by the CacheKeySourceModifier would be hashed and used as the key to access the cache - for example, when calling methods on CacheResolverLru and

ImageSharp.Web/src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

Line 335 in d055952

await this.cache.SetAsync(key, outStream, cachedImageMetadata);

Alternatively, instead of keeping track of a source key and modifying it when we need a cache key, we could
add a class, and the ability to use a user derived version instead of the default via a factory set as an option (maybe on ImageSharpMiddlewareOptions).

        /// <summary>
        /// Contains the key used to identify the source image and cached image.
        /// </summary>
        public class ImageKeyCollection
        {
            protected uint Length { get; }

            /// <summary>
            /// The data that the (hashed) key is based on.
            /// </summary>
            protected string KeySource { get; }

            protected ICacheHash CacheHash { get; }

            /// <summary>
            /// A key which identifies the source image.
            /// </summary>
            public string ImageSourceKey { get; }

            /// <summary>
            /// A key which identifies the cached image.
            /// By default, same as source key.
            /// It is an error to call this method before <see cref="SourceImageMetadata"/>
            /// </summary>
            public virtual string ImageCacheKey => this.ImageSourceKey;

            public ImageMetadata? SourceImageMetadata { get; set; }

            public ImageKeyCollection(string keySource, ICacheHash cacheHash, uint length)
            {
                this.KeySource = keySource;
                this.ImageSourceKey = this.CacheHash.Create(this.KeySource, length);
                this.CacheHash = cacheHash;
                this.Length = length;
            }
        }

        public class VaryByModifiedDateImageKeyCollection : ImageKeyCollection
        {
            private string _imageCacheKey;

            public VaryByModifiedDateImageKeyCollection(string uri, ICacheHash cacheHash, uint length) : base(uri, cacheHash, length)
            {
            }

            public override string ImageCacheKey
            {
                get
                {
                    if (this._imageCacheKey != null)
                    {
                        return this._imageCacheKey;
                    }

                    if (!this.SourceImageMetadata.HasValue)
                    {
                        ThrowHelper.ThrowArgumentNullExceptionForNotNull(nameof(this.SourceImageMetadata));
                    }

                    this._imageCacheKey = this.CacheHash.Create($"{this.KeySource}{this.SourceImageMetadata.Value.LastWriteTimeUtc.Ticks}", this.Length);

                    return this._imageCacheKey;
                }
            }
        }

@JimBobSquarePants, what do you say?

[JimBobSquarePants]

I'm afraid I don't believe this is a viable solution. You shouldn't be sharing a filesystem across multiple independent servers in that manner. You should be using a cache that handles concurrency like Azure Blob Storage

[yringler]

Thank you for your advice. I'll take a look at Azure Blob Storage, and see if we can start using that for our image cache, and see if the powers that be are willing to move in that direction.
Truth is, we're using a CDN anyway - maybe we shouldn't be caching at all? The only requests to our servers should be coming from the CDN. IDK, I'll think about it.

[JimBobSquarePants]

You can tell an Azure CDN to use a web application instance as a backing store. That would allow using the file system since only one application instance is ever using it.

All requests can point to the CDN which delegates the request if no result is found to your actual app.