[Backport 6.x] Reimplement #4673 manually (#4678)

Author: Mpdreamz

dotnet-tools.json

@@ -8,17 +8,11 @@
         "assembly-rewriter"
       ]
     },
-    "dotnet-assembly-differ": {
-      "version": "1.0.0-ci20190926135713",
-      "commands": [
-        "assembly-differ"
-      ]
-    },
     "assembly-differ": {
       "version": "0.9.0",
       "commands": [
         "assembly-differ"
       ]
     }
   }
-}
+}

src/Elasticsearch.Net/Configuration/ConnectionConfiguration.cs

@@ -76,6 +76,12 @@ private static bool UsingCurlHandler
 		/// </summary>
 		public static readonly TimeSpan DefaultTimeout = TimeSpan.FromMinutes(1);
 
+		/// <summary>
+		/// The default timeout before a TCP connection is forcefully recycled so that DNS updates come through
+		/// Defaults to 5 minutes.
+		/// </summary>
+		public static readonly TimeSpan DefaultDnsRefreshTimeout = TimeSpan.FromMinutes(5);
+
 		/// <summary>
 		/// The default connection limit for both Elasticsearch.Net and Nest. Defaults to <c>80</c>
 #if DOTNETCORE
@@ -185,6 +191,7 @@ public abstract class ConnectionConfiguration<T> : IConnectionConfigurationValue
 		private string _proxyPassword;
 		private string _proxyUsername;
 		private TimeSpan _requestTimeout;
+		private TimeSpan _dnsRefreshTimeout;
 		private Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> _serverCertificateValidationCallback;
 		private IReadOnlyCollection<int> _skipDeserializationForStatusCodes = new ReadOnlyCollection<int>(new int[] { });
 		private TimeSpan? _sniffLifeSpan;
@@ -202,6 +209,7 @@ protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection co
 
 			_connectionLimit = ConnectionConfiguration.DefaultConnectionLimit;
 			_requestTimeout = ConnectionConfiguration.DefaultTimeout;
+			_dnsRefreshTimeout = ConnectionConfiguration.DefaultDnsRefreshTimeout;
 			_sniffOnConnectionFault = true;
 			_sniffOnStartup = true;
 			_sniffLifeSpan = TimeSpan.FromHours(1);
@@ -249,6 +257,7 @@ protected ConnectionConfiguration(IConnectionPool connectionPool, IConnection co
 		NameValueCollection IConnectionConfigurationValues.QueryStringParameters => _queryString;
 		IElasticsearchSerializer IConnectionConfigurationValues.RequestResponseSerializer => UseThisRequestResponseSerializer;
 		TimeSpan IConnectionConfigurationValues.RequestTimeout => _requestTimeout;
+		TimeSpan IConnectionConfigurationValues.DnsRefreshTimeout => _dnsRefreshTimeout;
 
 		Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> IConnectionConfigurationValues.ServerCertificateValidationCallback =>
 			_serverCertificateValidationCallback;
@@ -419,6 +428,16 @@ public T GlobalQueryStringParameters(NameValueCollection queryStringParameters)
 		/// </summary>
 		public T MaxRetryTimeout(TimeSpan maxRetryTimeout) => Assign(maxRetryTimeout, (a, v) => a._maxRetryTimeout = v);
 
+		/// <summary>
+		/// DnsRefreshTimeout for the connections. Defaults to 5 minutes.
+		#if DOTNETCORE
+		/// <para>Will create new instances of <see cref="System.Net.Http.HttpClient"/> after this timeout to force DNS updates</para>
+		#else
+		/// <para>Will set both <see cref="System.Net.ServicePointManager.DnsRefreshTimeout"/> and <see cref="System.Net.ServicePointManager.ConnectionLeaseTimeout "/>
+		#endif
+		/// </summary>
+		public T DnsRefreshTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._dnsRefreshTimeout = v);
+
 		/// <summary>
 		/// If your connection has to go through proxy, use this method to specify the proxy url
 		/// </summary>

src/Elasticsearch.Net/Configuration/IConnectionConfigurationValues.cs

@@ -219,5 +219,15 @@ public interface IConnectionConfigurationValues : IDisposable
 		/// versions that initiate requests to Elasticsearch
 		/// </summary>
 		string UserAgent { get; }
+
+		/// <summary>
+		/// DnsRefreshTimeout for the connections. Defaults to 5 minutes.
+		#if DOTNETCORE
+		/// <para>Will create new instances of <see cref="System.Net.Http.HttpClient"/> after this timeout to force DNS updates</para>
+		#else
+		/// <para>Will set <see cref="System.Net.ServicePointManager.ConnectionLeaseTimeout "/>
+		#endif
+		/// </summary>
+		TimeSpan DnsRefreshTimeout { get; }
 	}
 }

src/Elasticsearch.Net/Connection/HandlerTracking/ActiveHandlerTrackingEntry.cs

@@ -0,0 +1,84 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if DOTNETCORE
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Elasticsearch.Net
+{
+	/// <summary>
+    /// Thread-safety: We treat this class as immutable except for the timer. Creating a new object
+	/// for the 'expiry' pool simplifies the threading requirements significantly.
+	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ActiveHandlerTrackingEntry.cs</para>
+	/// </summary>
+    internal class ActiveHandlerTrackingEntry
+    {
+        private static readonly TimerCallback TimerCallback = (s) => ((ActiveHandlerTrackingEntry)s).Timer_Tick();
+        private readonly object _lock;
+        private bool _timerInitialized;
+        private Timer _timer;
+        private TimerCallback _callback;
+
+        public ActiveHandlerTrackingEntry(
+            int key,
+            LifetimeTrackingHttpMessageHandler handler,
+            TimeSpan lifetime)
+        {
+            Key = key;
+            Handler = handler;
+            Lifetime = lifetime;
+
+            _lock = new object();
+        }
+
+        public LifetimeTrackingHttpMessageHandler Handler { get; private set; }
+
+        public TimeSpan Lifetime { get; }
+
+        public int Key { get; }
+
+        public void StartExpiryTimer(TimerCallback callback)
+        {
+            if (Lifetime == Timeout.InfiniteTimeSpan) return;
+
+            if (Volatile.Read(ref _timerInitialized)) return;
+
+            StartExpiryTimerSlow(callback);
+        }
+
+        private void StartExpiryTimerSlow(TimerCallback callback)
+        {
+            Debug.Assert(Lifetime != Timeout.InfiniteTimeSpan);
+
+            lock (_lock)
+            {
+                if (Volatile.Read(ref _timerInitialized))
+                    return;
+
+                _callback = callback;
+                _timer = NonCapturingTimer.Create(TimerCallback, this, Lifetime, Timeout.InfiniteTimeSpan);
+                _timerInitialized = true;
+            }
+        }
+
+        private void Timer_Tick()
+        {
+            Debug.Assert(_callback != null);
+            Debug.Assert(_timer != null);
+
+            lock (_lock)
+			{
+				if (_timer == null) return;
+
+				_timer.Dispose();
+				_timer = null;
+
+				_callback(this);
+			}
+        }
+    }
+}
+#endif

src/Elasticsearch.Net/Connection/HandlerTracking/ExpiredHandlerTrackingEntry.cs

@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if DOTNETCORE
+using System;
+using System.Net.Http;
+
+namespace Elasticsearch.Net
+{
+	/// <summary>
+	/// Thread-safety: This class is immutable
+	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ExpiredHandlerTrackingEntry.cs</para>
+	/// </summary>
+	internal class ExpiredHandlerTrackingEntry
+	{
+		private readonly WeakReference _livenessTracker;
+
+		// IMPORTANT: don't cache a reference to `other` or `other.Handler` here.
+		// We need to allow it to be GC'ed.
+		public ExpiredHandlerTrackingEntry(ActiveHandlerTrackingEntry other)
+		{
+			Key = other.Key;
+
+			_livenessTracker = new WeakReference(other.Handler);
+			InnerHandler = other.Handler.InnerHandler;
+		}
+
+		public bool CanDispose => !_livenessTracker.IsAlive;
+
+		public HttpMessageHandler InnerHandler { get; }
+
+		public int Key { get; }
+	}
+}
+#endif

src/Elasticsearch.Net/Connection/HandlerTracking/LifetimeTrackingHttpMessageHandler.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if DOTNETCORE
+using System.Net.Http;
+
+namespace Elasticsearch.Net
+{
+	/// <summary>
+	/// This a marker used to check if the underlying handler should be disposed. HttpClients
+	/// share a reference to an instance of this class, and when it goes out of scope the inner handler
+	/// is eligible to be disposed.
+	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/LifetimeTrackingHttpMessageHandler.cs</para>
+	/// </summary>
+	internal class LifetimeTrackingHttpMessageHandler : DelegatingHandler
+	{
+		public LifetimeTrackingHttpMessageHandler(HttpMessageHandler innerHandler)
+			: base(innerHandler) { }
+
+		protected override void Dispose(bool disposing)
+		{
+			// The lifetime of this is tracked separately by ActiveHandlerTrackingEntry
+		}
+	}
+}
+#endif