Refactor deadline to apply more gracefully

perf/Grpc.AspNetCore.Microbenchmarks/DeadlineUnaryServerCallHandlerBenchmark.cs

@@ -0,0 +1,39 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Grpc.AspNetCore.Server.Internal;
+using Microsoft.AspNetCore.Http;
+
+namespace Grpc.AspNetCore.Microbenchmarks
+{
+    public class DeadlineUnaryServerCallHandlerBenchmark : UnaryServerCallHandlerBenchmarkBase
+    {
+        protected override void ConfigureHttpContext(DefaultHttpContext httpContext)
+        {
+            httpContext.Request.Headers[GrpcProtocolConstants.TimeoutHeader] = "1H";
+        }
+
+        [Benchmark]
+        public Task DeadlineHandleCallAsync()
+        {
+            return InvokeUnaryRequestAsync();
+        }
+    }
+}

perf/Grpc.AspNetCore.Microbenchmarks/Program.cs

@@ -16,6 +16,8 @@
 
 #endregion
 
+using System;
+using System.Threading.Tasks;
 using BenchmarkDotNet.Running;
 
 namespace Grpc.AspNetCore.Microbenchmarks
@@ -31,18 +33,19 @@ static void Main(string[] args)
         // Profiling option. This will call methods explicitly, in-process
         static async Task Main(string[] args)
         {
-            UnaryServerCallHandlerBenchmark benchmark = new UnaryServerCallHandlerBenchmark();
+            var benchmark = new DeadlineUnaryServerCallHandlerBenchmark();
             benchmark.GlobalSetup();
-            for (int i = 0; i < 100; i++)
+            Console.WriteLine("Warming up.");
+            for (int i = 0; i < 100000; i++)
             {
-                await benchmark.HandleCallAsync();
+                await benchmark.DeadlineHandleCallAsync();
             }
 
             Console.WriteLine("Press any key to start.");
             Console.ReadKey();
             for (int i = 0; i < 1; i++)
             {
-                await benchmark.HandleCallAsync();
+                await benchmark.DeadlineHandleCallAsync();
             }
 
             Console.WriteLine("Done. Press any key to exit.");

perf/Grpc.AspNetCore.Microbenchmarks/UnaryServerCallHandlerBenchmarkBase.cs

@@ -16,6 +16,7 @@
 
 #endregion
 
+using System;
 using System.Buffers;
 using System.IO;
 using System.IO.Pipelines;
@@ -88,6 +89,11 @@ public void GlobalSetup()
             {
                 Trailers = _trailers
             });
+            ConfigureHttpContext(_httpContext);
+        }
+
+        protected virtual void ConfigureHttpContext(DefaultHttpContext httpContext)
+        {
         }
 
         protected Task InvokeUnaryRequestAsync()

src/Grpc.AspNetCore.Server/Internal/CallHandlers/ClientStreamingServerCallHandler.cs

@@ -71,67 +71,48 @@ public ClientStreamingServerCallHandler(
             }
         }
 
-        protected override async Task HandleCallAsyncCore(HttpContext httpContext)
+        protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
         {
             // Disable request body data rate for client streaming
             DisableMinRequestBodyDataRate(httpContext);
 
-            var serverCallContext = CreateServerCallContext(httpContext);
-
-            GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response);
-
             TResponse? response = null;
 
-            try
+            if (_pipelineInvoker == null)
             {
-                serverCallContext.Initialize();
-
-                if (_pipelineInvoker == null)
+                var activator = httpContext.RequestServices.GetRequiredService<IGrpcServiceActivator<TService>>();
+                TService? service = null;
+                try
                 {
-                    var activator = httpContext.RequestServices.GetRequiredService<IGrpcServiceActivator<TService>>();
-                    TService? service = null;
-                    try
-                    {
-                        service = activator.Create();
-                        response = await _invoker(
-                            service,
-                            new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
-                            serverCallContext);
-                    }
-                    finally
-                    {
-                        if (service != null)
-                        {
-                            activator.Release(service);
-                        }
-                    }
-                }
-                else
-                {
-                    response = await _pipelineInvoker(
+                    service = activator.Create();
+                    response = await _invoker(
+                        service,
                         new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
                         serverCallContext);
                 }
-
-                if (response == null)
+                finally
                 {
-                    // This is consistent with Grpc.Core when a null value is returned
-                    throw new RpcException(new Status(StatusCode.Cancelled, "No message returned from method."));
+                    if (service != null)
+                    {
+                        activator.Release(service);
+                    }
                 }
-
-                var responseBodyWriter = httpContext.Response.BodyWriter;
-                await responseBodyWriter.WriteMessageAsync(response, serverCallContext, Method.ResponseMarshaller.Serializer);
-
-                await serverCallContext.EndCallAsync();
             }
-            catch (Exception ex)
+            else
             {
-                serverCallContext.ProcessHandlerError(ex, Method.Name);
+                response = await _pipelineInvoker(
+                    new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
+                    serverCallContext);
             }
-            finally
+
+            if (response == null)
             {
-                serverCallContext.Dispose();
+                // This is consistent with Grpc.Core when a null value is returned
+                throw new RpcException(new Status(StatusCode.Cancelled, "No message returned from method."));
             }
+
+            var responseBodyWriter = httpContext.Response.BodyWriter;
+            await responseBodyWriter.WriteMessageAsync(response, serverCallContext, Method.ResponseMarshaller.Serializer);
         }
     }
 }

src/Grpc.AspNetCore.Server/Internal/CallHandlers/DuplexStreamingServerCallHandler.cs

@@ -72,57 +72,38 @@ await _invoker(
             }
         }
 
-        protected override async Task HandleCallAsyncCore(HttpContext httpContext)
+        protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
         {
             // Disable request body data rate for client streaming
             DisableMinRequestBodyDataRate(httpContext);
 
-            var serverCallContext = CreateServerCallContext(httpContext);
-
-            GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response);
-
-            try
+            if (_pipelineInvoker == null)
             {
-                serverCallContext.Initialize();
-
-                if (_pipelineInvoker == null)
-                {
-                    var activator = httpContext.RequestServices.GetRequiredService<IGrpcServiceActivator<TService>>();
-                    TService? service = null;
-                    try
-                    {
-                        service = activator.Create();
-                        await _invoker(
-                            service,
-                            new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
-                            new HttpContextStreamWriter<TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer),
-                            serverCallContext);
-                    }
-                    finally
-                    {
-                        if (service != null)
-                        {
-                            activator.Release(service);
-                        }
-                    }
-                }
-                else
+                var activator = httpContext.RequestServices.GetRequiredService<IGrpcServiceActivator<TService>>();
+                TService? service = null;
+                try
                 {
-                    await _pipelineInvoker(
+                    service = activator.Create();
+                    await _invoker(
+                        service,
                         new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
                         new HttpContextStreamWriter<TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer),
                         serverCallContext);
                 }
-
-                await serverCallContext.EndCallAsync();
-            }
-            catch (Exception ex)
-            {
-                serverCallContext.ProcessHandlerError(ex, Method.Name);
+                finally
+                {
+                    if (service != null)
+                    {
+                        activator.Release(service);
+                    }
+                }
             }
-            finally
+            else
             {
-                serverCallContext.Dispose();
+                await _pipelineInvoker(
+                    new HttpContextStreamReader<TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer),
+                    new HttpContextStreamWriter<TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer),
+                    serverCallContext);
             }
         }
     }