Add option to ignore calls to unknown gRPC services (#788)

Author: JamesNK

perf/benchmarkapps/GrpcAspNetCoreServer/Startup.cs

@@ -37,7 +37,11 @@ public class Startup
     {
         public void ConfigureServices(IServiceCollection services)
         {
-            services.AddGrpc();
+            services.AddGrpc(o =>
+            {
+                // Small performance benefits to not add catch-all routes to handle UNIMPLEMENTED for unknown services
+                o.IgnoreUnknownServices = true;
+            });
             services.AddControllers();
 
 #if CLIENT_CERTIFICATE_AUTHENTICATION

src/Grpc.AspNetCore.Server/GrpcServiceOptions.cs

@@ -74,6 +74,13 @@ public IList<ICompressionProvider> CompressionProviders
             set => _compressionProviders = value;
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether gRPC should ignore calls to unknown services and methods.
+        /// If set to <c>true</c>, calls to unknown services and methods won't return an 'UNIMPLEMENTED' status,
+        /// and the request will pass to the next registered middleware in ASP.NET Core.
+        /// </summary>
+        public bool? IgnoreUnknownServices { get; set; }
+
         /// <summary>
         /// Get a collection of interceptors to be executed with every call. Interceptors are executed in order.
         /// </summary>

src/Grpc.AspNetCore.Server/Internal/GrpcServiceOptionsSetup.cs

@@ -60,6 +60,7 @@ public void Configure(GrpcServiceOptions<TService> options)
             options.ResponseCompressionAlgorithm = _options.ResponseCompressionAlgorithm;
             options.ResponseCompressionLevel = _options.ResponseCompressionLevel;
             options.CompressionProviders = _options.CompressionProviders;
+            options.IgnoreUnknownServices = _options.IgnoreUnknownServices;
         }
     }
 }

src/Grpc.AspNetCore.Server/Internal/ServerCallHandlerFactory.cs

@@ -112,6 +112,9 @@ public RequestDelegate CreateUnimplementedMethod()
             };
         }
 
+        public bool IgnoreUnknownServices => _globalOptions.IgnoreUnknownServices ?? false;
+        public bool IgnoreUnknownMethods => _serviceOptions.IgnoreUnknownServices ?? false;
+
         public RequestDelegate CreateUnimplementedService()
         {
             var logger = _loggerFactory.CreateLogger<ServerCallHandlerFactory<TService>>();

src/Grpc.AspNetCore.Server/Model/Internal/ServiceRouteBuilder.cs

@@ -106,27 +106,30 @@ internal static void CreateUnimplementedEndpoints(
         {
             // Return UNIMPLEMENTED status for missing service:
             // - /{service}/{method} + content-type header = grpc/application
-            if (serviceMethodsRegistry.Methods.Count == 0)
+            if (!serverCallHandlerFactory.IgnoreUnknownServices && serviceMethodsRegistry.Methods.Count == 0)
             {
                 // Only one unimplemented service endpoint is needed for the application
                 CreateUnimplementedEndpoint(endpointRouteBuilder, "{unimplementedService}/{unimplementedMethod}", "Unimplemented service", serverCallHandlerFactory.CreateUnimplementedService());
             }
 
             // Return UNIMPLEMENTED status for missing method:
             // - /Package.Service/{method} + content-type header = grpc/application
-            var serviceNames = serviceMethods.Select(m => m.Method.ServiceName).Distinct();
-
-            // Typically there should be one service name for a type
-            // In case the bind method sets up multiple services in one call we'll loop over them
-            foreach (var serviceName in serviceNames)
+            if (!serverCallHandlerFactory.IgnoreUnknownMethods)
             {
-                if (serviceMethodsRegistry.Methods.Any(m => string.Equals(m.Method.ServiceName, serviceName, StringComparison.Ordinal)))
+                var serviceNames = serviceMethods.Select(m => m.Method.ServiceName).Distinct();
+
+                // Typically there should be one service name for a type
+                // In case the bind method sets up multiple services in one call we'll loop over them
+                foreach (var serviceName in serviceNames)
                 {
-                    // Only one unimplemented method endpoint is need for the service
-                    continue;
-                }
+                    if (serviceMethodsRegistry.Methods.Any(m => string.Equals(m.Method.ServiceName, serviceName, StringComparison.Ordinal)))
+                    {
+                        // Only one unimplemented method endpoint is need for the service
+                        continue;
+                    }
 
-                CreateUnimplementedEndpoint(endpointRouteBuilder, serviceName + "/{unimplementedMethod}", $"Unimplemented method for {serviceName}", serverCallHandlerFactory.CreateUnimplementedMethod());
+                    CreateUnimplementedEndpoint(endpointRouteBuilder, serviceName + "/{unimplementedMethod}", $"Unimplemented method for {serviceName}", serverCallHandlerFactory.CreateUnimplementedMethod());
+                }
             }
         }
 

test/FunctionalTests/Web/Client/ServerStreamingMethodTests.cs

@@ -154,6 +154,10 @@ public async Task SendValidRequest_ClientAbort_ClientThrowsCancelledException()
 
             Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode);
 
+            // It is possible get into a situation where the response stream finishes slightly before the call.
+            // Small delay to ensure call logging is complete.
+            await Task.Delay(50);
+
             AssertHasLog(LogLevel.Information, "GrpcStatusError", "Call failed with gRPC error status. Status code: 'Cancelled', Message: 'Call canceled by the client.'.");
         }
     }

test/Grpc.AspNetCore.Server.Tests/GrpcEndpointRouteBuilderExtensionsTests.cs

@@ -296,6 +296,69 @@ public void MapGrpcService_NoMatchingCompressionProvider_ThrowError()
             Assert.AreEqual("The configured response compression algorithm 'DOES_NOT_EXIST' does not have a matching compression provider.", ex.InnerException!.InnerException!.Message);
         }
 
+        [Test]
+        public void MapGrpcService_IgnoreUnknownServicesDefault_RegisterUnknownHandler()
+        {
+            // Arrange
+            var services = ServicesHelpers.CreateServices();
+
+            var routeBuilder = CreateTestEndpointRouteBuilder(services.BuildServiceProvider(validateScopes: true));
+
+            // Act
+            routeBuilder.MapGrpcService<GreeterServiceWithMetadataAttributes>();
+
+            // Assert
+            var endpoints = routeBuilder.DataSources
+                .SelectMany(ds => ds.Endpoints)
+                .ToList();
+
+            Assert.IsNotNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented service"));
+            Assert.IsNotNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented method for greet.Greeter"));
+        }
+
+        [Test]
+        public void MapGrpcService_IgnoreUnknownServicesGlobalTrue_DontRegisterUnknownHandler()
+        {
+            // Arrange
+            var services = ServicesHelpers.CreateServices(o => o.IgnoreUnknownServices = true);
+
+            var routeBuilder = CreateTestEndpointRouteBuilder(services.BuildServiceProvider(validateScopes: true));
+
+            // Act
+            routeBuilder.MapGrpcService<GreeterServiceWithMetadataAttributes>();
+
+            // Assert
+            var endpoints = routeBuilder.DataSources
+                .SelectMany(ds => ds.Endpoints)
+                .ToList();
+
+            Assert.IsNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented service"));
+            Assert.IsNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented method for GreeterServiceWithMetadataAttributes"));
+        }
+
+        [Test]
+        public void MapGrpcService_IgnoreUnknownServicesServiceTrue_DontRegisterUnknownHandler()
+        {
+            // Arrange
+            var services = ServicesHelpers.CreateServices(configureGrpcService: o =>
+            {
+                o.AddServiceOptions<GreeterServiceWithMetadataAttributes>(o => o.IgnoreUnknownServices = true);
+            });
+
+            var routeBuilder = CreateTestEndpointRouteBuilder(services.BuildServiceProvider(validateScopes: true));
+
+            // Act
+            routeBuilder.MapGrpcService<GreeterServiceWithMetadataAttributes>();
+
+            // Assert
+            var endpoints = routeBuilder.DataSources
+                .SelectMany(ds => ds.Endpoints)
+                .ToList();
+
+            Assert.IsNotNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented service"));
+            Assert.IsNull(endpoints.SingleOrDefault(e => e.DisplayName == "gRPC - Unimplemented method for GreeterServiceWithMetadataAttributes"));
+        }
+
         public IEndpointRouteBuilder CreateTestEndpointRouteBuilder(IServiceProvider serviceProvider)
         {
             return new TestEndpointRouteBuilder(serviceProvider);

test/Shared/ServicesHelpers.cs

@@ -24,11 +24,17 @@ namespace Grpc.Tests.Shared
 {
     internal static class ServicesHelpers
     {
-        public static ServiceCollection CreateServices(Action<GrpcServiceOptions>? configureGrpc = null)
+        public static ServiceCollection CreateServices(
+            Action<GrpcServiceOptions>? configureGrpc = null,
+            Action<IGrpcServerBuilder>? configureGrpcService = null)
         {
             var services = new ServiceCollection();
+
             services.AddLogging();
-            services.AddGrpc(configureGrpc ?? (o => { }));
+
+            var serverBuilder = services.AddGrpc(configureGrpc ?? (o => { }));
+            configureGrpcService?.Invoke(serverBuilder);
+
             return services;
         }
     }