[Fixes #2044] Implement an equivalent to AsyncTimeOutAttribute

Author: kichalla

src/Microsoft.AspNet.Mvc.Core/Filters/AsyncTimeoutAttribute.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNet.Mvc.Core;
+using Microsoft.Framework.Internal;
+
+namespace Microsoft.AspNet.Mvc
+{
+    /// <summary>
+    /// Represents an attribute that is used to set the timeout value, in milliseconds, 
+    /// which when elapsed will cause the current request to be aborted.
+    /// </summary>
+    [AttributeUsage(
+        AttributeTargets.Class | AttributeTargets.Method,
+        AllowMultiple = false,
+        Inherited = true)]
+    public class AsyncTimeoutAttribute : Attribute, IAsyncResourceFilter
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncTimeoutAttribute"/>.
+        /// </summary>
+        /// <param name="duration">The duration in milliseconds.</param>
+        public AsyncTimeoutAttribute(int duration)
+        {
+            if (duration < -1)
+            {
+                throw new ArgumentException(
+                    Resources.FormatAsyncTimeoutAttribute_InvalidTimeout(duration, nameof(duration))); 
+            }
+
+            Duration = duration;
+        }
+
+        /// <summary>
+        /// The timeout duration in milliseconds.
+        /// </summary>
+        public int Duration { get; }
+
+        public async Task OnResourceExecutionAsync(
+            [NotNull] ResourceExecutingContext context,
+            [NotNull] ResourceExecutionDelegate next)
+        {
+            var httpContext = context.HttpContext;
+
+            // Get a task that will complete after a time delay.
+            var timeDelayTask = Task.Delay(Duration, cancellationToken: httpContext.RequestAborted);
+
+            // Task representing later stages of the pipeline.
+            var pipelineTask = next();
+
+            // Get the first task which completed.
+            var completedTask = await Task.WhenAny(pipelineTask, timeDelayTask);
+
+            if (completedTask == pipelineTask)
+            {
+                // Task completed within timeout, but it could be in faulted or canceled state.
+                // Allow the following line to throw exception and be handled somewhere else.
+                await completedTask;
+            }
+            else
+            {
+                // Pipeline task did not complete within timeout, so abort the request.
+                httpContext.Abort();
+            }
+        }
+    }
+}

src/Microsoft.AspNet.Mvc.Core/Filters/ResourceExecutionDelegate.cs

@@ -6,7 +6,7 @@
 namespace Microsoft.AspNet.Mvc
 {
     /// <summary>
-    /// A delegate which asyncronously returns a <see cref="ResourceExecutedContext"/>.
+    /// A delegate which asynchronously returns a <see cref="ResourceExecutedContext"/>.
     /// </summary>
     /// <returns>A <see cref="ResourceExecutedContext"/>.</returns>
     public delegate Task<ResourceExecutedContext> ResourceExecutionDelegate();

src/Microsoft.AspNet.Mvc.Core/Properties/Resources.Designer.cs

@@ -448,4 +448,7 @@
   <data name="ModelType_WrongType" xml:space="preserve">
     <value>The model's runtime type '{0}' is not assignable to the type '{1}'.</value>
   </data>
+  <data name="AsyncTimeoutAttribute_InvalidTimeout" xml:space="preserve">
+    <value>The value '{0}' for argument '{1}' is invalid. The timeout value must be non-negative.</value>
+  </data>
 </root>

src/Microsoft.AspNet.Mvc.Core/Resources.resx

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#if ASPNET50
+using System.Threading.Tasks;
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Routing;
+using Moq;
+using Xunit;
+
+namespace Microsoft.AspNet.Mvc.Test
+{
+    public class AsyncTimeoutAttributeTest
+    {
+        [Fact]
+        public async Task RequestIsAborted_AfterTimeoutDurationElapses()
+        {
+            // Arrange
+            var httpContext = new Mock<HttpContext>();
+            var asyncTimeoutAttribute = new AsyncTimeoutAttribute(1 * 1000); // 1 second
+            var resourceExecutingContext = GetResourceExecutingContext(httpContext.Object);
+            
+            // Act
+            await asyncTimeoutAttribute.OnResourceExecutionAsync(
+                resourceExecutingContext, 
+                async () =>
+                {
+                    // Imagine here the rest of pipeline(ex: model-binding->action filters-action) being executed
+                    await Task.Delay(10 * 1000); // 10 seconds
+                    return null;
+                });
+
+            // Assert
+            httpContext.Verify(hc => hc.Abort(), Times.Once);
+        }
+
+        [Fact]
+        public async Task RequestIsNotAborted_BeforeTimeoutDurationElapses()
+        {
+            // Arrange
+            var httpContext = new Mock<HttpContext>();
+            var asyncTimeoutAttribute = new AsyncTimeoutAttribute(10 * 1000); // 10 seconds
+            var resourceExecutingContext = GetResourceExecutingContext(httpContext.Object);
+            
+            // Act
+            await asyncTimeoutAttribute.OnResourceExecutionAsync(
+                resourceExecutingContext,
+                async () =>
+                {
+                    // Imagine here the rest of pipeline(ex: model-binding->action filters-action) being executed
+                    await Task.Delay(1 * 1000); // 1 second
+                    return null;
+                });
+
+            // Assert
+            httpContext.Verify(hc => hc.Abort(), Times.Never);
+        }
+
+        private ResourceExecutingContext GetResourceExecutingContext(HttpContext httpContext)
+        {
+            var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
+
+            return new ResourceExecutingContext(actionContext, new IFilter[] { });
+        }
+    }
+}
+#endif