Implement request timeout middleware

src/Http/Http/perf/Microbenchmarks/Microsoft.AspNetCore.Http.Microbenchmarks.csproj

@@ -11,6 +11,7 @@
   <ItemGroup>
     <Reference Include="BenchmarkDotNet" />
     <Reference Include="Microsoft.AspNetCore.Http" />
+    <Reference Include="Microsoft.AspNetCore.Http.Extensions" />
     <Compile Include="$(SharedSourceRoot)BenchmarkRunner\*.cs" />
   </ItemGroup>
 

src/Http/Http/perf/Microbenchmarks/RequestTimeoutsMiddlewareBenchmark.cs

@@ -0,0 +1,149 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using BenchmarkDotNet.Attributes;
+using Microsoft.AspNetCore.Http.Timeouts;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.AspNetCore.Http;
+
+public class RequestTimeoutsMiddlewareBenchmark
+{
+    RequestTimeoutsMiddleware _middlewareWithNoTimeout;
+    RequestTimeoutsMiddleware _middleware;
+    RequestTimeoutsMiddleware _middlewareWithThrow;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _middlewareWithNoTimeout = new RequestTimeoutsMiddleware(
+            async context => { await Task.Yield(); },
+            new CancellationTokenLinker(),
+            NullLogger<RequestTimeoutsMiddleware>.Instance,
+            Options.Create(new RequestTimeoutOptions()));
+
+        _middleware = new RequestTimeoutsMiddleware(
+          async context => { await Task.Yield(); },
+          new CancellationTokenLinker(),
+          NullLogger<RequestTimeoutsMiddleware>.Instance,
+          Options.Create(new RequestTimeoutOptions
+          {
+              DefaultPolicy = new RequestTimeoutPolicy
+              {
+                  Timeout = TimeSpan.FromMilliseconds(200)
+              },
+              Policies =
+              {
+                  ["policy1"] = new RequestTimeoutPolicy { Timeout = TimeSpan.FromMilliseconds(200)}
+              }
+          }));
+
+        _middlewareWithThrow = new RequestTimeoutsMiddleware(
+          async context =>
+          {
+              await Task.Delay(TimeSpan.FromMicroseconds(2));
+              context.RequestAborted.ThrowIfCancellationRequested();
+          },
+          new CancellationTokenLinker(),
+          NullLogger<RequestTimeoutsMiddleware>.Instance,
+          Options.Create(new RequestTimeoutOptions
+          {
+              DefaultPolicy = new RequestTimeoutPolicy
+              {
+                  Timeout = TimeSpan.FromMicroseconds(1)
+              }
+          }));
+    }
+
+    [Benchmark]
+    public async Task NoMetadataNoDefault()
+    {
+        var context = CreateHttpContext(new Endpoint(null, null, null));
+        await _middlewareWithNoTimeout.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task DefaultTimeout()
+    {
+        var context = CreateHttpContext(new Endpoint(null, null, null));
+
+        await _middleware.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task DefaultTimeoutOverriddenByDisable()
+    {
+        var context = CreateHttpContext(new Endpoint(
+            null,
+            new EndpointMetadataCollection(new DisableRequestTimeoutAttribute()),
+            null));
+
+        await _middleware.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task TimeoutMetadata()
+    {
+        var context = CreateHttpContext(new Endpoint(
+            null,
+            new EndpointMetadataCollection(new RequestTimeoutAttribute(200)),
+            null));
+
+        await _middleware.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task NamedPolicyMetadata()
+    {
+        var context = CreateHttpContext(new Endpoint(
+            null,
+            new EndpointMetadataCollection(new RequestTimeoutAttribute("policy1")),
+            null));
+
+        await _middleware.Invoke(context);
+    }
+
+    [Benchmark]
+    public async Task TimeoutFires()
+    {
+        var context = CreateHttpContext(new Endpoint(null, null, null));
+
+        await _middlewareWithThrow.Invoke(context);
+    }
+
+    private HttpContext CreateHttpContext(Endpoint endpoint)
+    {
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(endpoint);
+
+        var cts = new CancellationTokenSource();
+        context.RequestAborted = cts.Token;
+
+        return context;
+    }
+
+    private sealed class Options : IOptionsMonitor<RequestTimeoutOptions>
+    {
+        private readonly RequestTimeoutOptions _options;
+
+        private Options(RequestTimeoutOptions options)
+        {
+            _options = options;
+        }
+
+        public static Options Create(RequestTimeoutOptions options)
+        {
+            return new Options(options);
+        }
+
+        public RequestTimeoutOptions CurrentValue => _options;
+
+        public RequestTimeoutOptions Get(string name) => _options;
+
+        public IDisposable OnChange(Action<RequestTimeoutOptions, string> listener)
+        {
+            return default;
+        }
+    }
+}

src/Http/Http/src/Microsoft.AspNetCore.Http.csproj

@@ -12,6 +12,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+	<Compile Include="$(SharedSourceRoot)CancellationTokenSourcePool.cs" />
     <Compile Include="$(SharedSourceRoot)CopyOnWriteDictionary\*.cs" LinkBase="Shared"/>
     <Compile Include="$(SharedSourceRoot)ValueTaskExtensions\**\*.cs" LinkBase="Shared"/>
     <Compile Include="..\..\Shared\StreamCopyOperationInternal.cs" Link="Internal\StreamCopyOperationInternal.cs" />
@@ -25,6 +26,7 @@
   <ItemGroup>
     <Reference Include="Microsoft.AspNetCore.Connections.Abstractions" />
     <Reference Include="Microsoft.AspNetCore.Http.Abstractions" />
+    <Reference Include="Microsoft.AspNetCore.Http.Extensions" />
     <Reference Include="Microsoft.AspNetCore.WebUtilities" />
     <Reference Include="Microsoft.Extensions.ObjectPool" />
     <Reference Include="Microsoft.Extensions.Options" />

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

@@ -1,3 +1,38 @@
 #nullable enable
+Microsoft.AspNetCore.Builder.RequestTimeoutsIApplicationBuilderExtensions
+Microsoft.AspNetCore.Builder.RequestTimeoutsIEndpointConventionBuilderExtensions
 Microsoft.AspNetCore.Http.BindingAddress.IsNamedPipe.get -> bool
-Microsoft.AspNetCore.Http.BindingAddress.NamedPipeName.get -> string!
+Microsoft.AspNetCore.Http.BindingAddress.NamedPipeName.get -> string!
+Microsoft.AspNetCore.Http.Timeouts.DisableRequestTimeoutAttribute
+Microsoft.AspNetCore.Http.Timeouts.DisableRequestTimeoutAttribute.DisableRequestTimeoutAttribute() -> void
+Microsoft.AspNetCore.Http.Timeouts.IHttpRequestTimeoutFeature
+Microsoft.AspNetCore.Http.Timeouts.IHttpRequestTimeoutFeature.DisableTimeout() -> void
+Microsoft.AspNetCore.Http.Timeouts.IHttpRequestTimeoutFeature.RequestTimeoutToken.get -> System.Threading.CancellationToken
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutAttribute
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutAttribute.PolicyName.get -> string?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutAttribute.RequestTimeoutAttribute(int milliseconds) -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutAttribute.RequestTimeoutAttribute(string! policyName) -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutAttribute.Timeout.get -> System.TimeSpan?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.AddPolicy(string! policyName, Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy! policy) -> Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions!
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.AddPolicy(string! policyName, System.TimeSpan timeout) -> Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions!
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.DefaultPolicy.get -> Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.DefaultPolicy.set -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.Policies.get -> System.Collections.Generic.IDictionary<string!, Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy!>!
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions.RequestTimeoutOptions() -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.RequestTimeoutPolicy() -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.Timeout.get -> System.TimeSpan?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.Timeout.init -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.TimeoutStatusCode.get -> int?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.TimeoutStatusCode.init -> void
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.WriteTimeoutResponse.get -> Microsoft.AspNetCore.Http.RequestDelegate?
+Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy.WriteTimeoutResponse.init -> void
+Microsoft.Extensions.DependencyInjection.RequestTimeoutsIServiceCollectionExtensions
+static Microsoft.AspNetCore.Builder.RequestTimeoutsIApplicationBuilderExtensions.UseRequestTimeouts(this Microsoft.AspNetCore.Builder.IApplicationBuilder! builder) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+static Microsoft.AspNetCore.Builder.RequestTimeoutsIEndpointConventionBuilderExtensions.DisableRequestTimeout(this Microsoft.AspNetCore.Builder.IEndpointConventionBuilder! builder) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
+static Microsoft.AspNetCore.Builder.RequestTimeoutsIEndpointConventionBuilderExtensions.WithRequestTimeout(this Microsoft.AspNetCore.Builder.IEndpointConventionBuilder! builder, Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutPolicy! policy) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
+static Microsoft.AspNetCore.Builder.RequestTimeoutsIEndpointConventionBuilderExtensions.WithRequestTimeout(this Microsoft.AspNetCore.Builder.IEndpointConventionBuilder! builder, string! policyName) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
+static Microsoft.AspNetCore.Builder.RequestTimeoutsIEndpointConventionBuilderExtensions.WithRequestTimeout(this Microsoft.AspNetCore.Builder.IEndpointConventionBuilder! builder, System.TimeSpan timeout) -> Microsoft.AspNetCore.Builder.IEndpointConventionBuilder!
+static Microsoft.Extensions.DependencyInjection.RequestTimeoutsIServiceCollectionExtensions.AddRequestTimeouts(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
+static Microsoft.Extensions.DependencyInjection.RequestTimeoutsIServiceCollectionExtensions.AddRequestTimeouts(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<Microsoft.AspNetCore.Http.Timeouts.RequestTimeoutOptions!>! configure) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

src/Http/Http/src/Timeouts/CancellationTokenLinker.cs

@@ -0,0 +1,20 @@
+// 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.Internal;
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+internal sealed class CancellationTokenLinker : ICancellationTokenLinker
+{
+    private readonly CancellationTokenSourcePool _ctsPool = new();
+
+    public (CancellationTokenSource linkedCts, CancellationTokenSource timeoutCts) GetLinkedCancellationTokenSource(HttpContext httpContext, CancellationToken originalToken, TimeSpan timeSpan)
+    {
+        var timeoutCts = _ctsPool.Rent();
+        timeoutCts.CancelAfter(timeSpan);
+        httpContext.Response.RegisterForDispose(timeoutCts);
+        var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(originalToken, timeoutCts.Token);
+        return (linkedCts, timeoutCts);
+    }
+}

src/Http/Http/src/Timeouts/DisableRequestTimeoutAttribute.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+/// <summary>
+/// Metadata that disables request timeouts on an endpoint.
+/// </summary>
+/// <remarks>
+/// Completely disables the request timeouts middleware from applying to this endpoint.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
+public sealed class DisableRequestTimeoutAttribute : Attribute
+{
+}

src/Http/Http/src/Timeouts/HttpRequestTimeoutFeature.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+internal sealed class HttpRequestTimeoutFeature : IHttpRequestTimeoutFeature
+{
+    private readonly CancellationTokenSource _timeoutCancellationTokenSource;
+
+    public HttpRequestTimeoutFeature(CancellationTokenSource timeoutCancellationTokenSource)
+    {
+        _timeoutCancellationTokenSource = timeoutCancellationTokenSource;
+    }
+
+    public CancellationToken RequestTimeoutToken => _timeoutCancellationTokenSource.Token;
+
+    public void DisableTimeout()
+    {
+        _timeoutCancellationTokenSource.CancelAfter(Timeout.Infinite);
+    }
+}

src/Http/Http/src/Timeouts/ICancellationTokenLinker.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+internal interface ICancellationTokenLinker
+{
+    (CancellationTokenSource linkedCts, CancellationTokenSource timeoutCts) GetLinkedCancellationTokenSource(HttpContext httpContext, CancellationToken originalToken, TimeSpan timeSpan);
+}

src/Http/Http/src/Timeouts/IHttpRequestTimeoutFeature.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+/// <summary>
+/// Used to control timeouts on the current request.
+/// </summary>
+public interface IHttpRequestTimeoutFeature
+{
+    /// <summary>
+    /// A <see cref="CancellationToken" /> that will trigger when the request times out.
+    /// </summary>
+    CancellationToken RequestTimeoutToken { get; }
+
+    /// <summary>
+    /// Disables the request timeout if it hasn't already expired. This does not
+    /// trigger the <see cref="RequestTimeoutToken"/>.
+    /// </summary>
+    void DisableTimeout();
+}

src/Http/Http/src/Timeouts/LoggerExtensions.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+internal static partial class LoggerExtensions
+{
+    [LoggerMessage(1, LogLevel.Warning, "Timeout exception handled.")]
+    public static partial void TimeoutExceptionHandled(this ILogger logger, Exception exception);
+}

src/Http/Http/src/Timeouts/RequestTimeoutAttribute.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Timeouts;
+
+/// <summary>
+/// Metadata that provides endpoint-specific request timeouts.
+/// </summary>
+/// <remarks>
+/// The default policy will be ignored with this attribute applied.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
+public sealed class RequestTimeoutAttribute : Attribute
+{
+    /// <summary>
+    /// The timeout to apply for this endpoint.
+    /// </summary>
+    public TimeSpan? Timeout { get; }
+
+    /// <summary>
+    /// The name of the policy which needs to be applied.
+    /// This value is case-insensitive.
+    /// </summary>
+    public string? PolicyName { get; }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="RequestTimeoutAttribute"/> using the specified timeout.
+    /// </summary>
+    /// <param name="milliseconds">The duration, in milliseconds, of the timeout for this endpoint.</param>
+    public RequestTimeoutAttribute(int milliseconds)
+    {
+        Timeout = TimeSpan.FromMilliseconds(milliseconds);
+    }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="RequestTimeoutAttribute"/> using the specified policy.
+    /// </summary>
+    /// <param name="policyName">The name of the policy which needs to be applied (case-insensitive).</param>
+    public RequestTimeoutAttribute(string policyName)
+    {
+        PolicyName = policyName;
+    }
+}