Send response directly from output stream rather than re-reading from the cache

Author: kroymann

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -277,7 +277,7 @@ private async Task ProcessRequestAsync(
 
             if (!readResult.IsNewOrUpdated)
             {
-                await this.SendResponseAsync(imageContext, key, readResult.CacheImageMetadata, readResult.Resolver);
+                await this.SendResponseAsync(imageContext, key, readResult.CacheImageMetadata, readResult.Resolver, null);
                 return;
             }
 
@@ -288,104 +288,92 @@ private async Task ProcessRequestAsync(
             // This reduces the overheads of unnecessary processing.
             ImageWorkerResult writeResult;
 
-            using (await this.asyncKeyLock.WriterLockAsync(key))
+            RecyclableMemoryStream outStream = null;
+            try
             {
-                RecyclableMemoryStream outStream = null;
-                try
+                using (await this.asyncKeyLock.WriterLockAsync(key))
                 {
-                    ImageCacheMetadata cachedImageMetadata = default;
-                    outStream = new RecyclableMemoryStream(this.options.MemoryStreamManager);
-                    IImageFormat format;
-
-                    // 14.9.3 CacheControl Max-Age
-                    // Check to see if the source metadata has a CacheControl Max-Age value
-                    // and use it to override the default max age from our options.
-                    TimeSpan maxAge = this.options.BrowserMaxAge;
-                    if (!sourceImageMetadata.CacheControlMaxAge.Equals(TimeSpan.MinValue))
-                    {
-                        maxAge = sourceImageMetadata.CacheControlMaxAge;
-                    }
-
-                    using (Stream inStream = await sourceImageResolver.OpenReadAsync())
+                    try
                     {
-                        // No commands? We simply copy the stream across.
-                        if (commands.Count == 0)
+                        ImageCacheMetadata cachedImageMetadata = default;
+                        outStream = new RecyclableMemoryStream(this.options.MemoryStreamManager);
+                        IImageFormat format;
+
+                        // 14.9.3 CacheControl Max-Age
+                        // Check to see if the source metadata has a CacheControl Max-Age value
+                        // and use it to override the default max age from our options.
+                        TimeSpan maxAge = this.options.BrowserMaxAge;
+                        if (!sourceImageMetadata.CacheControlMaxAge.Equals(TimeSpan.MinValue))
                         {
-                            await inStream.CopyToAsync(outStream);
-                            outStream.Position = 0;
-                            format = await Image.DetectFormatAsync(this.options.Configuration, outStream);
+                            maxAge = sourceImageMetadata.CacheControlMaxAge;
                         }
-                        else
+
+                        using (Stream inStream = await sourceImageResolver.OpenReadAsync())
                         {
-                            using var image = FormattedImage.Load(this.options.Configuration, inStream);
+                            // No commands? We simply copy the stream across.
+                            if (commands.Count == 0)
+                            {
+                                await inStream.CopyToAsync(outStream);
+                                outStream.Position = 0;
+                                format = await Image.DetectFormatAsync(this.options.Configuration, outStream);
+                            }
+                            else
+                            {
+                                using var image = FormattedImage.Load(this.options.Configuration, inStream);
 
-                            image.Process(
-                                this.logger,
-                                this.processors,
-                                commands,
-                                this.commandParser,
-                                this.parserCulture);
+                                image.Process(
+                                    this.logger,
+                                    this.processors,
+                                    commands,
+                                    this.commandParser,
+                                    this.parserCulture);
 
-                            await this.options.OnBeforeSaveAsync.Invoke(image);
+                                await this.options.OnBeforeSaveAsync.Invoke(image);
 
-                            image.Save(outStream);
-                            format = image.Format;
+                                image.Save(outStream);
+                                format = image.Format;
+                            }
                         }
-                    }
-
-                    // Allow for any further optimization of the image.
-                    outStream.Position = 0;
-                    string contentType = format.DefaultMimeType;
-                    string extension = this.formatUtilities.GetExtensionFromContentType(contentType);
-                    await this.options.OnProcessedAsync.Invoke(new ImageProcessingContext(context, outStream, commands, contentType, extension));
-                    outStream.Position = 0;
-
-                    cachedImageMetadata = new ImageCacheMetadata(
-                        sourceImageMetadata.LastWriteTimeUtc,
-                        DateTime.UtcNow,
-                        contentType,
-                        maxAge,
-                        outStream.Length);
-
-                    // Save the image to the cache and send the response to the caller.
-                    await this.cache.SetAsync(key, outStream, cachedImageMetadata);
-
-                    // Remove any resolver from the cache so we always resolve next request
-                    // for the same key.
-                    CacheResolverLru.TryRemove(key);
-
-                    // Place the resolver in the lru cache.
-                    (IImageCacheResolver ImageCacheResolver, ImageCacheMetadata ImageCacheMetadata) cachedImage = await
-                        CacheResolverLru.GetOrAddAsync(
-                            key,
-                            async k =>
-                            {
-                                IImageCacheResolver resolver = await this.cache.GetAsync(k);
-                                ImageCacheMetadata metadata = default;
-                                if (resolver != null)
-                                {
-                                    metadata = await resolver.GetMetaDataAsync();
-                                }
-
-                                return (resolver, metadata);
-                            });
 
-                    writeResult = new ImageWorkerResult(cachedImage.ImageCacheMetadata, cachedImage.ImageCacheResolver);
-                }
-                catch (Exception ex)
-                {
-                    // Log the error internally then rethrow.
-                    // We don't call next here, the pipeline will automatically handle it
-                    this.logger.LogImageProcessingFailed(imageContext.GetDisplayUrl(), ex);
-                    throw;
-                }
-                finally
-                {
-                    await this.StreamDisposeAsync(outStream);
+                        // Allow for any further optimization of the image.
+                        outStream.Position = 0;
+                        string contentType = format.DefaultMimeType;
+                        string extension = this.formatUtilities.GetExtensionFromContentType(contentType);
+                        await this.options.OnProcessedAsync.Invoke(new ImageProcessingContext(context, outStream, commands, contentType, extension));
+                        outStream.Position = 0;
+
+                        cachedImageMetadata = new ImageCacheMetadata(
+                            sourceImageMetadata.LastWriteTimeUtc,
+                            DateTime.UtcNow,
+                            contentType,
+                            maxAge,
+                            outStream.Length);
+
+                        // Save the image to the cache and send the response to the caller.
+                        await this.cache.SetAsync(key, outStream, cachedImageMetadata);
+                        outStream.Position = 0;
+
+                        // Remove any resolver from the cache so we always resolve next request
+                        // for the same key.
+                        CacheResolverLru.TryRemove(key);
+
+                        writeResult = new ImageWorkerResult(cachedImageMetadata, null);
+                    }
+                    catch (Exception ex)
+                    {
+                        // Log the error internally then rethrow.
+                        // We don't call next here, the pipeline will automatically handle it
+                        this.logger.LogImageProcessingFailed(imageContext.GetDisplayUrl(), ex);
+                        throw;
+                    }
                 }
-            }
 
-            await this.SendResponseAsync(imageContext, key, writeResult.CacheImageMetadata, writeResult.Resolver);
+                await this.SendResponseAsync(imageContext, key, writeResult.CacheImageMetadata, writeResult.Resolver, outStream);
+            }
+            finally
+            {
+                await this.StreamDisposeAsync(outStream);
+            }
         }
 
         private ValueTask StreamDisposeAsync(Stream stream)
@@ -411,8 +399,8 @@ private ValueTask StreamDisposeAsync(Stream stream)
         }
 
         private async Task<ImageWorkerResult> IsNewOrUpdatedAsync(
-            IImageResolver sourceImageResolver,
-            string key)
+                    IImageResolver sourceImageResolver,
+                    string key)
         {
             // Get the source metadata for processing, storing the result for future checks.
             ImageMetadata sourceImageMetadata = await
@@ -464,7 +452,8 @@ private async Task SendResponseAsync(
             ImageContext imageContext,
             string key,
             ImageCacheMetadata metadata,
-            IImageCacheResolver cacheResolver)
+            IImageCacheResolver cacheResolver,
+            Stream stream)
         {
             imageContext.ComprehendRequestHeaders(metadata.CacheLastWriteTimeUtc, metadata.ContentLength);
 
@@ -480,11 +469,19 @@ private async Task SendResponseAsync(
 
                     this.logger.LogImageServed(imageContext.GetDisplayUrl(), key);
 
-                    // When stream is null we're sending from the cache.
-                    using (Stream stream = await cacheResolver.OpenReadAsync())
+                    // If stream is not null, then send it directly. Otherwise, use the cacheResolver
+                    // to load from the cache.
+                    if (stream != null)
                     {
                         await imageContext.SendAsync(stream, metadata);
                     }
+                    else
+                    {
+                        using (Stream cacheStream = await cacheResolver.OpenReadAsync())
+                        {
+                            await imageContext.SendAsync(cacheStream, metadata);
+                        }
+                    }
 
                     return;