Add shim for IHttpSendFileFeature

Author: JunTaoLuo

src/Microsoft.AspNetCore.ResponseCaching/Internal/DefaultResponseCacheEntrySerializer.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Globalization;
 using System.IO;
 using Microsoft.AspNetCore.Http;
 

src/Microsoft.AspNetCore.ResponseCaching/Internal/SendFileFeatureWrapper.cs

@@ -0,0 +1,28 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http.Features;
+
+namespace Microsoft.AspNetCore.ResponseCaching.Internal
+{
+    internal class SendFileFeatureWrapper : IHttpSendFileFeature
+    {
+        private readonly IHttpSendFileFeature _originalSendFileFeature;
+        private readonly ResponseCacheStream _responseCacheStream;
+
+        public SendFileFeatureWrapper(IHttpSendFileFeature originalSendFileFeature, ResponseCacheStream responseCacheStream)
+        {
+            _originalSendFileFeature = originalSendFileFeature;
+            _responseCacheStream = responseCacheStream;
+        }
+
+        // Flush and disable the buffer if anyone tries to call the SendFile feature.
+        public async Task SendFileAsync(string path, long offset, long? length, CancellationToken cancellation)
+        {
+            _responseCacheStream.DisableBuffering();
+            await _originalSendFileFeature.SendFileAsync(path, offset, length, cancellation);
+        }
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingContext.cs

@@ -34,6 +34,7 @@ public ResponseCachingContext(HttpContext httpContext, IResponseCache cache)
         {
         }
 
+        // Internal for testing
         internal ResponseCachingContext(HttpContext httpContext, IResponseCache cache, ISystemClock clock)
         {
             if (cache == null)
@@ -81,6 +82,8 @@ internal bool CacheResponse
 
         private ResponseCacheStream ResponseCacheStream { get; set; }
 
+        private IHttpSendFileFeature OriginalSendFileFeature { get; set; }
+
         private RequestHeaders RequestHeaders
         {
             get
@@ -261,12 +264,6 @@ internal bool ResponseIsCacheable()
                 return false;
             }
 
-            // Do not cache responses that may bypass the response body
-            if (HttpContext.Features.Get<IHttpSendFileFeature>() != null)
-            {
-                return false;
-            }
-
             // TODO: public MAY override the cacheability checks for private and status codes
 
             // Check private
@@ -489,14 +486,27 @@ internal void OnResponseStarting()
         internal void HookResponseStream()
         {
             // TODO: Consider caching large responses on disk and serving them from there.
+
+            // Shim response stream
             OriginalResponseStream = HttpContext.Response.Body;
             ResponseCacheStream = new ResponseCacheStream(OriginalResponseStream);
             HttpContext.Response.Body = ResponseCacheStream;
+
+            // Shim IHttpSendFileFeature
+            OriginalSendFileFeature = HttpContext.Features.Get<IHttpSendFileFeature>();
+            if (OriginalSendFileFeature != null)
+            {
+                HttpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(OriginalSendFileFeature, ResponseCacheStream));
+            }
         }
 
         internal void UnhookResponseStream()
         {
+            // Unshim response stream
             HttpContext.Response.Body = OriginalResponseStream;
+
+            // Unshim IHttpSendFileFeature
+            HttpContext.Features.Set(OriginalSendFileFeature);
         }
 
         private enum ResponseType

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingMiddleware.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 
 namespace Microsoft.AspNetCore.ResponseCaching
 {
@@ -67,6 +68,7 @@ public async Task Invoke(HttpContext context)
                 finally
                 {
                     cachingContext.UnhookResponseStream();
+
                 }
             }
             else

test/Microsoft.AspNetCore.ResponseCaching.Tests/ResponseCachingContextTests.cs

@@ -189,20 +189,6 @@ public void ResponseIsCacheable_VaryByStar_NotAllowed()
             Assert.False(context.ResponseIsCacheable());
         }
 
-        [Fact]
-        public void ResponseIsCacheable_IHttpSendFileFeature_NotAllowed()
-        {
-            var httpContext = new DefaultHttpContext();
-            httpContext.Response.GetTypedHeaders().CacheControl = new CacheControlHeaderValue()
-            {
-                Public = true
-            };
-            httpContext.Features.Set<IHttpSendFileFeature>(new TestHttpSendFileFeature());
-            var context = new ResponseCachingContext(httpContext, new TestResponseCache());
-
-            Assert.False(context.ResponseIsCacheable());
-        }
-
         [Fact]
         public void ResponseIsCacheable_Private_NotAllowed()
         {

test/Microsoft.AspNetCore.ResponseCaching.Tests/ResponseCachingTests.cs

@@ -2,9 +2,12 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Net.Http.Headers;
@@ -259,7 +262,51 @@ public async void ServesCachedContentWithoutSetCookie()
             }
         }
 
-        private static IWebHostBuilder CreateBuilderWithResponseCaching(RequestDelegate requestDelegate)
+        [Fact]
+        public async void ServesFreshContentIfIHttpSendFileFeatureUsed()
+        {
+            var builder = CreateBuilderWithResponseCaching(
+                app =>
+                {
+                    app.Use(async (context, next) =>
+                    {
+                        context.Features.Set<IHttpSendFileFeature>(new DummySendFileFeature());
+                        await next.Invoke();
+                    });
+                },
+                async (context) =>
+                {
+                    var uniqueId = Guid.NewGuid().ToString();
+                    var headers = context.Response.GetTypedHeaders();
+                    headers.CacheControl = new CacheControlHeaderValue()
+                    {
+                        Public = true,
+                        MaxAge = TimeSpan.FromSeconds(10)
+                    };
+                    headers.Date = DateTimeOffset.UtcNow;
+                    headers.Headers["X-Value"] = uniqueId;
+                    await context.Features.Get<IHttpSendFileFeature>().SendFileAsync("dummy", 0, 0, CancellationToken.None);
+                    await context.Response.WriteAsync(uniqueId);
+                });
+
+            using (var server = new TestServer(builder))
+            {
+                var client = server.CreateClient();
+                var initialResponse = await client.GetAsync("");
+                var subsequentResponse = await client.GetAsync("");
+
+                initialResponse.EnsureSuccessStatusCode();
+                subsequentResponse.EnsureSuccessStatusCode();
+
+                Assert.False(subsequentResponse.Headers.Contains(HeaderNames.Age));
+                Assert.NotEqual(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());
+            }
+        }
+
+        private static IWebHostBuilder CreateBuilderWithResponseCaching(RequestDelegate requestDelegate) =>
+            CreateBuilderWithResponseCaching(app => { }, requestDelegate);
+
+        private static IWebHostBuilder CreateBuilderWithResponseCaching(Action<IApplicationBuilder> configureDelegate, RequestDelegate requestDelegate)
         {
             return new WebHostBuilder()
                 .ConfigureServices(services =>
@@ -268,9 +315,18 @@ private static IWebHostBuilder CreateBuilderWithResponseCaching(RequestDelegate
                 })
                 .Configure(app =>
                 {
+                    configureDelegate(app);
                     app.UseResponseCaching();
                     app.Run(requestDelegate);
                 });
         }
+
+        private class DummySendFileFeature : IHttpSendFileFeature
+        {
+            public Task SendFileAsync(string path, long offset, long? count, CancellationToken cancellation)
+            {
+                return Task.FromResult(0);
+            }
+        }
     }
 }