Map HttpStatusCode to gRPC status code (#575)

Author: JamesNK

src/Grpc.Net.Client/Internal/GrpcCall.cs

@@ -237,9 +237,17 @@ public Task<TResponse> GetResponseAsync()
         {
             Log.ResponseHeadersReceived(Logger);
 
+            // gRPC status can be returned in the header when there is no message (e.g. unimplemented status)
+            // An explicitly specified status header has priority over other failing statuses
+            if (GrpcProtocolHelpers.TryGetStatusCore(httpResponse.Headers, out var status))
+            {
+                return status;
+            }
+
             if (httpResponse.StatusCode != HttpStatusCode.OK)
             {
-                return new Status(StatusCode.Cancelled, "Bad gRPC response. Expected HTTP status code 200. Got status code: " + (int)httpResponse.StatusCode);
+                var statusCode = MapHttpStatusToGrpcCode(httpResponse.StatusCode);
+                return new Status(statusCode, "Bad gRPC response. HTTP status code: " + (int)httpResponse.StatusCode);
             }
 
             if (httpResponse.Content?.Headers.ContentType == null)
@@ -252,19 +260,40 @@ public Task<TResponse> GetResponseAsync()
             {
                 return new Status(StatusCode.Cancelled, "Bad gRPC response. Invalid content-type value: " + grpcEncoding);
             }
-            else
-            {
-                // gRPC status can be returned in the header when there is no message (e.g. unimplemented status)
-                if (GrpcProtocolHelpers.TryGetStatusCore(httpResponse.Headers, out var status))
-                {
-                    return status;
-                }
-            }
 
             // Call is still in progress
             return null;
         }
 
+        private static StatusCode MapHttpStatusToGrpcCode(HttpStatusCode httpStatusCode)
+        {
+            switch (httpStatusCode)
+            {
+                case HttpStatusCode.BadRequest:  // 400
+                case HttpStatusCode.RequestHeaderFieldsTooLarge: // 431
+                    return StatusCode.Internal;
+                case HttpStatusCode.Unauthorized:  // 401
+                    return StatusCode.Unauthenticated;
+                case HttpStatusCode.Forbidden:  // 403
+                    return StatusCode.PermissionDenied;
+                case HttpStatusCode.NotFound:  // 404
+                    return StatusCode.Unimplemented;
+                case HttpStatusCode.TooManyRequests:  // 429
+                case HttpStatusCode.BadGateway:  // 502
+                case HttpStatusCode.ServiceUnavailable:  // 503
+                case HttpStatusCode.GatewayTimeout:  // 504
+                    return StatusCode.Unavailable;
+                default:
+                    if ((int)httpStatusCode >= 100 && (int)httpStatusCode < 200)
+                    {
+                        // 1xx. These headers should have been ignored.
+                        return StatusCode.Internal;
+                    }
+
+                    return StatusCode.Unknown;
+            }
+        }
+
         public Metadata GetTrailers()
         {
             using (StartScope())

test/FunctionalTests/Client/CancellationTests.cs

@@ -228,6 +228,15 @@ async Task ServerStreamingCall(DataMessage request, IServerStreamWriter<DataMess
                     return true;
                 }
 
+                // Cancellation happened after checking token but before writing message
+                if (writeContext.LoggerName == "Grpc.AspNetCore.Server.ServerCallHandler" &&
+                    writeContext.EventId.Name == "ErrorExecutingServiceMethod" &&
+                    writeContext.Exception is InvalidOperationException &&
+                    writeContext.Exception.Message == "Cannot write message after request is complete.")
+                {
+                    return true;
+                }
+
                 if (writeContext.LoggerName == "Grpc.Net.Client.Internal.GrpcCall" &&
                     writeContext.EventId.Name == "GrpcStatusError" &&
                     writeContext.Message == "Call failed with gRPC error status. Status code: 'Cancelled', Message: 'Call canceled by the client.'.")

test/Grpc.Net.Client.Tests/AsyncServerStreamingCallTests.cs

@@ -166,8 +166,8 @@ public async Task ClientStreamReader_WriteWithInvalidHttpStatus_ErrorThrown()
             // Assert
             var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseStream.MoveNext(CancellationToken.None)).DefaultTimeout();
 
-            Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
-            Assert.AreEqual("Bad gRPC response. Expected HTTP status code 200. Got status code: 404", ex.Status.Detail);
+            Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
+            Assert.AreEqual("Bad gRPC response. HTTP status code: 404", ex.Status.Detail);
         }
 
         [Test]

test/Grpc.Net.Client.Tests/GetStatusTests.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Net;
+using System.Net.Http;
 using System.Threading.Tasks;
 using Greet;
 using Grpc.Core;
@@ -31,6 +32,63 @@ namespace Grpc.Net.Client.Tests
     [TestFixture]
     public class GetStatusTests
     {
+        [TestCase(HttpStatusCode.BadRequest, StatusCode.Internal)]
+        [TestCase(HttpStatusCode.RequestHeaderFieldsTooLarge, StatusCode.Internal)]
+        [TestCase(HttpStatusCode.Unauthorized, StatusCode.Unauthenticated)]
+        [TestCase(HttpStatusCode.Forbidden, StatusCode.PermissionDenied)]
+        [TestCase(HttpStatusCode.NotFound, StatusCode.Unimplemented)]
+        [TestCase(HttpStatusCode.TooManyRequests, StatusCode.Unavailable)]
+        [TestCase(HttpStatusCode.BadGateway, StatusCode.Unavailable)]
+        [TestCase(HttpStatusCode.ServiceUnavailable, StatusCode.Unavailable)]
+        [TestCase(HttpStatusCode.GatewayTimeout, StatusCode.Unavailable)]
+        [TestCase(HttpStatusCode.Continue, StatusCode.Internal)]
+        [TestCase(HttpStatusCode.UpgradeRequired, StatusCode.Unknown)]
+        public async Task AsyncUnaryCall_Non200HttpStatusCode_MappedToGrpcStatusCode(HttpStatusCode httpStatusCode, StatusCode statusCode)
+        {
+            // Arrange
+            var httpClient = ClientTestHelpers.CreateTestClient(request =>
+            {
+                var response = new HttpResponseMessage { StatusCode = httpStatusCode };
+                return Task.FromResult(response);
+            });
+            var invoker = HttpClientCallInvokerFactory.Create(httpClient);
+
+            // Act
+            var call = invoker.AsyncUnaryCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
+
+            // Assert
+            var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync).DefaultTimeout();
+            Assert.AreEqual(statusCode, ex.StatusCode);
+
+            var status = call.GetStatus();
+            Assert.AreEqual(statusCode, status.StatusCode);
+            Assert.AreEqual("Bad gRPC response. HTTP status code: " + (int)httpStatusCode, status.Detail);
+        }
+
+        [Test]
+        public async Task AsyncUnaryCall_Non200HttpStatusCodeWithGrpcStatusCode_GrpcStatusCodeTakesPriority()
+        {
+            // Arrange
+            var httpClient = ClientTestHelpers.CreateTestClient(request =>
+            {
+                var response = new HttpResponseMessage { StatusCode = HttpStatusCode.Continue };
+                response.Headers.Add(GrpcProtocolConstants.StatusTrailer, StatusCode.DataLoss.ToString("D"));
+                return Task.FromResult(response);
+            });
+            var invoker = HttpClientCallInvokerFactory.Create(httpClient);
+
+            // Act
+            var call = invoker.AsyncUnaryCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
+
+            // Assert
+            var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync).DefaultTimeout();
+            Assert.AreEqual(StatusCode.DataLoss, ex.StatusCode);
+
+            var status = call.GetStatus();
+            Assert.AreEqual(StatusCode.DataLoss, status.StatusCode);
+            Assert.AreEqual(null, status.Detail);
+        }
+
         [Test]
         public async Task AsyncUnaryCall_ValidStatusReturned_ReturnsStatus()
         {

test/Grpc.Net.Client.Tests/ResponseAsyncTests.cs

@@ -157,8 +157,8 @@ public async Task AsyncClientStreamingCall_NotFoundStatus_ThrowsError()
             var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync).DefaultTimeout();
 
             // Assert
-            Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
-            Assert.AreEqual("Bad gRPC response. Expected HTTP status code 200. Got status code: 404", ex.Status.Detail);
+            Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
+            Assert.AreEqual("Bad gRPC response. HTTP status code: 404", ex.Status.Detail);
         }
 
         [Test]