From 5c0d5a9685d74bb603fee42bbbb7ac55d44dfb88 Mon Sep 17 00:00:00 2001 From: Safia Abdalla Date: Mon, 8 May 2023 11:42:36 -0700 Subject: [PATCH 1/2] Don't generate RequestBody for parameters when disabledInferredBody is true (#47659) (#47807) --- src/OpenApi/src/OpenApiGenerator.cs | 6 +++--- src/OpenApi/test/OpenApiGeneratorTests.cs | 12 ++++++++++++ 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/src/OpenApi/src/OpenApiGenerator.cs b/src/OpenApi/src/OpenApiGenerator.cs index 86e7e46720ac..0274b7a26cb8 100644 --- a/src/OpenApi/src/OpenApiGenerator.cs +++ b/src/OpenApi/src/OpenApiGenerator.cs @@ -78,7 +78,7 @@ private OpenApiOperation GetOperation(string httpMethod, MethodInfo methodInfo, Description = metadata.GetMetadata()?.Description, Tags = GetOperationTags(methodInfo, metadata), Parameters = GetOpenApiParameters(methodInfo, pattern, disableInferredBody), - RequestBody = GetOpenApiRequestBody(methodInfo, metadata, pattern), + RequestBody = GetOpenApiRequestBody(methodInfo, metadata, pattern, disableInferredBody), Responses = GetOpenApiResponses(methodInfo, metadata) }; @@ -251,7 +251,7 @@ private static void GenerateDefaultResponses(Dictionary ""), "headerName"); } + [Fact] + public void DoesNotGenerateRequestBodyWhenInferredBodyDisabled() + { + var operation = GetOpenApiOperation((string[] names) => { }, httpMethods: new[] { "GET" }); + + var parameter = Assert.Single(operation.Parameters); + + Assert.Equal("names", parameter.Name); + Assert.Equal(ParameterLocation.Query, parameter.In); + Assert.Null(operation.RequestBody); + } + private static OpenApiOperation GetOpenApiOperation( Delegate action, string pattern = null, From 764a98deaad6ea4bbcc53c225bdca64bd2f37a0e Mon Sep 17 00:00:00 2001 From: Marc Gravell Date: Mon, 8 May 2023 19:43:37 +0100 Subject: [PATCH 2/2] http.sys (7.0 backport): new option for response buffering (#48073) * backport kernel buffer mode to 7.0 * Update src/Servers/HttpSys/src/HttpSysOptions.cs Co-authored-by: Aditya Mandaleeka --------- Co-authored-by: Aditya Mandaleeka --- src/Servers/HttpSys/src/HttpSysOptions.cs | 11 ++++++ .../HttpSys/src/RequestProcessing/Response.cs | 2 -- .../src/RequestProcessing/ResponseBody.cs | 9 +++++ .../test/FunctionalTests/ResponseBodyTests.cs | 35 +++++++++++++++++++ 4 files changed, 55 insertions(+), 2 deletions(-) diff --git a/src/Servers/HttpSys/src/HttpSysOptions.cs b/src/Servers/HttpSys/src/HttpSysOptions.cs index f5eded3da02b..4b1e21eba2ae 100644 --- a/src/Servers/HttpSys/src/HttpSysOptions.cs +++ b/src/Servers/HttpSys/src/HttpSysOptions.cs @@ -34,6 +34,8 @@ public class HttpSysOptions /// public HttpSysOptions() { + const string EnableKernelResponseBufferingSwitch = "Microsoft.AspNetCore.Server.HttpSys.EnableKernelResponseBuffering"; + EnableKernelResponseBuffering = AppContext.TryGetSwitch(EnableKernelResponseBufferingSwitch, out var enabled) && enabled; } /// @@ -108,6 +110,15 @@ public string? RequestQueueName /// public bool ThrowWriteExceptions { get; set; } + /// + /// Enable buffering of response data in the Kernel. + /// It should be used by an application doing synchronous I/O or by an application doing asynchronous I/O with + /// no more than one outstanding write at a time, and can significantly improve throughput over high-latency connections. + /// Applications that use asynchronous I/O and that may have more than one send outstanding at a time should not use this flag. + /// Enabling this can results in higher CPU and memory usage by Http.Sys. + /// + internal bool EnableKernelResponseBuffering { get; set; } // internal via app-context in pre-8.0 + /// /// Gets or sets the maximum number of concurrent connections to accept, -1 for infinite, or null to /// use the machine wide setting from the registry. The default value is null. diff --git a/src/Servers/HttpSys/src/RequestProcessing/Response.cs b/src/Servers/HttpSys/src/RequestProcessing/Response.cs index 602fa50db907..1cc3921cf01a 100644 --- a/src/Servers/HttpSys/src/RequestProcessing/Response.cs +++ b/src/Servers/HttpSys/src/RequestProcessing/Response.cs @@ -275,8 +275,6 @@ actual HTTP header will be generated by the application and sent as entity body. // This will give us more control of the bytes that hit the wire, including encodings, HTTP 1.0, etc.. // It may also be faster to do this work in managed code and then pass down only one buffer. // What would we loose by bypassing HttpSendHttpResponse? - // - // TODO: Consider using the HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA flag for most/all responses rather than just Opaque. internal unsafe uint SendHeaders(HttpApiTypes.HTTP_DATA_CHUNK[]? dataChunks, ResponseStreamAsyncResult? asyncResult, HttpApiTypes.HTTP_FLAGS flags, diff --git a/src/Servers/HttpSys/src/RequestProcessing/ResponseBody.cs b/src/Servers/HttpSys/src/RequestProcessing/ResponseBody.cs index 3d13b77386e5..d0de166d1fb9 100644 --- a/src/Servers/HttpSys/src/RequestProcessing/ResponseBody.cs +++ b/src/Servers/HttpSys/src/RequestProcessing/ResponseBody.cs @@ -39,6 +39,8 @@ internal RequestContext RequestContext internal bool ThrowWriteExceptions => RequestContext.Server.Options.ThrowWriteExceptions; + internal bool EnableKernelResponseBuffering => RequestContext.Server.Options.EnableKernelResponseBuffering; + internal bool IsDisposed => _disposed; public override bool CanSeek @@ -463,6 +465,13 @@ private HttpApiTypes.HTTP_FLAGS ComputeLeftToWrite(long writeCount, bool endOfRe { flags |= HttpApiTypes.HTTP_FLAGS.HTTP_SEND_RESPONSE_FLAG_MORE_DATA; } + if (EnableKernelResponseBuffering) + { + // "When this flag is set, it should also be used consistently in calls to the HttpSendResponseEntityBody function." + // so: make sure we add it in *all* scenarios where it applies - our "close" could be at the end of a bunch + // of buffered chunks + flags |= HttpApiTypes.HTTP_FLAGS.HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA; + } // Update _leftToWrite now so we can queue up additional async writes. if (_leftToWrite > 0) diff --git a/src/Servers/HttpSys/test/FunctionalTests/ResponseBodyTests.cs b/src/Servers/HttpSys/test/FunctionalTests/ResponseBodyTests.cs index 10aa943ae7b5..c6d6b1b16641 100644 --- a/src/Servers/HttpSys/test/FunctionalTests/ResponseBodyTests.cs +++ b/src/Servers/HttpSys/test/FunctionalTests/ResponseBodyTests.cs @@ -133,6 +133,41 @@ public async Task ResponseBody_WriteNoHeaders_SetsChunked() } } + [ConditionalTheory] + [InlineData(true)] + [InlineData(false)] + public async Task ResponseBody_WriteNoHeaders_SetsChunked_LargeBody(bool enableKernelBuffering) + { + const int WriteSize = 1024 * 1024; + const int NumWrites = 32; + + string address; + using (Utilities.CreateHttpServer( + baseAddress: out address, + configureOptions: options => { options.EnableKernelResponseBuffering = enableKernelBuffering; }, + app: async httpContext => + { + httpContext.Features.Get().AllowSynchronousIO = true; + for (int i = 0; i < NumWrites - 1; i++) + { + httpContext.Response.Body.Write(new byte[WriteSize], 0, WriteSize); + } + await httpContext.Response.Body.WriteAsync(new byte[WriteSize], 0, WriteSize); + })) + { + var response = await SendRequestAsync(address); + Assert.Equal(200, (int)response.StatusCode); + Assert.Equal(new Version(1, 1), response.Version); + IEnumerable ignored; + Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); + Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); + + var bytes = await response.Content.ReadAsByteArrayAsync(); + Assert.Equal(WriteSize * NumWrites, bytes.Length); + Assert.True(bytes.All(b => b == 0)); + } + } + [ConditionalFact] public async Task ResponseBody_WriteNoHeadersAndFlush_DefaultsToChunked() {