HttpClient: Adds detection of DNS changes through use of SocketsHttpHandler for .NET 6 and above

Microsoft.Azure.Cosmos/src/HttpClient/CosmosHttpClientCore.cs

@@ -5,17 +5,16 @@ namespace Microsoft.Azure.Cosmos
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
     using System.Linq;
     using System.Net;
     using System.Net.Http;
     using System.Net.Http.Headers;
     using System.Net.Security;
+    using System.Reflection;
     using System.Security.Cryptography.X509Certificates;
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.Azure.Cosmos.Resource.CosmosExceptions;
-    using Microsoft.Azure.Cosmos.Tracing;
     using Microsoft.Azure.Cosmos.Tracing.TraceData;
     using Microsoft.Azure.Documents;
     using Microsoft.Azure.Documents.Collections;
@@ -101,29 +100,74 @@ public static CosmosHttpClient CreateWithConnectionPolicy(
 
         public static HttpMessageHandler CreateHttpClientHandler(int gatewayModeMaxConnectionLimit, IWebProxy webProxy, Func<X509Certificate2, X509Chain, SslPolicyErrors, bool> serverCertificateCustomValidationCallback)
         {
-            HttpClientHandler httpClientHandler = new HttpClientHandler();
-
-            // Proxy is only set by users and can cause not supported exception on some platforms
-            if (webProxy != null)
-            {
-                httpClientHandler.Proxy = webProxy;
-            }
-
-            // https://docs.microsoft.com/en-us/archive/blogs/timomta/controlling-the-number-of-outgoing-connections-from-httpclient-net-core-or-full-framework
+            HttpClientHandler httpClientHandler;
             try
             {
-                httpClientHandler.MaxConnectionsPerServer = gatewayModeMaxConnectionLimit;
-                if (serverCertificateCustomValidationCallback != null)
+                Type socketHandlerType = Type.GetType("System.Net.Http.SocketsHttpHandler, System.Net.Http");
+
+                object socketHttpHandler = Activator.CreateInstance(socketHandlerType);
+
+                PropertyInfo pooledConnectionLifetimeInfo = socketHandlerType.GetProperty("PooledConnectionLifetime");
+                pooledConnectionLifetimeInfo.SetValue(socketHttpHandler, TimeSpan.FromMinutes(5), null);
+
+                // Proxy is only set by users and can cause not supported exception on some platforms
+                if (webProxy != null)
                 {
-                    httpClientHandler.ServerCertificateCustomValidationCallback = (_, certificate2, x509Chain, sslPolicyErrors) => serverCertificateCustomValidationCallback(certificate2, x509Chain, sslPolicyErrors);
+                    PropertyInfo webProxyInfo = socketHandlerType.GetProperty("Proxy");
+                    webProxyInfo.SetValue(socketHttpHandler, webProxy, null);
                 }
+
+                // https://docs.microsoft.com/en-us/archive/blogs/timomta/controlling-the-number-of-outgoing-connections-from-httpclient-net-core-or-full-framework
+                try
+                {
+                    PropertyInfo maxConnectionsPerSercerInfo = socketHandlerType.GetProperty("MaxConnectionsPerServer");
+                    maxConnectionsPerSercerInfo.SetValue(socketHttpHandler, gatewayModeMaxConnectionLimit, null);
+
+                    if (serverCertificateCustomValidationCallback != null)
+                    {
+                        Func<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, bool> customCertificateValidationCallback =
+                            (_, certificate2, x509Chain, sslPolicyErrors) => serverCertificateCustomValidationCallback(certificate2, x509Chain, sslPolicyErrors);
+
+                        PropertyInfo serverCertificateCustomValidationCallbackInfo = socketHandlerType.GetProperty("ServerCertificateCustomValidationCallback");
+                        serverCertificateCustomValidationCallbackInfo.SetValue(socketHttpHandler,
+                            customCertificateValidationCallback,
+                            null);                        
+                    }
+                }
+                // MaxConnectionsPerServer is not supported on some platforms.
+                catch (PlatformNotSupportedException)
+                {
+                }
+
+                return (HttpMessageHandler)socketHttpHandler;
+
             }
-            // MaxConnectionsPerServer is not supported on some platforms.
-            catch (PlatformNotSupportedException)
+            catch
             {
-            }
+                httpClientHandler = new HttpClientHandler();
+
+                // Proxy is only set by users and can cause not supported exception on some platforms
+                if (webProxy != null)
+                {
+                    httpClientHandler.Proxy = webProxy;
+                }
+
+                // https://docs.microsoft.com/en-us/archive/blogs/timomta/controlling-the-number-of-outgoing-connections-from-httpclient-net-core-or-full-framework
+                try
+                {
+                    httpClientHandler.MaxConnectionsPerServer = gatewayModeMaxConnectionLimit;
+                    if (serverCertificateCustomValidationCallback != null)
+                    {
+                        httpClientHandler.ServerCertificateCustomValidationCallback = (_, certificate2, x509Chain, sslPolicyErrors) => serverCertificateCustomValidationCallback(certificate2, x509Chain, sslPolicyErrors);
+                    }
+                }
+                // MaxConnectionsPerServer is not supported on some platforms.
+                catch (PlatformNotSupportedException)
+                {
+                }
 
-            return httpClientHandler;
+                return httpClientHandler;
+            }           
         }
 
         private static HttpMessageHandler CreateHttpMessageHandler(

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/ClientTests.cs

@@ -74,6 +74,9 @@ public async Task ValidateExceptionOnInitTask()
                 Assert.IsFalse(object.ReferenceEquals(ex, cosmosException1));
                 Assert.IsTrue(httpCallCount > 0);
             }
+
+            //Test cleanup
+            cosmosClient.Dispose();
         }
 
         [TestMethod]
@@ -154,6 +157,9 @@ public async Task InitTaskThreadSafe()
                 this.TaskStartedCount = 0;
                 httpCallCount = 0;
             }
+
+            //Test cleanup
+            cosmosClient.Dispose();
         }
 
 
@@ -287,6 +293,9 @@ public async Task ValidateAzureKeyCredentialDirectModeUpdateAsync()
                     masterKeyCredential.Update(authKey);
                     await TestCommon.DeleteDatabaseAsync(client, client.GetDatabase(databaseName));
                 }
+
+                //Test cleanup
+                client.Dispose();
             }
         }
 
@@ -338,6 +347,9 @@ public async Task ResourceResponseStreamingTest()
                 {
                     Console.WriteLine("Expected exception while deserializing Resource: " + ex.Message);
                 }
+
+                //Test cleanup
+                client.Dispose();
             }
         }
 
@@ -382,6 +394,9 @@ public async Task TestHeadersPassedinByClient()
             ulong capability = ulong.Parse(sdkSupportedCapability);
 
             Assert.AreEqual((ulong)SDKSupportedCapabilities.PartitionMerge, capability & (ulong)SDKSupportedCapabilities.PartitionMerge,$" received header value as {sdkSupportedCapability}");
+
+            //Test cleanup
+            cosmosClient.Dispose();
         }
 
         [TestMethod]
@@ -445,6 +460,9 @@ internal async Task TestEtagOnUpsertOperation(bool useGateway, Protocol protocol
                 {
                     await client.DeleteDatabaseAsync(db);
                 }
+
+                //Test cleanup
+                client.Dispose();
             }
         }
 
@@ -487,6 +505,8 @@ public async Task Verify_CertificateCallBackGetsCalled_ForTCP_HTTP()
                 await database?.DeleteStreamAsync();
             }
 
+            //Test cleanup
+            cosmosClient.Dispose();
         }
 
         [TestMethod]
@@ -857,6 +877,9 @@ public async Task HttpClientFactorySmokeTest()
                     await database.DeleteAsync();
                 }
             }
+
+            //Test cleanup
+            cosmosClient.Dispose();
         }
 
         [TestMethod]
@@ -878,7 +901,7 @@ public async Task HttpClientConnectionLimitTest()
             ))
             {
                 CosmosHttpClient cosmosHttpClient = cosmosClient.DocumentClient.httpClient;
-                HttpClientHandler httpClientHandler = (HttpClientHandler)cosmosHttpClient.HttpMessageHandler;
+                SocketsHttpHandler httpClientHandler = (SocketsHttpHandler)cosmosHttpClient.HttpMessageHandler;
                 Assert.AreEqual(gatewayConnectionLimit, httpClientHandler.MaxConnectionsPerServer);
 
                 Cosmos.Database database = await cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString());
@@ -897,6 +920,7 @@ public async Task HttpClientConnectionLimitTest()
 
                 // Clean up the database and container
                 await database.DeleteAsync();
+                cosmosClient.Dispose();
             }
 
 
@@ -907,6 +931,23 @@ public async Task HttpClientConnectionLimitTest()
                 $"Before connections: {JsonConvert.SerializeObject(excludeConnections)}; After connections: {JsonConvert.SerializeObject(afterConnections)}");
         }
 
+        [TestMethod]
+        public void PooledConnectionLifetimeTest()
+        {
+            //Create Cosmos Client
+            using CosmosClient cosmosClient = new CosmosClient(
+                accountEndpoint: "https://localhost:8081",
+                authKeyOrResourceToken: Convert.ToBase64String(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())));
+
+            //Assert type of message handler
+            Type socketHandlerType = Type.GetType("System.Net.Http.SocketsHttpHandler, System.Net.Http");
+            Type clientMessageHandlerType = cosmosClient.ClientContext.DocumentClient.httpClient.HttpMessageHandler.GetType();
+            Assert.AreEqual(socketHandlerType, clientMessageHandlerType);
+
+            //Test cleanup
+            cosmosClient.Dispose();
+        }
+
         public static IReadOnlyList<string> GetActiveConnections()
         {
             string testPid = Process.GetCurrentProcess().Id.ToString();