Spike of unified response body features #11305

Author: Tratcher

src/Hosting/TestHost/src/HttpContextBuilder.cs

@@ -45,15 +45,13 @@ internal HttpContextBuilder(ApplicationWrapper application, bool allowSynchronou
             _responseReaderStream = new ResponseBodyReaderStream(pipe, ClientInitiatedAbort, () => _responseReadCompleteCallback?.Invoke(_httpContext));
             _responsePipeWriter = new ResponseBodyPipeWriter(pipe, ReturnResponseMessageAsync);
             _responseFeature.Body = new ResponseBodyWriterStream(_responsePipeWriter, () => AllowSynchronousIO);
-            _responseFeature.BodySnapshot = _responseFeature.Body;
             _responseFeature.BodyWriter = _responsePipeWriter;
 
             _httpContext.Features.Set<IHttpBodyControlFeature>(this);
             _httpContext.Features.Set<IHttpResponseFeature>(_responseFeature);
-            _httpContext.Features.Set<IHttpResponseStartFeature>(_responseFeature);
+            _httpContext.Features.Set<IHttpResponseBodyFeature>(_responseFeature);
             _httpContext.Features.Set<IHttpRequestLifetimeFeature>(_requestLifetimeFeature);
             _httpContext.Features.Set<IHttpResponseTrailersFeature>(_responseTrailersFeature);
-            _httpContext.Features.Set<IResponseBodyPipeFeature>(_responseFeature);
         }
 
         public bool AllowSynchronousIO { get; set; }
@@ -183,6 +181,7 @@ internal async Task ReturnResponseMessageAsync()
                     Body = _responseReaderStream
                 };
                 newFeatures.Set<IHttpResponseFeature>(clientResponseFeature);
+                newFeatures.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(_responseReaderStream));
                 _responseTcs.TrySetResult(new DefaultHttpContext(newFeatures));
             }
         }

src/Hosting/TestHost/src/ResponseFeature.cs

@@ -11,7 +11,7 @@
 
 namespace Microsoft.AspNetCore.TestHost
 {
-    internal class ResponseFeature : IHttpResponseFeature, IHttpResponseStartFeature, IResponseBodyPipeFeature
+    internal class ResponseFeature : IHttpResponseFeature, IHttpResponseBodyFeature
     {
         private readonly HeaderDictionary _headers = new HeaderDictionary();
         private readonly Action<Exception> _abort;
@@ -24,7 +24,6 @@ internal class ResponseFeature : IHttpResponseFeature, IHttpResponseStartFeature
         public ResponseFeature(Action<Exception> abort)
         {
             Headers = _headers;
-            Body = new MemoryStream();
 
             // 200 is the default status code all the way down to the host, so we set it
             // here to be consistent with the rest of the hosts when writing tests.
@@ -68,29 +67,9 @@ public string ReasonPhrase
 
         public Stream Body { get; set; }
 
-        internal Stream BodySnapshot { get; set; }
-
         internal PipeWriter BodyWriter { get; set; }
 
-        public PipeWriter Writer
-        {
-            get
-            {
-                if (!ReferenceEquals(BodySnapshot, Body))
-                {
-                    BodySnapshot = Body;
-                    BodyWriter = PipeWriter.Create(Body);
-
-                    OnCompleted((self) =>
-                    {
-                        ((PipeWriter)self).Complete();
-                        return Task.CompletedTask;
-                    }, BodyWriter);
-                }
-
-                return BodyWriter;
-            }
-        }
+        public PipeWriter Writer => BodyWriter;
 
         public bool HasStarted { get; set; }
 
@@ -158,5 +137,19 @@ public async Task StartAsync(CancellationToken token = default)
                 throw;
             }
         }
+
+        public void DisableResponseBuffering()
+        {
+        }
+
+        public Task SendFileAsync(string path, long offset, long? count, CancellationToken cancellation)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task CompleteAsync()
+        {
+            return Writer.CompleteAsync().AsTask();
+        }
     }
 }

src/Http/Http.Features/src/IHttpResponseBodyFeature.cs

@@ -0,0 +1,54 @@
+// 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.IO;
+using System.IO.Pipelines;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.Http.Features
+{
+    /// <summary>
+    /// An aggregate of the different ways to interact with the response body.
+    /// </summary>
+    public interface IHttpResponseBodyFeature
+    {
+        /// <summary>
+        /// The <see cref="Stream"/> for writing the response body.
+        /// </summary>
+        Stream Body { get; }
+
+        /// <summary>
+        /// A <see cref="PipeWriter"/> representing the response body, if any.
+        /// </summary>
+        PipeWriter Writer { get; }
+
+        /// <summary>
+        /// Opts out of write buffering for the response.
+        /// </summary>
+        void DisableResponseBuffering();
+
+        /// <summary>
+        /// Starts the response by calling OnStarting() and making headers unmodifiable.
+        /// </summary>
+        Task StartAsync(CancellationToken token = default);
+
+        /// <summary>
+        /// Sends the requested file in the response body. This may bypass the IHttpResponseFeature.Body
+        /// <see cref="Stream"/>. A response may include multiple writes.
+        /// </summary>
+        /// <param name="path">The full disk path to the file.</param>
+        /// <param name="offset">The offset in the file to start at.</param>
+        /// <param name="count">The number of bytes to send, or null to send the remainder of the file.</param>
+        /// <param name="cancellation">A <see cref="CancellationToken"/> used to abort the transmission.</param>
+        /// <returns></returns>
+        Task SendFileAsync(string path, long offset, long? count, CancellationToken cancellation);
+
+        /// <summary>
+        /// Flush any remaining response headers, data, or trailers.
+        /// This may throw if the response is in an invalid state such as a Content-Length mismatch.
+        /// </summary>
+        /// <returns></returns>
+        Task CompleteAsync();
+    }
+}

src/Http/Http.Features/src/IHttpResponseFeature.cs

@@ -30,7 +30,7 @@ public interface IHttpResponseFeature
         /// <summary>
         /// The <see cref="Stream"/> for writing the response body.
         /// </summary>
-        Stream Body { get; set; }
+        Stream Body { get; [Obsolete("Use IHttpResponseBodyFeature instead.", error: false)] set; }
 
         /// <summary>
         /// Indicates if the response has started. If true, the <see cref="StatusCode"/>,

src/Http/Http.Features/src/IHttpResponseStartFeature.cs

@@ -1,6 +1,7 @@
 // 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;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -9,6 +10,7 @@ namespace Microsoft.AspNetCore.Http.Features
     /// <summary>
     /// Feature to start response writing.
     /// </summary>
+    [Obsolete("TODO: Remove, use IHttpResponseBodyFeature instead", error: false)]
     public interface IHttpResponseStartFeature
     {
         /// <summary>

src/Http/Http.Features/src/IResponseBodyPipeFeature.cs

@@ -9,6 +9,7 @@ namespace Microsoft.AspNetCore.Http.Features
     /// <summary>
     ///     Represents the HttpResponseBody as a PipeWriter
     /// </summary>
+    [Obsolete("TODO: Remove, use IHttpResponseBodyFeature instead.", error: false)]
     public interface IResponseBodyPipeFeature
     {
         /// <summary>

src/Http/Http/src/DefaultHttpContext.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.IO;
 using System.Security.Claims;
 using System.Threading;
 using Microsoft.AspNetCore.Http.Features;
@@ -36,6 +37,7 @@ public DefaultHttpContext()
         {
             Features.Set<IHttpRequestFeature>(new HttpRequestFeature());
             Features.Set<IHttpResponseFeature>(new HttpResponseFeature());
+            Features.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(Stream.Null));
         }
 
         public DefaultHttpContext(IFeatureCollection features)

src/Http/Http/src/Features/ResponseBodyPipeFeature.cs

@@ -15,9 +15,8 @@ internal sealed class DefaultHttpResponse : HttpResponse
     {
         // Lambdas hoisted to static readonly fields to improve inlining https://github.com/dotnet/roslyn/issues/13624
         private readonly static Func<IFeatureCollection, IHttpResponseFeature> _nullResponseFeature = f => null;
-        private readonly static Func<IFeatureCollection, IHttpResponseStartFeature> _nullResponseStartFeature = f => null;
+        private readonly static Func<IFeatureCollection, IHttpResponseBodyFeature> _nullResponseBodyFeature = f => null;
         private readonly static Func<IFeatureCollection, IResponseCookiesFeature> _newResponseCookiesFeature = f => new ResponseCookiesFeature(f);
-        private readonly static Func<HttpContext, IResponseBodyPipeFeature> _newResponseBodyPipeFeature = context => new ResponseBodyPipeFeature(context);
 
         private readonly DefaultHttpContext _context;
         private FeatureReferences<FeatureInterfaces> _features;
@@ -46,15 +45,12 @@ public void Uninitialize()
         private IHttpResponseFeature HttpResponseFeature =>
             _features.Fetch(ref _features.Cache.Response, _nullResponseFeature);
 
-        private IHttpResponseStartFeature HttpResponseStartFeature =>
-            _features.Fetch(ref _features.Cache.ResponseStart, _nullResponseStartFeature);
+        private IHttpResponseBodyFeature HttpResponseBodyFeature =>
+            _features.Fetch(ref _features.Cache.ResponseBody, _nullResponseBodyFeature);
 
         private IResponseCookiesFeature ResponseCookiesFeature =>
             _features.Fetch(ref _features.Cache.Cookies, _newResponseCookiesFeature);
 
-        private IResponseBodyPipeFeature ResponseBodyPipeFeature =>
-            _features.Fetch(ref _features.Cache.BodyPipe, this.HttpContext, _newResponseBodyPipeFeature);
-
         public override HttpContext HttpContext { get { return _context; } }
 
         public override int StatusCode
@@ -70,8 +66,13 @@ public override IHeaderDictionary Headers
 
         public override Stream Body
         {
-            get { return HttpResponseFeature.Body; }
-            set { HttpResponseFeature.Body = value; }
+            get { return HttpResponseBodyFeature.Body; }
+            set
+            {
+                var feature = new StreamResponseBodyFeature(value);
+                OnCompleted(feature.CompleteAsync);
+                _features.Collection.Set<IHttpResponseBodyFeature>(feature);
+            }
         }
 
         public override long? ContentLength
@@ -111,7 +112,7 @@ public override bool HasStarted
 
         public override PipeWriter BodyWriter
         {
-            get { return ResponseBodyPipeFeature.Writer; }
+            get { return HttpResponseBodyFeature.Writer; }
         }
 
         public override void OnStarting(Func<object, Task> callback, object state)
@@ -155,20 +156,14 @@ public override Task StartAsync(CancellationToken cancellationToken = default)
                 return Task.CompletedTask;
             }
 
-            if (HttpResponseStartFeature == null)
-            {
-                return HttpResponseFeature.Body.FlushAsync(cancellationToken);
-            }
-
-            return HttpResponseStartFeature.StartAsync(cancellationToken);
+            return HttpResponseBodyFeature.StartAsync(cancellationToken);
         }
 
         struct FeatureInterfaces
         {
             public IHttpResponseFeature Response;
+            public IHttpResponseBodyFeature ResponseBody;
             public IResponseCookiesFeature Cookies;
-            public IResponseBodyPipeFeature BodyPipe;
-            public IHttpResponseStartFeature ResponseStart;
         }
     }
 }