CSHARP-3754: Implemented srvMaxHosts for both initial seedlist and SRV polling. (#666)

Author: JamesKovacs

src/MongoDB.Driver.Core/Core/Clusters/LoadBalancedCluster.cs

@@ -86,6 +86,7 @@ public LoadBalancedCluster(
 
             Ensure.IsEqualTo(settings.EndPoints.Count, 1, nameof(settings.EndPoints.Count));
             Ensure.IsNull(settings.ReplicaSetName, nameof(settings.ReplicaSetName));
+            Ensure.That(settings.SrvMaxHosts == 0, "srvMaxHosts cannot be used with load balanced mode.");
 
             _clusterClock = new ClusterClock();
             _clusterId = new ClusterId();

src/MongoDB.Driver.Core/Core/Clusters/MultiServerCluster.cs

@@ -576,18 +576,24 @@ void IDnsMonitoringCluster.ProcessDnsResults(List<DnsEndPoint> dnsEndPoints)
                 var newClusterDescription = oldClusterDescription;
                 var currentEndPoints = oldClusterDescription.Servers.Select(serverDescription => serverDescription.EndPoint).ToList();
 
-                var endPointsToAdd = dnsEndPoints.Where(endPoint => !currentEndPoints.Contains(endPoint));
-                foreach (var endPoint in endPointsToAdd)
-                {
-                    newClusterDescription = EnsureServer(newClusterDescription, endPoint, newServers);
-                }
-
                 var endPointsToRemove = currentEndPoints.Where(endPoint => !dnsEndPoints.Contains(endPoint));
                 foreach (var endPoint in endPointsToRemove)
                 {
                     newClusterDescription = RemoveServer(newClusterDescription, endPoint, "Server no longer appears in the DNS SRV records.");
                 }
 
+                var endPointsToAdd = dnsEndPoints.Where(endPoint => !currentEndPoints.Contains(endPoint)).ToList();
+                var srvMaxHosts = Settings.SrvMaxHosts;
+                if (srvMaxHosts > 0)
+                {
+                    FisherYatesShuffle.Shuffle(endPointsToAdd);
+                    endPointsToAdd = endPointsToAdd.Take(srvMaxHosts - currentEndPoints.Count + endPointsToRemove.Count()).ToList();
+                }
+                foreach (var endPoint in endPointsToAdd)
+                {
+                    newClusterDescription = EnsureServer(newClusterDescription, endPoint, newServers);
+                }
+
                 newClusterDescription = newClusterDescription.WithDnsMonitorException(null);
                 UpdateClusterDescription(newClusterDescription);
             }

src/MongoDB.Driver.Core/Core/Clusters/SingleServerCluster.cs

@@ -46,6 +46,7 @@ internal sealed class SingleServerCluster : Cluster
         internal SingleServerCluster(ClusterSettings settings, IClusterableServerFactory serverFactory, IEventSubscriber eventSubscriber)
             : base(settings, serverFactory, eventSubscriber)
         {
+            Ensure.That(settings.SrvMaxHosts == 0, "srvMaxHosts cannot be used with a single server cluster.");
             Ensure.IsEqualTo(settings.EndPoints.Count, 1, "settings.EndPoints.Count");
             _replicaSetName = settings.ReplicaSetName;  // can be null
 

src/MongoDB.Driver.Core/Core/Configuration/ClusterSettings.cs

@@ -50,6 +50,7 @@ public class ClusterSettings
         private readonly ConnectionStringScheme _scheme;
         private readonly ServerApi _serverApi;
         private readonly TimeSpan _serverSelectionTimeout;
+        private readonly int _srvMaxHosts;
         private readonly IServerSelector _preServerSelector;
         private readonly IServerSelector _postServerSelector;
 
@@ -72,6 +73,7 @@ public class ClusterSettings
         /// <param name="postServerSelector">The post server selector.</param>
         /// <param name="schemaMap">The schema map.</param>
         /// <param name="scheme">The connection string scheme.</param>
+        /// <param name="srvMaxHosts">Limits the number of SRV records used to populate the seedlist during initial discovery, as well as the number of additional hosts that may be added during SRV polling.</param>
         public ClusterSettings(
 #pragma warning disable CS0618 // Type or member is obsolete
             Optional<ClusterConnectionMode> connectionMode = default(Optional<ClusterConnectionMode>),
@@ -89,25 +91,27 @@ public ClusterSettings(
             Optional<IServerSelector> preServerSelector = default(Optional<IServerSelector>),
             Optional<IServerSelector> postServerSelector = default(Optional<IServerSelector>),
             Optional<IReadOnlyDictionary<string, BsonDocument>> schemaMap = default(Optional<IReadOnlyDictionary<string, BsonDocument>>),
-            Optional<ConnectionStringScheme> scheme = default(Optional<ConnectionStringScheme>))
+            Optional<ConnectionStringScheme> scheme = default(Optional<ConnectionStringScheme>),
+            Optional<int> srvMaxHosts = default)
         {
 #pragma warning disable CS0618 // Type or member is obsolete
             _connectionMode = connectionMode.WithDefault(ClusterConnectionMode.Automatic);
             _connectionModeSwitch = connectionModeSwitch.WithDefault(ConnectionModeSwitch.NotSet);
 #pragma warning restore CS0618 // Type or member is obsolete
             _directConnection = directConnection.WithDefault(null);
-            _endPoints = Ensure.IsNotNull(endPoints.WithDefault(__defaultEndPoints), "endPoints").ToList();
+            _endPoints = Ensure.IsNotNull(endPoints.WithDefault(__defaultEndPoints), nameof(endPoints)).ToList();
             _kmsProviders = kmsProviders.WithDefault(null);
             _loadBalanced = loadBalanced.WithDefault(false);
-            _localThreshold = Ensure.IsInfiniteOrGreaterThanOrEqualToZero(localThreshold.WithDefault(TimeSpan.FromMilliseconds(15)), "localThreshold");
-            _maxServerSelectionWaitQueueSize = Ensure.IsGreaterThanOrEqualToZero(maxServerSelectionWaitQueueSize.WithDefault(500), "maxServerSelectionWaitQueueSize");
+            _localThreshold = Ensure.IsInfiniteOrGreaterThanOrEqualToZero(localThreshold.WithDefault(TimeSpan.FromMilliseconds(15)), nameof(localThreshold));
+            _maxServerSelectionWaitQueueSize = Ensure.IsGreaterThanOrEqualToZero(maxServerSelectionWaitQueueSize.WithDefault(500), nameof(maxServerSelectionWaitQueueSize));
             _replicaSetName = replicaSetName.WithDefault(null);
             _serverApi = serverApi.WithDefault(null);
-            _serverSelectionTimeout = Ensure.IsGreaterThanOrEqualToZero(serverSelectionTimeout.WithDefault(TimeSpan.FromSeconds(30)), "serverSelectionTimeout");
+            _serverSelectionTimeout = Ensure.IsGreaterThanOrEqualToZero(serverSelectionTimeout.WithDefault(TimeSpan.FromSeconds(30)), nameof(serverSelectionTimeout));
             _preServerSelector = preServerSelector.WithDefault(null);
             _postServerSelector = postServerSelector.WithDefault(null);
             _scheme = scheme.WithDefault(ConnectionStringScheme.MongoDB);
             _schemaMap = schemaMap.WithDefault(null);
+            _srvMaxHosts = Ensure.IsGreaterThanOrEqualToZero(srvMaxHosts.WithDefault(0), nameof(srvMaxHosts));
 
             ClusterConnectionModeHelper.EnsureConnectionModeValuesAreValid(_connectionMode, _connectionModeSwitch, _directConnection);
         }
@@ -265,6 +269,13 @@ public TimeSpan ServerSelectionTimeout
             get { return _serverSelectionTimeout; }
         }
 
+        /// <summary>
+        /// Limits the number of SRV records used to populate the seedlist
+        /// during initial discovery, as well as the number of additional hosts
+        /// that may be added during SRV polling.
+        /// </summary>
+        public int SrvMaxHosts => _srvMaxHosts;
+
         /// <summary>
         /// Gets the pre server selector.
         /// </summary>
@@ -306,6 +317,7 @@ public IServerSelector PostServerSelector
         /// <param name="postServerSelector">The post server selector.</param>
         /// <param name="schemaMap">The schema map.</param>
         /// <param name="scheme">The connection string scheme.</param>
+        /// <param name="srvMaxHosts">Limits the number of SRV records used to populate the seedlist during initial discovery, as well as the number of additional hosts that may be added during SRV polling.</param>
         /// <returns>A new ClusterSettings instance.</returns>
         public ClusterSettings With(
 #pragma warning disable CS0618 // Type or member is obsolete
@@ -324,7 +336,8 @@ public ClusterSettings With(
             Optional<IServerSelector> preServerSelector = default(Optional<IServerSelector>),
             Optional<IServerSelector> postServerSelector = default(Optional<IServerSelector>),
             Optional<IReadOnlyDictionary<string, BsonDocument>> schemaMap = default(Optional<IReadOnlyDictionary<string, BsonDocument>>),
-            Optional<ConnectionStringScheme> scheme = default(Optional<ConnectionStringScheme>))
+            Optional<ConnectionStringScheme> scheme = default(Optional<ConnectionStringScheme>),
+            Optional<int> srvMaxHosts = default)
         {
             return new ClusterSettings(
                 connectionMode: connectionMode.WithDefault(_connectionMode),
@@ -341,7 +354,8 @@ public ClusterSettings With(
                 preServerSelector: Optional.Create(preServerSelector.WithDefault(_preServerSelector)),
                 postServerSelector: Optional.Create(postServerSelector.WithDefault(_postServerSelector)),
                 schemaMap: Optional.Create(schemaMap.WithDefault(_schemaMap)),
-                scheme: scheme.WithDefault(_scheme));
+                scheme: scheme.WithDefault(_scheme),
+                srvMaxHosts: srvMaxHosts.WithDefault(_srvMaxHosts));
         }
 
         // internal methods

src/MongoDB.Driver.Core/Core/Configuration/ConnectionString.cs

@@ -26,7 +26,6 @@
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Compression;
 using MongoDB.Driver.Core.Misc;
-using MongoDB.Shared;
 
 namespace MongoDB.Driver.Core.Configuration
 {
@@ -80,7 +79,8 @@ public sealed class ConnectionString
         private TimeSpan? _heartbeatTimeout;
         private IReadOnlyList<EndPoint> _hosts;
         private bool? _ipv6;
-        private bool _isResolved;
+        private readonly bool _isInternalRepresentation;
+        private readonly bool _isResolved;
         private bool? _journal;
         private bool _loadBalanced;
         private TimeSpan? _localThreshold;
@@ -100,6 +100,7 @@ public sealed class ConnectionString
         private ConnectionStringScheme _scheme;
         private TimeSpan? _serverSelectionTimeout;
         private TimeSpan? _socketTimeout;
+        private int? _srvMaxHosts;
         private bool? _tls;
         private bool? _tlsDisableCertificateRevocationCheck;
         private bool? _tlsInsecure;
@@ -116,13 +117,14 @@ public sealed class ConnectionString
         /// Initializes a new instance of the <see cref="ConnectionString" /> class.
         /// </summary>
         /// <param name="connectionString">The connection string.</param>
-        public ConnectionString(string connectionString) : this(connectionString, DnsClientWrapper.Instance)
+        public ConnectionString(string connectionString) : this(connectionString, false, DnsClientWrapper.Instance)
         {
         }
 
-        internal ConnectionString(string connectionString, IDnsResolver dnsResolver)
+        internal ConnectionString(string connectionString, bool isInternalRepresentation, IDnsResolver dnsResolver)
         {
             _originalConnectionString = Ensure.IsNotNull(connectionString, nameof(connectionString));
+            _isInternalRepresentation = isInternalRepresentation;
 
             _allOptions = new NameValueCollection(StringComparer.OrdinalIgnoreCase);
             _unknownOptions = new NameValueCollection(StringComparer.OrdinalIgnoreCase);
@@ -140,7 +142,7 @@ internal ConnectionString(string connectionString, IDnsResolver dnsResolver)
         /// <param name="connectionString">The connection string.</param>
         /// <param name="isResolved">Whether the connection string is resolved.</param>
         internal ConnectionString(string connectionString, bool isResolved)
-            : this(connectionString)
+            : this(connectionString, true, DnsClientWrapper.Instance)
         {
             if (!isResolved && _scheme != ConnectionStringScheme.MongoDBPlusSrv)
             {
@@ -294,7 +296,7 @@ public TimeSpan? HeartbeatTimeout
         /// </summary>
         public IReadOnlyList<EndPoint> Hosts
         {
-            get { return _hosts; }
+            get { return _srvMaxHosts > 0 ? _hosts.Take(_srvMaxHosts.Value).ToList() : _hosts; }
         }
 
         /// <summary>
@@ -466,6 +468,13 @@ public TimeSpan? SocketTimeout
             get { return _socketTimeout; }
         }
 
+        /// <summary>
+        /// Limits the number of SRV records used to populate the seedlist
+        /// during initial discovery, as well as the number of additional hosts
+        /// that may be added during SRV polling.
+        /// </summary>
+        public int? SrvMaxHosts => _srvMaxHosts;
+
         /// <summary>
         /// Gets whether to use SSL.
         /// </summary>
@@ -685,7 +694,7 @@ private ConnectionString BuildResolvedConnectionString(ConnectionStringScheme re
             connectionString += string.Join(",", resolvedHosts) + "/";
             if (_databaseName != null)
             {
-                connectionString += Uri.EscapeDataString(_databaseName) + "/";
+                connectionString += Uri.EscapeDataString(_databaseName);
             }
 
             // remove any option from the resolved options that was specified locally
@@ -899,6 +908,16 @@ private void Parse()
                 throw new MongoConfigurationException("Direct connect cannot be used with multiple host names.");
             }
 
+            if (!_isInternalRepresentation && _srvMaxHosts > 0 && _scheme != ConnectionStringScheme.MongoDBPlusSrv)
+            {
+                throw new MongoConfigurationException("srvMaxHosts can only be used with the mongodb+srv scheme.");
+            }
+
+            if (_replicaSet != null && _srvMaxHosts > 0)
+            {
+                throw new MongoConfigurationException("Specifying srvMaxHosts when connecting to a replica set is invalid.");
+            }
+
             if (_loadBalanced)
             {
                 if (_hosts.Count > 1)
@@ -911,6 +930,11 @@ private void Parse()
                     throw new MongoConfigurationException("ReplicaSetName cannot be used with load balanced mode.");
                 }
 
+                if (_srvMaxHosts > 0)
+                {
+                    throw new MongoConfigurationException("srvMaxHosts cannot be used with load balanced mode.");
+                }
+
                 if (IsDirectConnection())
                 {
                     throw new MongoConfigurationException("Load balanced mode cannot be used with direct connection.");
@@ -1081,6 +1105,14 @@ private void ParseOption(string name, string value)
                 case "sockettimeoutms":
                     _socketTimeout = ParseTimeSpan(name, value);
                     break;
+                case "srvmaxhosts":
+                    var srvMaxHostsValue = ParseInt32(name, value);
+                    if (srvMaxHostsValue < 0)
+                    {
+                        throw new MongoConfigurationException("srvMaxHosts must be greater than or equal to 0.");
+                    }
+                    _srvMaxHosts = srvMaxHostsValue;
+                    break;
                 case "ssl": // Obsolete
                 case "tls":
                     var tlsValue = ParseBoolean(name, value);
@@ -1319,6 +1351,11 @@ private List<string> GetHostsFromSrvRecords(IEnumerable<SrvRecord> srvRecords)
                 hosts.Add(h + ":" + srvRecord.EndPoint.Port);
             }
 
+            if (_srvMaxHosts > 0)
+            {
+                FisherYatesShuffle.Shuffle(hosts);
+            }
+
             return hosts;
         }
 

src/MongoDB.Driver.Core/Core/Misc/FisherYatesShuffle.cs

@@ -0,0 +1,36 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System.Collections.Generic;
+
+namespace MongoDB.Driver.Core.Misc
+{
+    internal static class FisherYatesShuffle
+    {
+        public static void Shuffle<T>(IList<T> list)
+        {
+            Ensure.IsNotNull(list, nameof(list));
+
+            for (var i = list.Count - 1; i > 0; i--)
+            {
+                var j = ThreadStaticRandom.Next(i + 1);
+                if (i != j)
+                {
+                    (list[j], list[i]) = (list[i], list[j]);
+                }
+            }
+        }
+    }
+}

src/MongoDB.Driver.Legacy/MongoServerSettings.cs

@@ -1219,6 +1219,7 @@ internal ClusterKey ToClusterKey()
                 _servers.ToList(),
                 _serverSelectionTimeout,
                 _socketTimeout,
+                srvMaxHosts: 0, // not supported for legacy
                 _sslSettings,
                 _useTls,
                 _waitQueueSize,

src/MongoDB.Driver/ClusterKey.cs

@@ -60,6 +60,7 @@ internal class ClusterKey
         private readonly IReadOnlyList<MongoServerAddress> _servers;
         private readonly TimeSpan _serverSelectionTimeout;
         private readonly TimeSpan _socketTimeout;
+        private readonly int _srvMaxHosts;
         private readonly SslSettings _sslSettings;
         private readonly bool _useTls;
         private readonly int _waitQueueSize;
@@ -99,6 +100,7 @@ public ClusterKey(
             IReadOnlyList<MongoServerAddress> servers,
             TimeSpan serverSelectionTimeout,
             TimeSpan socketTimeout,
+            int srvMaxHosts,
             SslSettings sslSettings,
             bool useTls,
             int waitQueueSize,
@@ -136,6 +138,7 @@ public ClusterKey(
             _servers = servers;
             _serverSelectionTimeout = serverSelectionTimeout;
             _socketTimeout = socketTimeout;
+            _srvMaxHosts = srvMaxHosts;
             _sslSettings = sslSettings;
             _useTls = useTls;
             _waitQueueSize = waitQueueSize;
@@ -199,6 +202,7 @@ public bool? DirectConnection
         public IReadOnlyList<MongoServerAddress> Servers { get { return _servers; } }
         public TimeSpan ServerSelectionTimeout { get { return _serverSelectionTimeout; } }
         public TimeSpan SocketTimeout { get { return _socketTimeout; } }
+        public int SrvMaxHosts { get { return _srvMaxHosts; } }
         public SslSettings SslSettings { get { return _sslSettings; } }
         public bool UseTls => _useTls;
         public int WaitQueueSize { get { return _waitQueueSize; } }
@@ -253,6 +257,7 @@ public override bool Equals(object obj)
                 _servers.SequenceEqual(rhs._servers) &&
                 _serverSelectionTimeout == rhs._serverSelectionTimeout &&
                 _socketTimeout == rhs._socketTimeout &&
+                _srvMaxHosts == rhs._srvMaxHosts &&
                 object.Equals(_sslSettings, rhs._sslSettings) &&
                 _useTls == rhs._useTls &&
                 _waitQueueSize == rhs._waitQueueSize &&