Add request body minimum data rate feature (#1874).

Author: Cesar Blum Silveira

KestrelHttpServer.sln

@@ -25,7 +25,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "shared", "shared", "{0EF2AC
 		test\shared\KestrelTestLoggerProvider.cs = test\shared\KestrelTestLoggerProvider.cs
 		test\shared\LifetimeNotImplemented.cs = test\shared\LifetimeNotImplemented.cs
 		test\shared\MockConnectionInformation.cs = test\shared\MockConnectionInformation.cs
-		test\shared\MockFrameControl.cs = test\shared\MockFrameControl.cs
 		test\shared\MockLogger.cs = test\shared\MockLogger.cs
 		test\shared\MockSystemClock.cs = test\shared\MockSystemClock.cs
 		test\shared\StringExtensions.cs = test\shared\StringExtensions.cs

src/Microsoft.AspNetCore.Server.Kestrel.Core/CoreStrings.resx

@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!-- 
-    Microsoft ResX Schema 
-    
+  <!--
+    Microsoft ResX Schema
+
     Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
     associated with the data types.
-    
+
     Example:
-    
+
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
     <resheader name="version">2.0</resheader>
@@ -26,36 +26,36 @@
         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
         <comment>This is a comment</comment>
     </data>
-                
-    There are any number of "resheader" rows that contain simple 
+
+    There are any number of "resheader" rows that contain simple
     name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
     mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
     extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
     read any of the formats listed below.
-    
+
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
+    value   : The object must be serialized with
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-    
+
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
+    value   : The object must be serialized with
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
 
     mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
+    value   : The object must be serialized into a byte array
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
     -->
@@ -327,4 +327,10 @@
   <data name="MaxRequestBodySizeCannotBeModifiedForUpgradedRequests" xml:space="preserve">
     <value>The maximum request body size cannot be modified after the request has been upgraded.</value>
   </data>
-</root>
+  <data name="PositiveTimeSpanRequired" xml:space="preserve">
+    <value>Value must be a positive TimeSpan.</value>
+  </data>
+  <data name="NonNegativeTimeSpanRequired" xml:space="preserve">
+    <value>Value must be a non-negative TimeSpan.</value>
+  </data>
+</root>

src/Microsoft.AspNetCore.Server.Kestrel.Core/Features/IHttpRequestBodyMinimumDataRateFeature.cs

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.Server.Kestrel.Core.Features
+{
+    /// <summary>
+    /// Represents a minimum data rate for the request body of an HTTP request.
+    /// </summary>
+    public interface IHttpRequestBodyMinimumDataRateFeature
+    {
+        /// <summary>
+        /// The minimum data rate in bytes/second at which the request body should be received.
+        /// Setting this property to null indicates no minimum data rate should be enforced.
+        /// This limit has no effect on upgraded connections which are always unlimited.
+        /// </summary>
+        MinimumDataRate MinimumDataRate { get; set; }
+    }
+}

src/Microsoft.AspNetCore.Server.Kestrel.Core/Features/MinimumDataRate.cs

@@ -0,0 +1,41 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNetCore.Server.Kestrel.Core.Features
+{
+    public class MinimumDataRate
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="MinimumDataRate"/>.
+        /// </summary>
+        /// <param name="rate">The minimum rate in bytes/second at which data should be processed.</param>
+        /// <param name="gracePeriod">The amount of time to delay enforcement of <paramref name="rate"/>.</param>
+        public MinimumDataRate(double rate, TimeSpan gracePeriod)
+        {
+            if (rate <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(rate), CoreStrings.PositiveNumberRequired);
+            }
+
+            if (gracePeriod < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(gracePeriod), CoreStrings.NonNegativeTimeSpanRequired);
+            }
+
+            Rate = rate;
+            GracePeriod = gracePeriod;
+        }
+
+        /// <summary>
+        /// The minimum rate in bytes/second at which data should be processed.
+        /// </summary>
+        public double Rate { get; }
+
+        /// <summary>
+        /// The amount of time to delay enforcement of <see cref="MinimumDataRate" />.
+        /// </summary>
+        public TimeSpan GracePeriod { get; }
+    }
+}

src/Microsoft.AspNetCore.Server.Kestrel.Core/Internal/FrameConnection.cs

@@ -29,13 +29,24 @@ public class FrameConnection : IConnectionContext, ITimeoutControl
         private long _timeoutTimestamp = long.MaxValue;
         private TimeoutAction _timeoutAction;
 
+        private object _readTimingLock = new object();
+        private bool _readTimingEnabled;
+        private bool _readTimingPauseRequested;
+        private long _readTimingElapsedTicks;
+        private long _readTimingBytesRead;
+
         private Task _lifetimeTask;
 
         public FrameConnection(FrameConnectionContext context)
         {
             _context = context;
         }
 
+        // For testing
+        internal Frame Frame => _frame;
+
+        public bool TimedOut { get; private set; }
+
         public string ConnectionId => _context.ConnectionId;
         public IPipeWriter Input => _context.Input.Writer;
         public IPipeReader Output => _context.Output.Reader;
@@ -91,15 +102,7 @@ private async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> app
                 }
 
                 // _frame must be initialized before adding the connection to the connection manager
-                _frame = new Frame<TContext>(application, new FrameContext
-                {
-                    ConnectionId = _context.ConnectionId,
-                    ConnectionInformation = _context.ConnectionInformation,
-                    ServiceContext = _context.ServiceContext,
-                    TimeoutControl = this,
-                    Input = input,
-                    Output = output
-                });
+                CreateFrame(application, input, output);
 
                 // Do this before the first await so we don't yield control to the transport until we've
                 // added the connection to the connection manager
@@ -140,9 +143,22 @@ private async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> app
             }
         }
 
+        internal void CreateFrame<TContext>(IHttpApplication<TContext> application, IPipeReader input, IPipe output)
+        {
+            _frame = new Frame<TContext>(application, new FrameContext
+            {
+                ConnectionId = _context.ConnectionId,
+                ConnectionInformation = _context.ConnectionInformation,
+                ServiceContext = _context.ServiceContext,
+                TimeoutControl = this,
+                Input = input,
+                Output = output
+            });
+        }
+
         public void OnConnectionClosed(Exception ex)
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             // Abort the connection (if not already aborted)
             _frame.Abort(ex);
@@ -152,7 +168,7 @@ public void OnConnectionClosed(Exception ex)
 
         public Task StopAsync()
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             _frame.Stop();
 
@@ -161,32 +177,41 @@ public Task StopAsync()
 
         public void Abort(Exception ex)
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             // Abort the connection (if not already aborted)
             _frame.Abort(ex);
         }
 
         public Task AbortAsync(Exception ex)
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             // Abort the connection (if not already aborted)
             _frame.Abort(ex);
 
             return _lifetimeTask;
         }
 
-        public void Timeout()
+        public void SetTimeoutResponse()
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             _frame.SetBadRequestState(RequestRejectionReason.RequestTimeout);
         }
 
+        public void Timeout()
+        {
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
+
+            TimedOut = true;
+            _readTimingEnabled = false;
+            _frame.Stop();
+        }
+
         private async Task<Stream> ApplyConnectionAdaptersAsync()
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             var features = new FeatureCollection();
             var connectionAdapters = _context.ConnectionAdapters;
@@ -231,7 +256,7 @@ private void DisposeAdaptedConnections()
 
         public void Tick(DateTimeOffset now)
         {
-            Debug.Assert(_frame != null, $"nameof({_frame}) is null");
+            Debug.Assert(_frame != null, $"{nameof(_frame)} is null");
 
             var timestamp = now.Ticks;
 
@@ -242,10 +267,41 @@ public void Tick(DateTimeOffset now)
 
                 if (_timeoutAction == TimeoutAction.SendTimeoutResponse)
                 {
-                    Timeout();
+                    SetTimeoutResponse();
                 }
 
-                _frame.Stop();
+                Timeout();
+            }
+            else
+            {
+                lock (_readTimingLock)
+                {
+                    if (_readTimingEnabled)
+                    {
+                        _readTimingElapsedTicks += timestamp - _lastTimestamp;
+
+                        if (_frame.RequestBodyMinimumDataRate?.Rate > 0 && _readTimingElapsedTicks > _frame.RequestBodyMinimumDataRate.GracePeriod.Ticks)
+                        {
+                            var elapsedSeconds = (double)_readTimingElapsedTicks / TimeSpan.TicksPerSecond;
+                            var rate = Interlocked.Read(ref _readTimingBytesRead) / elapsedSeconds;
+
+                            if (rate < _frame.RequestBodyMinimumDataRate.Rate)
+                            {
+                                Log.RequestBodyMininumDataRateNotSatisfied(_context.ConnectionId, _frame.TraceIdentifier, _frame.RequestBodyMinimumDataRate.Rate);
+                                Timeout();
+                            }
+                        }
+
+                        // PauseTimingReads() cannot just set _timingReads to false. It needs to go through at least one tick
+                        // before pausing, otherwise _readTimingElapsed might never be updated if PauseTimingReads() is always
+                        // called before the next tick.
+                        if (_readTimingPauseRequested)
+                        {
+                            _readTimingEnabled = false;
+                            _readTimingPauseRequested = false;
+                        }
+                    }
+                }
             }
 
             Interlocked.Exchange(ref _lastTimestamp, timestamp);
@@ -275,5 +331,47 @@ private void AssignTimeout(long ticks, TimeoutAction timeoutAction)
             // Add Heartbeat.Interval since this can be called right before the next heartbeat.
             Interlocked.Exchange(ref _timeoutTimestamp, _lastTimestamp + ticks + Heartbeat.Interval.Ticks);
         }
+
+        public void StartTimingReads()
+        {
+            lock (_readTimingLock)
+            {
+                _readTimingElapsedTicks = 0;
+                _readTimingBytesRead = 0;
+                _readTimingEnabled = true;
+            }
+        }
+
+        public void StopTimingReads()
+        {
+            lock (_readTimingLock)
+            {
+                _readTimingEnabled = false;
+            }
+        }
+
+        public void PauseTimingReads()
+        {
+            lock (_readTimingLock)
+            {
+                _readTimingPauseRequested = true;
+            }
+        }
+
+        public void ResumeTimingReads()
+        {
+            lock (_readTimingLock)
+            {
+                _readTimingEnabled = true;
+
+                // In case pause and resume were both called between ticks
+                _readTimingPauseRequested = false;
+            }
+        }
+
+        public void BytesRead(int count)
+        {
+            Interlocked.Add(ref _readTimingBytesRead, count);
+        }
     }
 }