Implement Http/2 CompleteAsync #10886

Tratcher · Tratcher · commit f27a2336e069 · 2019-06-14T15:11:23.000-07:00
diff --git a/src/Http/Http.Features/src/IHttpResponseCompletionFeature.cs b/src/Http/Http.Features/src/IHttpResponseCompletionFeature.cs
@@ -0,0 +1,20 @@
+// 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.Tasks;
+
+namespace Microsoft.AspNetCore.Http.Features
+{
+    /// <summary>
+    /// A feature to gracefully end a response.
+    /// </summary>
+    public interface IHttpResponseCompletionFeature
+    {
+        /// <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();
+    }
+}
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.FeatureCollection.cs b/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.FeatureCollection.cs
@@ -277,6 +277,7 @@ protected void ResetHttp1Features()
         protected void ResetHttp2Features()
         {
             _currentIHttp2StreamIdFeature = this;
+            _currentIHttpResponseCompletionFeature = this;
             _currentIHttpResponseTrailersFeature = this;
         }
 
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.Generated.cs b/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.Generated.cs
@@ -29,6 +29,7 @@ internal partial class HttpProtocol : IFeatureCollection
         private static readonly Type IFormFeatureType = typeof(IFormFeature);
         private static readonly Type IHttpUpgradeFeatureType = typeof(IHttpUpgradeFeature);
         private static readonly Type IHttp2StreamIdFeatureType = typeof(IHttp2StreamIdFeature);
+        private static readonly Type IHttpResponseCompletionFeatureType = typeof(IHttpResponseCompletionFeature);
         private static readonly Type IHttpResponseTrailersFeatureType = typeof(IHttpResponseTrailersFeature);
         private static readonly Type IResponseCookiesFeatureType = typeof(IResponseCookiesFeature);
         private static readonly Type IItemsFeatureType = typeof(IItemsFeature);
@@ -58,6 +59,7 @@ internal partial class HttpProtocol : IFeatureCollection
         private object _currentIFormFeature;
         private object _currentIHttpUpgradeFeature;
         private object _currentIHttp2StreamIdFeature;
+        private object _currentIHttpResponseCompletionFeature;
         private object _currentIHttpResponseTrailersFeature;
         private object _currentIResponseCookiesFeature;
         private object _currentIItemsFeature;
@@ -98,6 +100,7 @@ private void FastReset()
             _currentIQueryFeature = null;
             _currentIFormFeature = null;
             _currentIHttp2StreamIdFeature = null;
+            _currentIHttpResponseCompletionFeature = null;
             _currentIHttpResponseTrailersFeature = null;
             _currentIResponseCookiesFeature = null;
             _currentIItemsFeature = null;
@@ -224,6 +227,10 @@ object IFeatureCollection.this[Type key]
                 {
                     feature = _currentIHttp2StreamIdFeature;
                 }
+                else if (key == IHttpResponseCompletionFeatureType)
+                {
+                    feature = _currentIHttpResponseCompletionFeature;
+                }
                 else if (key == IHttpResponseTrailersFeatureType)
                 {
                     feature = _currentIHttpResponseTrailersFeature;
@@ -348,6 +355,10 @@ object IFeatureCollection.this[Type key]
                 {
                     _currentIHttp2StreamIdFeature = value;
                 }
+                else if (key == IHttpResponseCompletionFeatureType)
+                {
+                    _currentIHttpResponseCompletionFeature = value;
+                }
                 else if (key == IHttpResponseTrailersFeatureType)
                 {
                     _currentIHttpResponseTrailersFeature = value;
@@ -470,6 +481,10 @@ TFeature IFeatureCollection.Get<TFeature>()
             {
                 feature = (TFeature)_currentIHttp2StreamIdFeature;
             }
+            else if (typeof(TFeature) == typeof(IHttpResponseCompletionFeature))
+            {
+                feature = (TFeature)_currentIHttpResponseCompletionFeature;
+            }
             else if (typeof(TFeature) == typeof(IHttpResponseTrailersFeature))
             {
                 feature = (TFeature)_currentIHttpResponseTrailersFeature;
@@ -598,6 +613,10 @@ void IFeatureCollection.Set<TFeature>(TFeature feature)
             {
                 _currentIHttp2StreamIdFeature = feature;
             }
+            else if (typeof(TFeature) == typeof(IHttpResponseCompletionFeature))
+            {
+                _currentIHttpResponseCompletionFeature = feature;
+            }
             else if (typeof(TFeature) == typeof(IHttpResponseTrailersFeature))
             {
                 _currentIHttpResponseTrailersFeature = feature;
@@ -718,6 +737,10 @@ private IEnumerable<KeyValuePair<Type, object>> FastEnumerable()
             {
                 yield return new KeyValuePair<Type, object>(IHttp2StreamIdFeatureType, _currentIHttp2StreamIdFeature);
             }
+            if (_currentIHttpResponseCompletionFeature != null)
+            {
+                yield return new KeyValuePair<Type, object>(IHttpResponseCompletionFeatureType, _currentIHttpResponseCompletionFeature);
+            }
             if (_currentIHttpResponseTrailersFeature != null)
             {
                 yield return new KeyValuePair<Type, object>(IHttpResponseTrailersFeatureType, _currentIHttpResponseTrailersFeature);
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs b/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs
@@ -210,6 +210,7 @@ private void HttpVersionSetSlow(string value)
         public bool RequestTrailersAvailable { get; set; }
         public Stream RequestBody { get; set; }
         public PipeReader RequestBodyPipeReader { get; set; }
+        public HttpResponseTrailers ResponseTrailers { get; set; }
 
         private int _statusCode;
         public int StatusCode
@@ -287,7 +288,9 @@ public CancellationToken RequestAborted
 
         public bool HasResponseStarted => _requestProcessingStatus >= RequestProcessingStatus.HeadersCommitted;
 
-        public bool HasFlushedHeaders => _requestProcessingStatus == RequestProcessingStatus.HeadersFlushed;
+        public bool HasFlushedHeaders => _requestProcessingStatus >= RequestProcessingStatus.HeadersFlushed;
+
+        public bool HasResponseCompleted => _requestProcessingStatus == RequestProcessingStatus.ResponseCompleted;
 
         protected HttpRequestHeaders HttpRequestHeaders { get; }
 
@@ -632,9 +635,9 @@ private async Task ProcessRequests<TContext>(IHttpApplication<TContext> applicat
                     // Run the application code for this request
                     await application.ProcessRequestAsync(context);
 
-                    if (!_connectionAborted)
+                    if (!_connectionAborted && !VerifyResponseContentLength(out var lengthException))
                     {
-                        VerifyResponseContentLength();
+                        ReportApplicationError(lengthException);
                     }
                 }
                 catch (BadHttpRequestException ex)
@@ -898,7 +901,7 @@ private void CheckLastWrite()
             }
         }
 
-        protected void VerifyResponseContentLength()
+        protected bool VerifyResponseContentLength(out Exception ex)
         {
             var responseHeaders = HttpResponseHeaders;
 
@@ -915,9 +918,13 @@ protected void VerifyResponseContentLength()
                     _keepAlive = false;
                 }
 
-                ReportApplicationError(new InvalidOperationException(
-                    CoreStrings.FormatTooFewBytesWritten(_responseBytesWritten, responseHeaders.ContentLength.Value)));
+                ex = new InvalidOperationException(
+                    CoreStrings.FormatTooFewBytesWritten(_responseBytesWritten, responseHeaders.ContentLength.Value));
+                return false;
             }
+
+            ex = null;
+            return true;
         }
 
         public void ProduceContinue()
@@ -935,7 +942,7 @@ public void ProduceContinue()
             }
         }
 
-        public Task InitializeResponseAsync(int firstWriteByteCount)
+        public Task InitializeResponseAsync(int firstWriteByteCount, bool appCompleted = false)
         {
             var startingTask = FireOnStarting();
             // If return is Task.CompletedTask no awaiting is required
@@ -946,7 +953,7 @@ public Task InitializeResponseAsync(int firstWriteByteCount)
 
             VerifyInitializeState(firstWriteByteCount);
 
-            ProduceStart(appCompleted: false);
+            ProduceStart(appCompleted: appCompleted);
 
             return Task.CompletedTask;
         }
@@ -1043,8 +1050,13 @@ protected Task ProduceEnd()
             return WriteSuffix();
         }
 
-        private Task WriteSuffix()
+        protected Task WriteSuffix()
         {
+            if (HasResponseCompleted)
+            {
+                return Task.CompletedTask;
+            }
+
             // _autoChunk should be checked after we are sure ProduceStart() has been called
             // since ProduceStart() may set _autoChunk to true.
             if (_autoChunk || _httpVersion == Http.HttpVersion.Http2)
@@ -1064,7 +1076,7 @@ private Task WriteSuffix()
 
             if (!HasFlushedHeaders)
             {
-                _requestProcessingStatus = RequestProcessingStatus.HeadersFlushed;
+                _requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;
                 return FlushAsyncInternal();
             }
 
@@ -1080,6 +1092,8 @@ private async Task WriteSuffixAwaited()
 
             await Output.WriteStreamSuffixAsync();
 
+            _requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;
+
             if (_keepAlive)
             {
                 Log.ConnectionKeepAlive(ConnectionId);
@@ -1244,6 +1258,7 @@ private void SetErrorResponseHeaders(int statusCode)
 
             var responseHeaders = HttpResponseHeaders;
             responseHeaders.Reset();
+            ResponseTrailers?.Reset();
             var dateHeaderValues = DateHeaderValueManager.GetDateHeaderValues();
 
             responseHeaders.SetRawDate(dateHeaderValues.String, dateHeaderValues.Bytes);
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/RequestProcessingStatus.cs b/src/Servers/Kestrel/Core/src/Internal/Http/RequestProcessingStatus.cs
@@ -10,6 +10,7 @@ internal enum RequestProcessingStatus
         ParsingHeaders,
         AppStarted,
         HeadersCommitted,
-        HeadersFlushed
+        HeadersFlushed,
+        ResponseCompleted
     }
 }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2OutputProducer.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2OutputProducer.cs
@@ -151,7 +151,7 @@ public void WriteResponseHeaders(int statusCode, string ReasonPhrase, HttpRespon
                 // 2. There is no trailing HEADERS frame.
                 Http2HeadersFrameFlags http2HeadersFrame;
 
-                if (appCompleted && !_startedWritingDataFrames && (_stream.Trailers == null || _stream.Trailers.Count == 0))
+                if (appCompleted && !_startedWritingDataFrames && (_stream.ResponseTrailers == null || _stream.ResponseTrailers.Count == 0))
                 {
                     _streamEnded = true;
                     http2HeadersFrame = Http2HeadersFrameFlags.END_STREAM;
@@ -313,7 +313,7 @@ private async ValueTask<FlushResult> ProcessDataWrites()
                 {
                     readResult = await _dataPipe.Reader.ReadAsync();
 
-                    if (readResult.IsCompleted && _stream.Trailers?.Count > 0)
+                    if (readResult.IsCompleted && _stream.ResponseTrailers?.Count > 0)
                     {
                         // Output is ending and there are trailers to write
                         // Write any remaining content then write trailers
@@ -322,7 +322,8 @@ private async ValueTask<FlushResult> ProcessDataWrites()
                             flushResult = await _frameWriter.WriteDataAsync(_streamId, _flowControl, readResult.Buffer, endStream: false);
                         }
 
-                        flushResult = await _frameWriter.WriteResponseTrailers(_streamId, _stream.Trailers);
+                        _stream.ResponseTrailers.SetReadOnly();
+                        flushResult = await _frameWriter.WriteResponseTrailers(_streamId, _stream.ResponseTrailers);
                     }
                     else if (readResult.IsCompleted && _streamEnded)
                     {
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Stream.FeatureCollection.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Stream.FeatureCollection.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.Server.Kestrel.Core.Features;
@@ -11,21 +12,25 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
 {
     internal partial class Http2Stream : IHttp2StreamIdFeature,
                                          IHttpMinRequestBodyDataRateFeature,
+                                         IHttpResponseCompletionFeature,
                                          IHttpResponseTrailersFeature
 
     {
-        internal HttpResponseTrailers Trailers { get; set; }
         private IHeaderDictionary _userTrailers;
 
         IHeaderDictionary IHttpResponseTrailersFeature.Trailers
         {
             get
             {
-                if (Trailers == null)
+                if (ResponseTrailers == null)
                 {
-                    Trailers = new HttpResponseTrailers();
+                    ResponseTrailers = new HttpResponseTrailers();
+                    if (HasResponseCompleted)
+                    {
+                        ResponseTrailers.SetReadOnly();
+                    }
                 }
-                return _userTrailers ?? Trailers;
+                return _userTrailers ?? ResponseTrailers;
             }
             set
             {
@@ -48,5 +53,30 @@ MinDataRate IHttpMinRequestBodyDataRateFeature.MinDataRate
                 MinRequestBodyDataRate = value;
             }
         }
+
+        async Task IHttpResponseCompletionFeature.CompleteAsync()
+        {
+            // Finalize headers
+            if (!HasResponseStarted)
+            {
+                if (!VerifyResponseContentLength(out var lengthException))
+                {
+                    throw lengthException;
+                }
+
+                await InitializeResponseAsync(0, appCompleted: true);
+            }
+
+            // Flush headers, body, trailers...
+            if (!HasResponseCompleted)
+            {
+                if (!VerifyResponseContentLength(out var lengthException))
+                {
+                    throw lengthException;
+                }
+
+                await WriteSuffix();
+            }
+        }
     }
 }
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http2/Http2StreamTests.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http2/Http2StreamTests.cs
diff --git a/src/Servers/Kestrel/tools/CodeGenerator/HttpProtocolFeatureCollection.cs b/src/Servers/Kestrel/tools/CodeGenerator/HttpProtocolFeatureCollection.cs

Original file line number	Diff line number	Diff line change
`@@ -277,6 +277,7 @@ protected void ResetHttp1Features()`
`277`	`277`	`protected void ResetHttp2Features()`
`278`	`278`	`{`
`279`	`279`	`_currentIHttp2StreamIdFeature = this;`
	`280`	`+ _currentIHttpResponseCompletionFeature = this;`
`280`	`281`	`_currentIHttpResponseTrailersFeature = this;`
`281`	`282`	`}`
`282`	`283`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ internal partial class HttpProtocol : IFeatureCollection`
`29`	`29`	`private static readonly Type IFormFeatureType = typeof(IFormFeature);`
`30`	`30`	`private static readonly Type IHttpUpgradeFeatureType = typeof(IHttpUpgradeFeature);`
`31`	`31`	`private static readonly Type IHttp2StreamIdFeatureType = typeof(IHttp2StreamIdFeature);`
	`32`	`+ private static readonly Type IHttpResponseCompletionFeatureType = typeof(IHttpResponseCompletionFeature);`
`32`	`33`	`private static readonly Type IHttpResponseTrailersFeatureType = typeof(IHttpResponseTrailersFeature);`
`33`	`34`	`private static readonly Type IResponseCookiesFeatureType = typeof(IResponseCookiesFeature);`
`34`	`35`	`private static readonly Type IItemsFeatureType = typeof(IItemsFeature);`
`@@ -58,6 +59,7 @@ internal partial class HttpProtocol : IFeatureCollection`
`58`	`59`	`private object _currentIFormFeature;`
`59`	`60`	`private object _currentIHttpUpgradeFeature;`
`60`	`61`	`private object _currentIHttp2StreamIdFeature;`
	`62`	`+ private object _currentIHttpResponseCompletionFeature;`
`61`	`63`	`private object _currentIHttpResponseTrailersFeature;`
`62`	`64`	`private object _currentIResponseCookiesFeature;`
`63`	`65`	`private object _currentIItemsFeature;`
`@@ -98,6 +100,7 @@ private void FastReset()`
`98`	`100`	`_currentIQueryFeature = null;`
`99`	`101`	`_currentIFormFeature = null;`
`100`	`102`	`_currentIHttp2StreamIdFeature = null;`
	`103`	`+ _currentIHttpResponseCompletionFeature = null;`
`101`	`104`	`_currentIHttpResponseTrailersFeature = null;`
`102`	`105`	`_currentIResponseCookiesFeature = null;`
`103`	`106`	`_currentIItemsFeature = null;`
`@@ -224,6 +227,10 @@ object IFeatureCollection.this[Type key]`
`224`	`227`	`{`
`225`	`228`	`feature = _currentIHttp2StreamIdFeature;`
`226`	`229`	`}`
	`230`	`+ else if (key == IHttpResponseCompletionFeatureType)`
	`231`	`+ {`
	`232`	`+ feature = _currentIHttpResponseCompletionFeature;`
	`233`	`+ }`
`227`	`234`	`else if (key == IHttpResponseTrailersFeatureType)`
`228`	`235`	`{`
`229`	`236`	`feature = _currentIHttpResponseTrailersFeature;`
`@@ -348,6 +355,10 @@ object IFeatureCollection.this[Type key]`
`348`	`355`	`{`
`349`	`356`	`_currentIHttp2StreamIdFeature = value;`
`350`	`357`	`}`
	`358`	`+ else if (key == IHttpResponseCompletionFeatureType)`
	`359`	`+ {`
	`360`	`+ _currentIHttpResponseCompletionFeature = value;`
	`361`	`+ }`
`351`	`362`	`else if (key == IHttpResponseTrailersFeatureType)`
`352`	`363`	`{`
`353`	`364`	`_currentIHttpResponseTrailersFeature = value;`
`@@ -470,6 +481,10 @@ TFeature IFeatureCollection.Get<TFeature>()`
`470`	`481`	`{`
`471`	`482`	`feature = (TFeature)_currentIHttp2StreamIdFeature;`
`472`	`483`	`}`
	`484`	`+ else if (typeof(TFeature) == typeof(IHttpResponseCompletionFeature))`
	`485`	`+ {`
	`486`	`+ feature = (TFeature)_currentIHttpResponseCompletionFeature;`
	`487`	`+ }`
`473`	`488`	`else if (typeof(TFeature) == typeof(IHttpResponseTrailersFeature))`
`474`	`489`	`{`
`475`	`490`	`feature = (TFeature)_currentIHttpResponseTrailersFeature;`
`@@ -598,6 +613,10 @@ void IFeatureCollection.Set<TFeature>(TFeature feature)`
`598`	`613`	`{`
`599`	`614`	`_currentIHttp2StreamIdFeature = feature;`
`600`	`615`	`}`
	`616`	`+ else if (typeof(TFeature) == typeof(IHttpResponseCompletionFeature))`
	`617`	`+ {`
	`618`	`+ _currentIHttpResponseCompletionFeature = feature;`
	`619`	`+ }`
`601`	`620`	`else if (typeof(TFeature) == typeof(IHttpResponseTrailersFeature))`
`602`	`621`	`{`
`603`	`622`	`_currentIHttpResponseTrailersFeature = feature;`
`@@ -718,6 +737,10 @@ private IEnumerable<KeyValuePair<Type, object>> FastEnumerable()`
`718`	`737`	`{`
`719`	`738`	`yield return new KeyValuePair<Type, object>(IHttp2StreamIdFeatureType, _currentIHttp2StreamIdFeature);`
`720`	`739`	`}`
	`740`	`+ if (_currentIHttpResponseCompletionFeature != null)`
	`741`	`+ {`
	`742`	`+ yield return new KeyValuePair<Type, object>(IHttpResponseCompletionFeatureType, _currentIHttpResponseCompletionFeature);`
	`743`	`+ }`
`721`	`744`	`if (_currentIHttpResponseTrailersFeature != null)`
`722`	`745`	`{`
`723`	`746`	`yield return new KeyValuePair<Type, object>(IHttpResponseTrailersFeatureType, _currentIHttpResponseTrailersFeature);`
Original file line number	Diff line number	Diff line change
`@@ -210,6 +210,7 @@ private void HttpVersionSetSlow(string value)`
`210`	`210`	`public bool RequestTrailersAvailable { get; set; }`
`211`	`211`	`public Stream RequestBody { get; set; }`
`212`	`212`	`public PipeReader RequestBodyPipeReader { get; set; }`
	`213`	`+ public HttpResponseTrailers ResponseTrailers { get; set; }`
`213`	`214`
`214`	`215`	`private int _statusCode;`
`215`	`216`	`public int StatusCode`
`@@ -287,7 +288,9 @@ public CancellationToken RequestAborted`
`287`	`288`
`288`	`289`	`public bool HasResponseStarted => _requestProcessingStatus >= RequestProcessingStatus.HeadersCommitted;`
`289`	`290`
`290`		`- public bool HasFlushedHeaders => _requestProcessingStatus == RequestProcessingStatus.HeadersFlushed;`
	`291`	`+ public bool HasFlushedHeaders => _requestProcessingStatus >= RequestProcessingStatus.HeadersFlushed;`
	`292`	`+`
	`293`	`+ public bool HasResponseCompleted => _requestProcessingStatus == RequestProcessingStatus.ResponseCompleted;`
`291`	`294`
`292`	`295`	`protected HttpRequestHeaders HttpRequestHeaders { get; }`
`293`	`296`
`@@ -632,9 +635,9 @@ private async Task ProcessRequests<TContext>(IHttpApplication<TContext> applicat`
`632`	`635`	`// Run the application code for this request`
`633`	`636`	`await application.ProcessRequestAsync(context);`
`634`	`637`
`635`		`- if (!_connectionAborted)`
	`638`	`+ if (!_connectionAborted && !VerifyResponseContentLength(out var lengthException))`
`636`	`639`	`{`
`637`		`- VerifyResponseContentLength();`
	`640`	`+ ReportApplicationError(lengthException);`
`638`	`641`	`}`
`639`	`642`	`}`
`640`	`643`	`catch (BadHttpRequestException ex)`
`@@ -898,7 +901,7 @@ private void CheckLastWrite()`
`898`	`901`	`}`
`899`	`902`	`}`
`900`	`903`
`901`		`- protected void VerifyResponseContentLength()`
	`904`	`+ protected bool VerifyResponseContentLength(out Exception ex)`
`902`	`905`	`{`
`903`	`906`	`var responseHeaders = HttpResponseHeaders;`
`904`	`907`
`@@ -915,9 +918,13 @@ protected void VerifyResponseContentLength()`
`915`	`918`	`_keepAlive = false;`
`916`	`919`	`}`
`917`	`920`
`918`		`- ReportApplicationError(new InvalidOperationException(`
`919`		`- CoreStrings.FormatTooFewBytesWritten(_responseBytesWritten, responseHeaders.ContentLength.Value)));`
	`921`	`+ ex = new InvalidOperationException(`
	`922`	`+ CoreStrings.FormatTooFewBytesWritten(_responseBytesWritten, responseHeaders.ContentLength.Value));`
	`923`	`+ return false;`
`920`	`924`	`}`
	`925`	`+`
	`926`	`+ ex = null;`
	`927`	`+ return true;`
`921`	`928`	`}`
`922`	`929`
`923`	`930`	`public void ProduceContinue()`
`@@ -935,7 +942,7 @@ public void ProduceContinue()`
`935`	`942`	`}`
`936`	`943`	`}`
`937`	`944`
`938`		`- public Task InitializeResponseAsync(int firstWriteByteCount)`
	`945`	`+ public Task InitializeResponseAsync(int firstWriteByteCount, bool appCompleted = false)`
`939`	`946`	`{`
`940`	`947`	`var startingTask = FireOnStarting();`
`941`	`948`	`// If return is Task.CompletedTask no awaiting is required`
`@@ -946,7 +953,7 @@ public Task InitializeResponseAsync(int firstWriteByteCount)`
`946`	`953`
`947`	`954`	`VerifyInitializeState(firstWriteByteCount);`
`948`	`955`
`949`		`- ProduceStart(appCompleted: false);`
	`956`	`+ ProduceStart(appCompleted: appCompleted);`
`950`	`957`
`951`	`958`	`return Task.CompletedTask;`
`952`	`959`	`}`
`@@ -1043,8 +1050,13 @@ protected Task ProduceEnd()`
`1043`	`1050`	`return WriteSuffix();`
`1044`	`1051`	`}`
`1045`	`1052`
`1046`		`- private Task WriteSuffix()`
	`1053`	`+ protected Task WriteSuffix()`
`1047`	`1054`	`{`
	`1055`	`+ if (HasResponseCompleted)`
	`1056`	`+ {`
	`1057`	`+ return Task.CompletedTask;`
	`1058`	`+ }`
	`1059`	`+`
`1048`	`1060`	`// _autoChunk should be checked after we are sure ProduceStart() has been called`
`1049`	`1061`	`// since ProduceStart() may set _autoChunk to true.`
`1050`	`1062`	`if (_autoChunk \|\| _httpVersion == Http.HttpVersion.Http2)`
`@@ -1064,7 +1076,7 @@ private Task WriteSuffix()`
`1064`	`1076`
`1065`	`1077`	`if (!HasFlushedHeaders)`
`1066`	`1078`	`{`
`1067`		`- _requestProcessingStatus = RequestProcessingStatus.HeadersFlushed;`
	`1079`	`+ _requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;`
`1068`	`1080`	`return FlushAsyncInternal();`
`1069`	`1081`	`}`
`1070`	`1082`
`@@ -1080,6 +1092,8 @@ private async Task WriteSuffixAwaited()`
`1080`	`1092`
`1081`	`1093`	`await Output.WriteStreamSuffixAsync();`
`1082`	`1094`
	`1095`	`+ _requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;`
	`1096`	`+`
`1083`	`1097`	`if (_keepAlive)`
`1084`	`1098`	`{`
`1085`	`1099`	`Log.ConnectionKeepAlive(ConnectionId);`
`@@ -1244,6 +1258,7 @@ private void SetErrorResponseHeaders(int statusCode)`
`1244`	`1258`
`1245`	`1259`	`var responseHeaders = HttpResponseHeaders;`
`1246`	`1260`	`responseHeaders.Reset();`
	`1261`	`+ ResponseTrailers?.Reset();`
`1247`	`1262`	`var dateHeaderValues = DateHeaderValueManager.GetDateHeaderValues();`
`1248`	`1263`
`1249`	`1264`	`responseHeaders.SetRawDate(dateHeaderValues.String, dateHeaderValues.Bytes);`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ internal enum RequestProcessingStatus`
`10`	`10`	`ParsingHeaders,`
`11`	`11`	`AppStarted,`
`12`	`12`	`HeadersCommitted,`
`13`		`- HeadersFlushed`
	`13`	`+ HeadersFlushed,`
	`14`	`+ ResponseCompleted`
`14`	`15`	`}`
`15`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ public void WriteResponseHeaders(int statusCode, string ReasonPhrase, HttpRespon`
`151`	`151`	`// 2. There is no trailing HEADERS frame.`
`152`	`152`	`Http2HeadersFrameFlags http2HeadersFrame;`
`153`	`153`
`154`		`- if (appCompleted && !_startedWritingDataFrames && (_stream.Trailers == null \|\| _stream.Trailers.Count == 0))`
	`154`	`+ if (appCompleted && !_startedWritingDataFrames && (_stream.ResponseTrailers == null \|\| _stream.ResponseTrailers.Count == 0))`
`155`	`155`	`{`
`156`	`156`	`_streamEnded = true;`
`157`	`157`	`http2HeadersFrame = Http2HeadersFrameFlags.END_STREAM;`
`@@ -313,7 +313,7 @@ private async ValueTask<FlushResult> ProcessDataWrites()`
`313`	`313`	`{`
`314`	`314`	`readResult = await _dataPipe.Reader.ReadAsync();`
`315`	`315`
`316`		`- if (readResult.IsCompleted && _stream.Trailers?.Count > 0)`
	`316`	`+ if (readResult.IsCompleted && _stream.ResponseTrailers?.Count > 0)`
`317`	`317`	`{`
`318`	`318`	`// Output is ending and there are trailers to write`
`319`	`319`	`// Write any remaining content then write trailers`
`@@ -322,7 +322,8 @@ private async ValueTask<FlushResult> ProcessDataWrites()`
`322`	`322`	`flushResult = await _frameWriter.WriteDataAsync(_streamId, _flowControl, readResult.Buffer, endStream: false);`
`323`	`323`	`}`
`324`	`324`
`325`		`- flushResult = await _frameWriter.WriteResponseTrailers(_streamId, _stream.Trailers);`
	`325`	`+ _stream.ResponseTrailers.SetReadOnly();`
	`326`	`+ flushResult = await _frameWriter.WriteResponseTrailers(_streamId, _stream.ResponseTrailers);`
`326`	`327`	`}`
`327`	`328`	`else if (readResult.IsCompleted && _streamEnded)`
`328`	`329`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
	`5`	`+using System.Threading.Tasks;`
`5`	`6`	`using Microsoft.AspNetCore.Http;`
`6`	`7`	`using Microsoft.AspNetCore.Http.Features;`
`7`	`8`	`using Microsoft.AspNetCore.Server.Kestrel.Core.Features;`
`@@ -11,21 +12,25 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2`
`11`	`12`	`{`
`12`	`13`	`internal partial class Http2Stream : IHttp2StreamIdFeature,`
`13`	`14`	`IHttpMinRequestBodyDataRateFeature,`
	`15`	`+ IHttpResponseCompletionFeature,`
`14`	`16`	`IHttpResponseTrailersFeature`
`15`	`17`
`16`	`18`	`{`
`17`		`- internal HttpResponseTrailers Trailers { get; set; }`
`18`	`19`	`private IHeaderDictionary _userTrailers;`
`19`	`20`
`20`	`21`	`IHeaderDictionary IHttpResponseTrailersFeature.Trailers`
`21`	`22`	`{`
`22`	`23`	`get`
`23`	`24`	`{`
`24`		`- if (Trailers == null)`
	`25`	`+ if (ResponseTrailers == null)`
`25`	`26`	`{`
`26`		`- Trailers = new HttpResponseTrailers();`
	`27`	`+ ResponseTrailers = new HttpResponseTrailers();`
	`28`	`+ if (HasResponseCompleted)`
	`29`	`+ {`
	`30`	`+ ResponseTrailers.SetReadOnly();`
	`31`	`+ }`
`27`	`32`	`}`
`28`		`- return _userTrailers ?? Trailers;`
	`33`	`+ return _userTrailers ?? ResponseTrailers;`
`29`	`34`	`}`
`30`	`35`	`set`
`31`	`36`	`{`
`@@ -48,5 +53,30 @@ MinDataRate IHttpMinRequestBodyDataRateFeature.MinDataRate`
`48`	`53`	`MinRequestBodyDataRate = value;`
`49`	`54`	`}`
`50`	`55`	`}`
	`56`	`+`
	`57`	`+ async Task IHttpResponseCompletionFeature.CompleteAsync()`
	`58`	`+ {`
	`59`	`+ // Finalize headers`
	`60`	`+ if (!HasResponseStarted)`
	`61`	`+ {`
	`62`	`+ if (!VerifyResponseContentLength(out var lengthException))`
	`63`	`+ {`
	`64`	`+ throw lengthException;`
	`65`	`+ }`
	`66`	`+`
	`67`	`+ await InitializeResponseAsync(0, appCompleted: true);`
	`68`	`+ }`
	`69`	`+`
	`70`	`+ // Flush headers, body, trailers...`
	`71`	`+ if (!HasResponseCompleted)`
	`72`	`+ {`
	`73`	`+ if (!VerifyResponseContentLength(out var lengthException))`
	`74`	`+ {`
	`75`	`+ throw lengthException;`
	`76`	`+ }`
	`77`	`+`
	`78`	`+ await WriteSuffix();`
	`79`	`+ }`
	`80`	`+ }`
`51`	`81`	`}`
`52`	`82`	`}`