Add keep-alive timeout (#464).

Author: Cesar Blum Silveira

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/Connection.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -156,6 +155,12 @@ public virtual void OnSocketClosed()
             _socketClosedTcs.TrySetResult(null);
         }
 
+        // Called on Libuv thread
+        public void Tick()
+        {
+            _frame.Tick();
+        }
+
         private void ApplyConnectionFilter()
         {
             if (_filterContext.Connection != _libuvStream)
@@ -277,6 +282,11 @@ void IConnectionControl.End(ProduceEndType endType)
             }
         }
 
+        void IConnectionControl.Stop()
+        {
+            StopAsync();
+        }
+
         private static unsafe string GenerateConnectionId(long id)
         {
             // The following routine is ~310% faster than calling long.ToString() on x64

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/Frame.cs

@@ -56,7 +56,7 @@ public abstract partial class Frame : ConnectionContext, IFrameControl
         private CancellationTokenSource _abortedCts;
         private CancellationToken? _manuallySetRequestAbortToken;
 
-        protected RequestProcessingStatus _requestProcessingStatus;
+        private RequestProcessingStatus _requestProcessingStatus;
         protected bool _keepAlive;
         private bool _autoChunk;
         protected Exception _applicationException;
@@ -68,6 +68,8 @@ public abstract partial class Frame : ConnectionContext, IFrameControl
         private int _remainingRequestHeadersBytesAllowed;
         private int _requestHeadersParsed;
 
+        private int _secondsSinceLastRequest;
+
         public Frame(ConnectionContext context)
             : base(context)
         {
@@ -213,10 +215,7 @@ private CancellationTokenSource RequestAbortedSource
             }
         }
 
-        public bool HasResponseStarted
-        {
-            get { return _requestProcessingStatus == RequestProcessingStatus.ResponseStarted; }
-        }
+        public bool HasResponseStarted => _requestProcessingStatus == RequestProcessingStatus.ResponseStarted;
 
         protected FrameRequestHeaders FrameRequestHeaders { get; private set; }
 
@@ -1267,6 +1266,25 @@ protected void ReportApplicationError(Exception ex)
             Log.ApplicationError(ConnectionId, ex);
         }
 
+        public void Tick()
+        {
+            // we're in between requests and not about to start processing a new one
+            if (_requestProcessingStatus == RequestProcessingStatus.RequestPending && !SocketInput.IsCompleted)
+            {
+                if (_secondsSinceLastRequest > ServerOptions.Limits.KeepAliveTimeout.TotalSeconds)
+                {
+                    ConnectionControl.Stop();
+                }
+
+                _secondsSinceLastRequest++;
+            }
+        }
+
+        public void RequestFinished()
+        {
+            _secondsSinceLastRequest = 0;
+        }
+
         protected enum RequestLineStatus
         {
             Empty,
@@ -1277,7 +1295,7 @@ protected enum RequestLineStatus
             Done
         }
 
-        protected enum RequestProcessingStatus
+        private enum RequestProcessingStatus
         {
             RequestPending,
             RequestStarted,

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/IConnectionControl.cs

@@ -8,5 +8,6 @@ public interface IConnectionControl
         void Pause();
         void Resume();
         void End(ProduceEndType endType);
+        void Stop();
     }
 }

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/MessageBody.cs

@@ -172,6 +172,7 @@ public override ValueTask<int> ReadAsyncImplementation(ArraySegment<byte> buffer
                 var limit = buffer.Array == null ? inputLengthLimit : Math.Min(buffer.Count, inputLengthLimit);
                 if (limit == 0)
                 {
+                    _context.RequestFinished();
                     return new ValueTask<int>(0);
                 }
 
@@ -182,10 +183,17 @@ public override ValueTask<int> ReadAsyncImplementation(ArraySegment<byte> buffer
                     // .GetAwaiter().GetResult() done by ValueTask if needed
                     var actual = task.Result;
                     _inputLength -= actual;
+
                     if (actual == 0)
                     {
                         _context.RejectRequest(RequestRejectionReason.UnexpectedEndOfRequestContent);
                     }
+
+                    if (_inputLength == 0)
+                    {
+                        _context.RequestFinished();
+                    }
+
                     return new ValueTask<int>(actual);
                 }
                 else
@@ -198,11 +206,17 @@ private async Task<int> ReadAsyncAwaited(Task<int> task)
             {
                 var actual = await task;
                 _inputLength -= actual;
+
                 if (actual == 0)
                 {
                     _context.RejectRequest(RequestRejectionReason.UnexpectedEndOfRequestContent);
                 }
 
+                if (_inputLength == 0)
+                {
+                    _context.RequestFinished();
+                }
+
                 return actual;
             }
         }
@@ -354,6 +368,8 @@ private async Task<int> ReadStateMachineAsync(SocketInput input, ArraySegment<by
                     _mode = Mode.Complete;
                 }
 
+                _context.RequestFinished();
+
                 return 0;
             }
 

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/KestrelThread.cs

@@ -27,12 +27,16 @@ public class KestrelThread
         // otherwise it needs to wait till the next pass of the libuv loop
         private readonly int _maxLoops = 8;
 
+        // how often the heartbeat timer will tick connections
+        private const int _heartbeatMilliseconds = 1000;
+
         private readonly KestrelEngine _engine;
         private readonly IApplicationLifetime _appLifetime;
         private readonly Thread _thread;
         private readonly TaskCompletionSource<object> _threadTcs = new TaskCompletionSource<object>();
         private readonly UvLoopHandle _loop;
         private readonly UvAsyncHandle _post;
+        private readonly UvTimerHandle _heartbeatTimer;
         private Queue<Work> _workAdding = new Queue<Work>(1024);
         private Queue<Work> _workRunning = new Queue<Work>(1024);
         private Queue<CloseHandle> _closeHandleAdding = new Queue<CloseHandle>(256);
@@ -57,6 +61,7 @@ public KestrelThread(KestrelEngine engine)
             _post = new UvAsyncHandle(_log);
             _thread = new Thread(ThreadStart);
             _thread.Name = "KestrelThread - libuv";
+            _heartbeatTimer = new UvTimerHandle(_log);
 #if !DEBUG
             // Mark the thread as being as unimportant to keeping the process alive.
             // Don't do this for debug builds, so we know if the thread isn't terminating.
@@ -176,9 +181,9 @@ private async Task DisposeConnectionsAsync()
             }
         }
 
-
         private void AllowStop()
         {
+            _heartbeatTimer.Stop();
             _post.Unreference();
         }
 
@@ -274,6 +279,8 @@ private void ThreadStart(object parameter)
                 {
                     _loop.Init(_engine.Libuv);
                     _post.Init(_loop, OnPost, EnqueueCloseHandle);
+                    _heartbeatTimer.Init(_loop, EnqueueCloseHandle);
+                    _heartbeatTimer.Start(OnHeartbeat, timeout: 1000, repeat: 1000);
                     _initCompleted = true;
                     tcs.SetResult(0);
                 }
@@ -296,6 +303,7 @@ private void ThreadStart(object parameter)
                 // run the loop one more time to delete the open handles
                 _post.Reference();
                 _post.Dispose();
+                _heartbeatTimer.Dispose();
 
                 // Ensure the Dispose operations complete in the event loop.
                 _loop.Run();
@@ -327,6 +335,15 @@ private void OnPost()
             } while (wasWork && loopsRemaining > 0);
         }
 
+        private void OnHeartbeat(UvTimerHandle timer)
+        {
+            Walk(ptr =>
+            {
+                var handle = UvMemory.FromIntPtr<UvHandle>(ptr);
+                (handle as UvStreamHandle)?.Connection?.Tick();
+            });
+        }
+
         private bool DoPostWork()
         {
             Queue<Work> queue;

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Networking/Libuv.cs

@@ -53,6 +53,9 @@ public Libuv()
             _uv_tcp_getpeername = NativeMethods.uv_tcp_getpeername;
             _uv_tcp_getsockname = NativeMethods.uv_tcp_getsockname;
             _uv_walk = NativeMethods.uv_walk;
+            _uv_timer_init = NativeMethods.uv_timer_init;
+            _uv_timer_start = NativeMethods.uv_timer_start;
+            _uv_timer_stop = NativeMethods.uv_timer_stop;
         }
 
         // Second ctor that doesn't set any fields only to be used by MockLibuv
@@ -407,6 +410,30 @@ public void walk(UvLoopHandle loop, uv_walk_cb walk_cb, IntPtr arg)
             _uv_walk(loop, walk_cb, arg);
         }
 
+        protected Func<UvLoopHandle, UvTimerHandle, int> _uv_timer_init;
+        unsafe public void timer_init(UvLoopHandle loop, UvTimerHandle handle)
+        {
+            loop.Validate();
+            handle.Validate();
+            ThrowIfErrored(_uv_timer_init(loop, handle));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void uv_timer_cb(IntPtr handle);
+        protected Func<UvTimerHandle, uv_timer_cb, long, long, int> _uv_timer_start;
+        unsafe public void timer_start(UvTimerHandle handle, uv_timer_cb cb, long timeout, long repeat)
+        {
+            handle.Validate();
+            ThrowIfErrored(_uv_timer_start(handle, cb, timeout, repeat));
+        }
+
+        protected Func<UvTimerHandle, int> _uv_timer_stop;
+        unsafe public void timer_stop(UvTimerHandle handle)
+        {
+            handle.Validate();
+            ThrowIfErrored(_uv_timer_stop(handle));
+        }
+
         public delegate int uv_tcp_getsockname_func(UvTcpHandle handle, out SockAddr addr, ref int namelen);
         protected uv_tcp_getsockname_func _uv_tcp_getsockname;
         public void tcp_getsockname(UvTcpHandle handle, out SockAddr addr, ref int namelen)
@@ -604,6 +631,15 @@ private static class NativeMethods
             [DllImport("libuv", CallingConvention = CallingConvention.Cdecl)]
             public static extern int uv_walk(UvLoopHandle loop, uv_walk_cb walk_cb, IntPtr arg);
 
+            [DllImport("libuv", CallingConvention = CallingConvention.Cdecl)]
+            unsafe public static extern int uv_timer_init(UvLoopHandle loop, UvTimerHandle handle);
+
+            [DllImport("libuv", CallingConvention = CallingConvention.Cdecl)]
+            unsafe public static extern int uv_timer_start(UvTimerHandle handle, uv_timer_cb cb, long timeout, long repeat);
+
+            [DllImport("libuv", CallingConvention = CallingConvention.Cdecl)]
+            unsafe public static extern int uv_timer_stop(UvTimerHandle handle);
+
             [DllImport("WS2_32.dll", CallingConvention = CallingConvention.Winapi)]
             unsafe public static extern int WSAIoctl(
                 IntPtr socket,

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Networking/UvTimerHandle.cs

@@ -0,0 +1,57 @@
+// 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;
+using Microsoft.AspNetCore.Server.Kestrel.Internal.Infrastructure;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Server.Kestrel.Internal.Networking
+{
+    public class UvTimerHandle : UvHandle
+    {
+        private readonly static Libuv.uv_timer_cb _uv_timer_cb = UvTimerCb;
+
+        private Action<UvTimerHandle> _callback;
+
+        public UvTimerHandle(IKestrelTrace logger) : base(logger)
+        {
+        }
+
+        public void Init(UvLoopHandle loop, Action<Action<IntPtr>, IntPtr> queueCloseHandle)
+        {
+            CreateHandle(
+                loop.Libuv,
+                loop.ThreadId,
+                loop.Libuv.handle_size(Libuv.HandleType.TIMER),
+                queueCloseHandle);
+
+            _uv.timer_init(loop, this);
+        }
+
+        public void Start(Action<UvTimerHandle> callback, long timeout, long repeat)
+        {
+            _callback = callback;
+            _uv.timer_start(this, _uv_timer_cb, timeout, repeat);
+        }
+
+        public void Stop()
+        {
+            _uv.timer_stop(this);
+        }
+
+        private static void UvTimerCb(IntPtr handle)
+        {
+            var timer = FromIntPtr<UvTimerHandle>(handle);
+
+            try
+            {
+                timer._callback(timer);
+            }
+            catch (Exception ex)
+            {
+                timer._log.LogError(0, ex, nameof(UvTimerCb));
+                throw;
+            }
+        }
+    }
+}

src/Microsoft.AspNetCore.Server.Kestrel/KestrelServerLimits.cs

@@ -23,6 +23,9 @@ public class KestrelServerLimits
         // Matches the default LimitRequestFields in Apache httpd.
         private int _maxRequestHeaderCount = 100;
 
+        // Matches the default http.sys keep-alive timouet.
+        private TimeSpan _keepAliveTimeout = TimeSpan.FromMinutes(2);
+
         /// <summary>
         /// Gets or sets the maximum size of the response buffer before write
         /// calls begin to block or return tasks that don't complete until the
@@ -138,5 +141,23 @@ public int MaxRequestHeaderCount
                 _maxRequestHeaderCount = value;
             }
         }
+
+        /// <summary>
+        /// Gets or sets the keep-alive timeout.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to 2 minutes. Timeout granularity is in seconds. Sub-second values will be rounded to the next second.
+        /// </remarks>
+        public TimeSpan KeepAliveTimeout
+        {
+            get
+            {
+                return _keepAliveTimeout;
+            }
+            set
+            {
+                _keepAliveTimeout = TimeSpan.FromSeconds(Math.Ceiling(value.TotalSeconds));
+            }
+        }
     }
 }