Add short circuit in routing

src/Http/Routing/perf/Microbenchmarks/EndpointRoutingShortCircuitBenchmark.cs

@@ -0,0 +1,113 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using BenchmarkDotNet.Attributes;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing.Matching;
+using Microsoft.AspNetCore.Routing.ShortCircuit;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.Routing;
+
+public class EndpointRoutingShortCircuitBenchmark
+{
+    private EndpointRoutingMiddleware _normalEndpointMiddleware;
+    private EndpointRoutingMiddleware _shortCircuitEndpointMiddleware;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var normalEndpoint = new Endpoint(context => Task.CompletedTask, new EndpointMetadataCollection(), "normal");
+
+        _normalEndpointMiddleware = new EndpointRoutingMiddleware(
+            new BenchmarkMatcherFactory(normalEndpoint),
+            NullLogger<EndpointRoutingMiddleware>.Instance,
+            new BenchmarkEndpointRouteBuilder(),
+            new BenchmarkEndpointDataSource(),
+            new DiagnosticListener("benchmark"),
+            Options.Create(new RouteOptions()),
+            context => Task.CompletedTask);
+
+        var shortCircuitEndpoint = new Endpoint(context => Task.CompletedTask, new EndpointMetadataCollection(new ShortCircuitMetadata(200)), "shortcircuit");
+
+        _shortCircuitEndpointMiddleware = new EndpointRoutingMiddleware(
+            new BenchmarkMatcherFactory(shortCircuitEndpoint),
+            NullLogger<EndpointRoutingMiddleware>.Instance,
+            new BenchmarkEndpointRouteBuilder(),
+            new BenchmarkEndpointDataSource(),
+            new DiagnosticListener("benchmark"),
+            Options.Create(new RouteOptions()),
+            context => Task.CompletedTask);
+
+    }
+
+    [Benchmark]
+    public async Task NormalEndpoint()
+    {
+        var context = new DefaultHttpContext();
+        await _normalEndpointMiddleware.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task ShortCircuitEndpoint()
+    {
+        var context = new DefaultHttpContext();
+        await _shortCircuitEndpointMiddleware.Invoke(context);
+    }
+}
+
+internal class BenchmarkMatcherFactory : MatcherFactory
+{
+    private readonly Endpoint _endpoint;
+
+    public BenchmarkMatcherFactory(Endpoint endpoint)
+    {
+        _endpoint = endpoint;
+    }
+
+    public override Matcher CreateMatcher(EndpointDataSource dataSource)
+    {
+        return new BenchmarkMatcher(_endpoint);
+    }
+
+    internal class BenchmarkMatcher : Matcher
+    {
+        private Endpoint _endpoint;
+
+        public BenchmarkMatcher(Endpoint endpoint)
+        {
+            _endpoint = endpoint;
+        }
+
+        public override Task MatchAsync(HttpContext httpContext)
+        {
+            httpContext.SetEndpoint(_endpoint);
+            return Task.CompletedTask;
+        }
+    }
+}
+
+internal class BenchmarkEndpointRouteBuilder : IEndpointRouteBuilder
+{
+    public IServiceProvider ServiceProvider => throw new NotImplementedException();
+
+    public ICollection<EndpointDataSource> DataSources => new List<EndpointDataSource>();
+
+    public IApplicationBuilder CreateApplicationBuilder()
+    {
+        throw new NotImplementedException();
+    }
+}
+internal class BenchmarkEndpointDataSource : EndpointDataSource
+{
+    public override IReadOnlyList<Endpoint> Endpoints => throw new NotImplementedException();
+
+    public override IChangeToken GetChangeToken()
+    {
+        throw new NotImplementedException();
+    }
+}

src/Http/Routing/src/EndpointMiddleware.cs

@@ -33,6 +33,7 @@ public Task Invoke(HttpContext httpContext)
         var endpoint = httpContext.GetEndpoint();
         if (endpoint is not null)
         {
+            // This check should be kept in sync with the one in EndpointRoutingMiddleware
             if (!_routeOptions.SuppressCheckForUnhandledSecurityMetadata)
             {
                 if (endpoint.Metadata.GetMetadata<IAuthorizeData>() is not null &&

src/Http/Routing/src/EndpointRoutingMiddleware.cs

@@ -4,9 +4,13 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors.Infrastructure;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing.Matching;
+using Microsoft.AspNetCore.Routing.ShortCircuit;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.AspNetCore.Routing;
 
@@ -19,7 +23,7 @@ internal sealed partial class EndpointRoutingMiddleware
     private readonly EndpointDataSource _endpointDataSource;
     private readonly DiagnosticListener _diagnosticListener;
     private readonly RequestDelegate _next;
-
+    private readonly RouteOptions _routeOptions;
     private Task<Matcher>? _initializationTask;
 
     public EndpointRoutingMiddleware(
@@ -28,6 +32,7 @@ public EndpointRoutingMiddleware(
         IEndpointRouteBuilder endpointRouteBuilder,
         EndpointDataSource rootCompositeEndpointDataSource,
         DiagnosticListener diagnosticListener,
+        IOptions<RouteOptions> routeOptions,
         RequestDelegate next)
     {
         ArgumentNullException.ThrowIfNull(endpointRouteBuilder);
@@ -36,6 +41,7 @@ public EndpointRoutingMiddleware(
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _diagnosticListener = diagnosticListener ?? throw new ArgumentNullException(nameof(diagnosticListener));
         _next = next ?? throw new ArgumentNullException(nameof(next));
+        _routeOptions = routeOptions.Value;
 
         // rootCompositeEndpointDataSource is a constructor parameter only so it always gets disposed by DI. This ensures that any
         // disposable EndpointDataSources also get disposed. _endpointDataSource is a component of rootCompositeEndpointDataSource.
@@ -102,6 +108,12 @@ private Task SetRoutingAndContinue(HttpContext httpContext)
             }
 
             Log.MatchSuccess(_logger, endpoint);
+
+            var shortCircuitMetadata = endpoint.Metadata.GetMetadata<ShortCircuitMetadata>();
+            if (shortCircuitMetadata is not null)
+            {
+                return ExecuteShortCircuit(shortCircuitMetadata, endpoint, httpContext);
+            }
         }
 
         return _next(httpContext);
@@ -115,6 +127,75 @@ static void Write(DiagnosticListener diagnosticListener, HttpContext httpContext
         }
     }
 
+    private Task ExecuteShortCircuit(ShortCircuitMetadata shortCircuitMetadata, Endpoint endpoint, HttpContext httpContext)
+    {
+        // This check should be kept in sync with the one in EndpointMiddleware
+        if (!_routeOptions.SuppressCheckForUnhandledSecurityMetadata)
+        {
+            if (endpoint.Metadata.GetMetadata<IAuthorizeData>() is not null)
+            {
+                ThrowCannotShortCircuitAnAuthRouteException(endpoint);
+            }
+
+            if (endpoint.Metadata.GetMetadata<ICorsMetadata>() is not null)
+            {
+                ThrowCannotShortCircuitACorsRouteException(endpoint);
+            }
+        }
+
+        if (shortCircuitMetadata.StatusCode.HasValue)
+        {
+            httpContext.Response.StatusCode = shortCircuitMetadata.StatusCode.Value;
+        }
+
+        if (endpoint.RequestDelegate is not null)
+        {
+            if (!_logger.IsEnabled(LogLevel.Information))
+            {
+                // Avoid the AwaitRequestTask state machine allocation if logging is disabled.
+                return endpoint.RequestDelegate(httpContext);
+            }
+
+            Log.ExecutingEndpoint(_logger, endpoint);
+
+            try
+            {
+                var requestTask = endpoint.RequestDelegate(httpContext);
+                if (!requestTask.IsCompletedSuccessfully)
+                {
+                    return AwaitRequestTask(endpoint, requestTask, _logger);
+                }
+            }
+            catch
+            {
+                Log.ExecutedEndpoint(_logger, endpoint);
+                throw;
+            }
+
+            Log.ExecutedEndpoint(_logger, endpoint);
+
+            return Task.CompletedTask;
+
+            static async Task AwaitRequestTask(Endpoint endpoint, Task requestTask, ILogger logger)
+            {
+                try
+                {
+                    await requestTask;
+                }
+                finally
+                {
+                    Log.ExecutedEndpoint(logger, endpoint);
+                }
+            }
+
+        }
+        else
+        {
+            Log.ShortCircuitedEndpoint(_logger, endpoint);
+        }
+        return Task.CompletedTask;
+    }
+
     // Initialization is async to avoid blocking threads while reflection and things
     // of that nature take place.
     //
@@ -165,6 +246,18 @@ private Task<Matcher> InitializeCoreAsync()
         }
     }
 
+    private static void ThrowCannotShortCircuitAnAuthRouteException(Endpoint endpoint)
+    {
+        throw new InvalidOperationException($"Endpoint {endpoint.DisplayName} contains authorization metadata, " +
+            "but this endpoint is marked with short circuit and it will execute on Routing Middleware.");
+    }
+
+    private static void ThrowCannotShortCircuitACorsRouteException(Endpoint endpoint)
+    {
+        throw new InvalidOperationException($"Endpoint {endpoint.DisplayName} contains CORS metadata, " +
+            "but this endpoint is marked with short circuit and it will execute on Routing Middleware.");
+    }
+
     private static partial class Log
     {
         public static void MatchSuccess(ILogger logger, Endpoint endpoint)
@@ -181,5 +274,14 @@ public static void MatchSkipped(ILogger logger, Endpoint endpoint)
 
         [LoggerMessage(3, LogLevel.Debug, "Endpoint '{EndpointName}' already set, skipping route matching.", EventName = "MatchingSkipped")]
         private static partial void MatchingSkipped(ILogger logger, string? endpointName);
+
+        [LoggerMessage(4, LogLevel.Information, "The endpoint '{EndpointName}' is being executed without running additional middleware.", EventName = "ExecutingEndpoint")]
+        public static partial void ExecutingEndpoint(ILogger logger, Endpoint endpointName);
+
+        [LoggerMessage(5, LogLevel.Information, "The endpoint '{EndpointName}' has been executed without running additional middleware.", EventName = "ExecutedEndpoint")]
+        public static partial void ExecutedEndpoint(ILogger logger, Endpoint endpointName);
+
+        [LoggerMessage(6, LogLevel.Information, "The endpoint '{EndpointName}' is being short circuited without running additional middleware or producing a response.", EventName = "ShortCircuitedEndpoint")]
+        public static partial void ShortCircuitedEndpoint(ILogger logger, Endpoint endpointName);
     }
 }

src/Http/Routing/src/PublicAPI.Unshipped.txt

@@ -1,4 +1,8 @@
 #nullable enable
 Microsoft.AspNetCore.Routing.RouteHandlerServices
 static Microsoft.AspNetCore.Routing.RouteHandlerServices.Map(Microsoft.AspNetCore.Routing.IEndpointRouteBuilder! endpoints, string! pattern, System.Delegate! handler, System.Collections.Generic.IEnumerable<string!>! httpMethods, System.Func<System.Reflection.MethodInfo!, Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions?, Microsoft.AspNetCore.Http.RequestDelegateMetadataResult!>! populateMetadata, System.Func<System.Delegate!, Microsoft.AspNetCore.Http.RequestDelegateFactoryOptions!, Microsoft.AspNetCore.Http.RequestDelegateMetadataResult?, Microsoft.AspNetCore.Http.RequestDelegateResult!>! createRequestDelegate) -> Microsoft.AspNetCore.Builder.RouteHandlerBuilder!
+Microsoft.AspNetCore.Builder.RouteShortCircuitEndpointConventionBuilderExtensions
+Microsoft.AspNetCore.Routing.RouteShortCircuitEndpointRouteBuilderExtensions
+static Microsoft.AspNetCore.Builder.RouteShortCircuitEndpointConventionBuilderExtensions.ShortCircuit(this Microsoft.AspNetCore.Builder.IEndpointConventionBuilder! builder, int? statusCode = null) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
+static Microsoft.AspNetCore.Routing.RouteShortCircuitEndpointRouteBuilderExtensions.MapShortCircuit(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder! builder, int statusCode, params string![]! routePrefixes) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
 static Microsoft.Extensions.DependencyInjection.RoutingServiceCollectionExtensions.AddRoutingCore(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

src/Http/Routing/src/ShortCircuit/RouteShortCircuitEndpointConventionBuilderExtensions.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Routing.ShortCircuit;
+
+namespace Microsoft.AspNetCore.Builder;
+
+/// <summary>
+/// Short circuit extension methods for <see cref="IEndpointConventionBuilder"/>.
+/// </summary>
+public static class RouteShortCircuitEndpointConventionBuilderExtensions
+{
+    private static readonly ShortCircuitMetadata _200ShortCircuitMetadata = new ShortCircuitMetadata(200);
+    private static readonly ShortCircuitMetadata _401ShortCircuitMetadata = new ShortCircuitMetadata(401);
+    private static readonly ShortCircuitMetadata _404ShortCircuitMetadata = new ShortCircuitMetadata(404);
+    private static readonly ShortCircuitMetadata _nullShortCircuitMetadata = new ShortCircuitMetadata(null);
+
+    /// <summary>
+    /// Short circuit the endpoint(s).
+    /// The execution of the endpoint will happen in UseRouting middleware instead of UseEndpoint.
+    /// </summary>
+    /// <param name="builder">The endpoint convention builder.</param>
+    /// <param name="statusCode">The status code to set in the response.</param>
+    /// <returns>The original convention builder parameter.</returns>
+    public static IEndpointConventionBuilder ShortCircuit(this IEndpointConventionBuilder builder, int? statusCode = null)
+    {
+        var metadata = statusCode switch
+        {
+            200 => _200ShortCircuitMetadata,
+            401 => _401ShortCircuitMetadata,
+            404 => _404ShortCircuitMetadata,
+            null => _nullShortCircuitMetadata,
+            _ => new ShortCircuitMetadata(statusCode)
+        };
+
+        builder.Add(b => b.Metadata.Add(metadata));
+        return builder;
+    }
+}