Add EnableRangeProcessingSwitch for FileContentResult and Fil… (#6839)

jbagga · web-flow · commit b3aa691549c6 · 2017-09-18T10:57:49.000-07:00
Addresses #6792
diff --git a/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileContentResultExecutor.cs b/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileContentResultExecutor.cs
@@ -28,12 +28,14 @@ public virtual Task ExecuteAsync(ActionContext context, FileContentResult result
                 throw new ArgumentNullException(nameof(result));
             }
 
+            AppContext.TryGetSwitch(EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch);
             var (range, rangeLength, serveBody) = SetHeadersAndLog(
                 context,
                 result,
                 result.FileContents.Length,
                 result.LastModified,
-                result.EntityTag);
+                result.EntityTag,
+                enableRangeProcessingSwitch);
 
             if (!serveBody)
             {
diff --git a/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileResultExecutorBase.cs b/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileResultExecutorBase.cs
@@ -17,6 +17,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
 {
     public class FileResultExecutorBase
     {
+        internal const string EnableRangeProcessingSwitch = "Switch.Microsoft.AspNetCore.Mvc.EnableRangeProcessing";
+
         private const string AcceptRangeHeaderValue = "bytes";
 
         protected const int BufferSize = 64 * 1024;
@@ -41,7 +43,8 @@ protected virtual (RangeItemHeaderValue range, long rangeLength, bool serveBody)
             FileResult result,
             long? fileLength,
             DateTimeOffset? lastModified = null,
-            EntityTagHeaderValue etag = null)
+            EntityTagHeaderValue etag = null,
+            bool enableRangeProcessing = true)
         {
             if (context == null)
             {
@@ -84,19 +87,23 @@ protected virtual (RangeItemHeaderValue range, long rangeLength, bool serveBody)
 
             if (fileLength.HasValue)
             {
-                SetAcceptRangeHeader(context);
                 // Assuming the request is not a range request, the Content-Length header is set to the length of the entire file. 
                 // If the request is a valid range request, this header is overwritten with the length of the range as part of the 
                 // range processing (see method SetContentLength).
                 response.ContentLength = fileLength.Value;
-                if (HttpMethods.IsHead(request.Method) || HttpMethods.IsGet(request.Method))
+
+                if (enableRangeProcessing)
                 {
-                    if ((preconditionState == PreconditionState.Unspecified ||
-                        preconditionState == PreconditionState.ShouldProcess))
+                    SetAcceptRangeHeader(context);
+                    if (HttpMethods.IsHead(request.Method) || HttpMethods.IsGet(request.Method))
                     {
-                        if (IfRangeValid(context, httpRequestHeaders, lastModified, etag))
+                        if ((preconditionState == PreconditionState.Unspecified ||
+                            preconditionState == PreconditionState.ShouldProcess))
                         {
-                            return SetRangeHeaders(context, httpRequestHeaders, fileLength.Value);
+                            if (IfRangeValid(context, httpRequestHeaders, lastModified, etag))
+                            {
+                                return SetRangeHeaders(context, httpRequestHeaders, fileLength.Value);
+                            }
                         }
                     }
                 }
diff --git a/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileStreamResultExecutor.cs b/src/Microsoft.AspNetCore.Mvc.Core/Internal/FileStreamResultExecutor.cs
@@ -33,12 +33,14 @@ public virtual Task ExecuteAsync(ActionContext context, FileStreamResult result)
                 fileLength = result.FileStream.Length;
             }
 
+            AppContext.TryGetSwitch(EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch);
             var (range, rangeLength, serveBody) = SetHeadersAndLog(
                 context,
                 result,
                 fileLength,
                 result.LastModified,
-                result.EntityTag);
+                result.EntityTag,
+                enableRangeProcessingSwitch);
 
             if (!serveBody)
             {
diff --git a/src/Microsoft.AspNetCore.Mvc.Core/Properties/AssemblyInfo.cs b/src/Microsoft.AspNetCore.Mvc.Core/Properties/AssemblyInfo.cs
@@ -4,4 +4,5 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("Microsoft.AspNetCore.Mvc.Core.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
+[assembly: InternalsVisibleTo("Microsoft.AspNetCore.Mvc.FunctionalTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
diff --git a/test/Microsoft.AspNetCore.Mvc.Core.Test/FileContentResultTest.cs b/test/Microsoft.AspNetCore.Mvc.Core.Test/FileContentResultTest.cs
@@ -99,7 +99,7 @@ public async Task WriteFileAsync_CopiesBuffer_ToOutputStream()
         [InlineData(6, 10, "World", 5)]
         [InlineData(null, 5, "World", 5)]
         [InlineData(6, null, "World", 5)]
-        public async Task WriteFileAsync_PreconditionStateShouldProcess_WritesRangeRequested(long? start, long? end, string expectedString, long contentLength)
+        public async Task WriteFileAsync_PreconditionStateShouldProcess_RangeRequestIgnored_WritesRangeRequested_IfRangeProcessingOn(long? start, long? end, string expectedString, long contentLength)
         {
             // Arrange
             var contentType = "text/plain";
@@ -134,18 +134,29 @@ public async Task WriteFileAsync_PreconditionStateShouldProcess_WritesRangeReque
             httpResponse.Body.Seek(0, SeekOrigin.Begin);
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
-            Assert.Equal(StatusCodes.Status206PartialContent, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
-            var contentRange = new ContentRangeHeaderValue(start.Value, end.Value, byteArray.Length);
-            Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.Equal(lastModified.ToString("R"), httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Equal(entityTag.ToString(), httpResponse.Headers[HeaderNames.ETag]);
-            Assert.Equal(contentLength, httpResponse.ContentLength);
-            Assert.Equal(expectedString, body);
+
+            if (AppContext.TryGetSwitch(FileResultExecutorBase.EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch)
+                && enableRangeProcessingSwitch)
+            {
+                Assert.Equal(StatusCodes.Status206PartialContent, httpResponse.StatusCode);
+                Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
+                var contentRange = new ContentRangeHeaderValue(start.Value, end.Value, byteArray.Length);
+                Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
+                Assert.Equal(contentLength, httpResponse.ContentLength);
+                Assert.Equal(expectedString, body);
+            }
+            else
+            {
+                Assert.Equal(StatusCodes.Status200OK, httpResponse.StatusCode);
+                Assert.Equal(11, httpResponse.ContentLength);
+                Assert.Equal("Hello World", body);
+            }
         }
 
         [Fact]
-        public async Task WriteFileAsync_IfRangeHeaderValid_WritesRequestedRange()
+        public async Task WriteFileAsync_IfRangeHeaderValid_WritesRangeRequest_IfRangeProcessingOn()
         {
             // Arrange
             var contentType = "text/plain";
@@ -179,18 +190,29 @@ public async Task WriteFileAsync_IfRangeHeaderValid_WritesRequestedRange()
             httpResponse.Body.Seek(0, SeekOrigin.Begin);
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
-            Assert.Equal(StatusCodes.Status206PartialContent, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
-            var contentRange = new ContentRangeHeaderValue(0, 4, byteArray.Length);
-            Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.Equal(lastModified.ToString("R"), httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Equal(entityTag.ToString(), httpResponse.Headers[HeaderNames.ETag]);
-            Assert.Equal(5, httpResponse.ContentLength);
-            Assert.Equal("Hello", body);
+
+            if (AppContext.TryGetSwitch(FileResultExecutorBase.EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch)
+                && enableRangeProcessingSwitch)
+            {
+                Assert.Equal(StatusCodes.Status206PartialContent, httpResponse.StatusCode);
+                Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
+                var contentRange = new ContentRangeHeaderValue(0, 4, byteArray.Length);
+                Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
+                Assert.Equal(5, httpResponse.ContentLength);
+                Assert.Equal("Hello", body);
+            }
+            else
+            {
+                Assert.Equal(StatusCodes.Status200OK, httpResponse.StatusCode);
+                Assert.Equal(11, httpResponse.ContentLength);
+                Assert.Equal("Hello World", body);
+            }
         }
 
         [Fact]
-        public async Task WriteFileAsync_IfRangeHeaderInvalid_RangeRequestedIgnored()
+        public async Task WriteFileAsync_IfRangeHeaderInvalid_RangeRequestIgnored()
         {
             // Arrange
             var contentType = "text/plain";
@@ -225,7 +247,6 @@ public async Task WriteFileAsync_IfRangeHeaderInvalid_RangeRequestedIgnored()
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
             Assert.Equal(StatusCodes.Status200OK, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
             Assert.Equal(lastModified.ToString("R"), httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Equal(entityTag.ToString(), httpResponse.Headers[HeaderNames.ETag]);
             Assert.Equal("Hello World", body);
@@ -265,7 +286,6 @@ public async Task WriteFileAsync_PreconditionStateUnspecified_RangeRequestIgnore
             var body = streamReader.ReadToEndAsync().Result;
             Assert.Empty(httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.Equal(StatusCodes.Status200OK, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
             Assert.Equal(lastModified.ToString("R"), httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Equal(entityTag.ToString(), httpResponse.Headers[HeaderNames.ETag]);
             Assert.Equal("Hello World", body);
@@ -303,16 +323,26 @@ public async Task WriteFileAsync_PreconditionStateUnspecified_RangeRequestedNotS
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
             var contentRange = new ContentRangeHeaderValue(byteArray.Length);
-            Assert.Equal(StatusCodes.Status416RangeNotSatisfiable, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
-            Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.Equal(lastModified.ToString("R"), httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Equal(entityTag.ToString(), httpResponse.Headers[HeaderNames.ETag]);
-            Assert.Empty(body);
+
+            if (AppContext.TryGetSwitch(FileResultExecutorBase.EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch)
+                && enableRangeProcessingSwitch)
+            {
+                Assert.Equal(StatusCodes.Status416RangeNotSatisfiable, httpResponse.StatusCode);
+                Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
+                Assert.Equal(contentRange.ToString(), httpResponse.Headers[HeaderNames.ContentRange]);
+                Assert.Empty(body);
+            }
+            else
+            {
+                Assert.Equal(StatusCodes.Status200OK, httpResponse.StatusCode);
+                Assert.Equal("Hello World", body);
+            }
         }
 
         [Fact]
-        public async Task WriteFileAsync_RangeRequested_PreconditionFailed()
+        public async Task WriteFileAsync_PreconditionFailed()
         {
             // Arrange
             var contentType = "text/plain";
@@ -346,15 +376,14 @@ public async Task WriteFileAsync_RangeRequested_PreconditionFailed()
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
             Assert.Equal(StatusCodes.Status412PreconditionFailed, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
             Assert.Equal(11, httpResponse.ContentLength);
             Assert.Empty(httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.NotEmpty(httpResponse.Headers[HeaderNames.LastModified]);
             Assert.Empty(body);
         }
 
         [Fact]
-        public async Task WriteFileAsync_RangeRequested_NotModified()
+        public async Task WriteFileAsync_NotModified()
         {
             // Arrange       
             var contentType = "text/plain";
@@ -388,7 +417,6 @@ public async Task WriteFileAsync_RangeRequested_NotModified()
             var streamReader = new StreamReader(httpResponse.Body);
             var body = streamReader.ReadToEndAsync().Result;
             Assert.Equal(StatusCodes.Status304NotModified, httpResponse.StatusCode);
-            Assert.Equal("bytes", httpResponse.Headers[HeaderNames.AcceptRanges]);
             Assert.Equal(11, httpResponse.ContentLength);
             Assert.Empty(httpResponse.Headers[HeaderNames.ContentRange]);
             Assert.NotEmpty(httpResponse.Headers[HeaderNames.LastModified]);
diff --git a/test/Microsoft.AspNetCore.Mvc.Core.Test/FileStreamResultTest.cs b/test/Microsoft.AspNetCore.Mvc.Core.Test/FileStreamResultTest.cs
diff --git a/test/Microsoft.AspNetCore.Mvc.FunctionalTests/FileResultTests.cs b/test/Microsoft.AspNetCore.Mvc.FunctionalTests/FileResultTests.cs

Original file line number	Diff line number	Diff line change
`@@ -28,12 +28,14 @@ public virtual Task ExecuteAsync(ActionContext context, FileContentResult result`
`28`	`28`	`throw new ArgumentNullException(nameof(result));`
`29`	`29`	`}`
`30`	`30`
	`31`	`+ AppContext.TryGetSwitch(EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch);`
`31`	`32`	`var (range, rangeLength, serveBody) = SetHeadersAndLog(`
`32`	`33`	`context,`
`33`	`34`	`result,`
`34`	`35`	`result.FileContents.Length,`
`35`	`36`	`result.LastModified,`
`36`		`- result.EntityTag);`
	`37`	`+ result.EntityTag,`
	`38`	`+ enableRangeProcessingSwitch);`
`37`	`39`
`38`	`40`	`if (!serveBody)`
`39`	`41`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal`
`17`	`17`	`{`
`18`	`18`	`public class FileResultExecutorBase`
`19`	`19`	`{`
	`20`	`+ internal const string EnableRangeProcessingSwitch = "Switch.Microsoft.AspNetCore.Mvc.EnableRangeProcessing";`
	`21`	`+`
`20`	`22`	`private const string AcceptRangeHeaderValue = "bytes";`
`21`	`23`
`22`	`24`	`protected const int BufferSize = 64 * 1024;`
`@@ -41,7 +43,8 @@ protected virtual (RangeItemHeaderValue range, long rangeLength, bool serveBody)`
`41`	`43`	`FileResult result,`
`42`	`44`	`long? fileLength,`
`43`	`45`	`DateTimeOffset? lastModified = null,`
`44`		`- EntityTagHeaderValue etag = null)`
	`46`	`+ EntityTagHeaderValue etag = null,`
	`47`	`+ bool enableRangeProcessing = true)`
`45`	`48`	`{`
`46`	`49`	`if (context == null)`
`47`	`50`	`{`
`@@ -84,19 +87,23 @@ protected virtual (RangeItemHeaderValue range, long rangeLength, bool serveBody)`
`84`	`87`
`85`	`88`	`if (fileLength.HasValue)`
`86`	`89`	`{`
`87`		`- SetAcceptRangeHeader(context);`
`88`	`90`	`// Assuming the request is not a range request, the Content-Length header is set to the length of the entire file.`
`89`	`91`	`// If the request is a valid range request, this header is overwritten with the length of the range as part of the`
`90`	`92`	`// range processing (see method SetContentLength).`
`91`	`93`	`response.ContentLength = fileLength.Value;`
`92`		`- if (HttpMethods.IsHead(request.Method) \|\| HttpMethods.IsGet(request.Method))`
	`94`	`+`
	`95`	`+ if (enableRangeProcessing)`
`93`	`96`	`{`
`94`		`- if ((preconditionState == PreconditionState.Unspecified \|\|`
`95`		`- preconditionState == PreconditionState.ShouldProcess))`
	`97`	`+ SetAcceptRangeHeader(context);`
	`98`	`+ if (HttpMethods.IsHead(request.Method) \|\| HttpMethods.IsGet(request.Method))`
`96`	`99`	`{`
`97`		`- if (IfRangeValid(context, httpRequestHeaders, lastModified, etag))`
	`100`	`+ if ((preconditionState == PreconditionState.Unspecified \|\|`
	`101`	`+ preconditionState == PreconditionState.ShouldProcess))`
`98`	`102`	`{`
`99`		`- return SetRangeHeaders(context, httpRequestHeaders, fileLength.Value);`
	`103`	`+ if (IfRangeValid(context, httpRequestHeaders, lastModified, etag))`
	`104`	`+ {`
	`105`	`+ return SetRangeHeaders(context, httpRequestHeaders, fileLength.Value);`
	`106`	`+ }`
`100`	`107`	`}`
`101`	`108`	`}`
`102`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,12 +33,14 @@ public virtual Task ExecuteAsync(ActionContext context, FileStreamResult result)`
`33`	`33`	`fileLength = result.FileStream.Length;`
`34`	`34`	`}`
`35`	`35`
	`36`	`+ AppContext.TryGetSwitch(EnableRangeProcessingSwitch, out var enableRangeProcessingSwitch);`
`36`	`37`	`var (range, rangeLength, serveBody) = SetHeadersAndLog(`
`37`	`38`	`context,`
`38`	`39`	`result,`
`39`	`40`	`fileLength,`
`40`	`41`	`result.LastModified,`
`41`		`- result.EntityTag);`
	`42`	`+ result.EntityTag,`
	`43`	`+ enableRangeProcessingSwitch);`
`42`	`44`
`43`	`45`	`if (!serveBody)`
`44`	`46`	`{`