CSHARP-1888: ServerMonitor should use HeartbeatTimeout for socket read/write timeouts.

Author: rstam

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

@@ -18,6 +18,8 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
+using MongoDB.Driver.Core.Authentication;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.ConnectionPools;
 using MongoDB.Driver.Core.Connections;
@@ -63,48 +65,14 @@ public ClusterBuilder()
             _eventAggregator = new EventAggregator();
         }
 
-        // methods
+        // public methods
         /// <summary>
         /// Builds the cluster.
         /// </summary>
         /// <returns>A cluster.</returns>
         public ICluster BuildCluster()
         {
-            IStreamFactory streamFactory = new TcpStreamFactory(_tcpStreamSettings);
-            if (_sslStreamSettings != null)
-            {
-                streamFactory = new SslStreamFactory(_sslStreamSettings, streamFactory);
-            }
-
-            streamFactory = _streamFactoryWrapper(streamFactory);
-
-            var connectionFactory = new BinaryConnectionFactory(
-                _connectionSettings,
-                streamFactory,
-                _eventAggregator);
-
-            var connectionPoolFactory = new ExclusiveConnectionPoolFactory(
-                _connectionPoolSettings,
-                connectionFactory,
-                _eventAggregator);
-
-            var serverMonitorFactory = new ServerMonitorFactory(
-                _serverSettings,
-                connectionFactory,
-                _eventAggregator);
-
-            var serverFactory = new ServerFactory(
-                _clusterSettings.ConnectionMode,
-                _serverSettings,
-                connectionPoolFactory,
-                serverMonitorFactory,
-                _eventAggregator);
-
-            var clusterFactory = new ClusterFactory(
-                _clusterSettings,
-                serverFactory,
-                _eventAggregator);
-
+            var clusterFactory = CreateClusterFactory();
             return clusterFactory.CreateCluster();
         }
 
@@ -242,5 +210,90 @@ public ClusterBuilder Subscribe(IEventSubscriber subscriber)
             _eventAggregator.Subscribe(subscriber);
             return this;
         }
+
+        // private methods
+        private IClusterFactory CreateClusterFactory()
+        {
+            var serverFactory = CreateServerFactory();
+
+            return new ClusterFactory(
+                _clusterSettings,
+                serverFactory,
+                _eventAggregator);
+        }
+
+        private IConnectionPoolFactory CreateConnectionPoolFactory()
+        {
+            var streamFactory = CreateTcpStreamFactory(_tcpStreamSettings);
+
+            var connectionFactory = new BinaryConnectionFactory(
+                _connectionSettings,
+                streamFactory,
+                _eventAggregator);
+
+            return new ExclusiveConnectionPoolFactory(
+                _connectionPoolSettings,
+                connectionFactory,
+                _eventAggregator);
+        }
+
+        private ServerFactory CreateServerFactory()
+        {
+            var connectionPoolFactory = CreateConnectionPoolFactory();
+            var serverMonitorFactory = CreateServerMonitorFactory();
+
+            return new ServerFactory(
+                _clusterSettings.ConnectionMode,
+                _serverSettings,
+                connectionPoolFactory,
+                serverMonitorFactory,
+                _eventAggregator);
+        }
+
+        private IServerMonitorFactory CreateServerMonitorFactory()
+        {
+            var serverMonitorConnectionSettings = _connectionSettings
+                .With(authenticators: new IAuthenticator[] { });
+
+            var heartbeatConnectTimeout = _tcpStreamSettings.ConnectTimeout;
+            if (heartbeatConnectTimeout == TimeSpan.Zero || heartbeatConnectTimeout == Timeout.InfiniteTimeSpan)
+            {
+                heartbeatConnectTimeout = TimeSpan.FromSeconds(30);
+            }
+            var heartbeatSocketTimeout = _serverSettings.HeartbeatTimeout;
+            if (heartbeatSocketTimeout == TimeSpan.Zero || heartbeatSocketTimeout == Timeout.InfiniteTimeSpan)
+            {
+                heartbeatSocketTimeout = heartbeatConnectTimeout;
+            }
+            var serverMonitorTcpStreamSettings = new TcpStreamSettings(_tcpStreamSettings)
+                .With(
+                    connectTimeout: heartbeatConnectTimeout,
+                    readTimeout: heartbeatSocketTimeout,
+                    writeTimeout: heartbeatSocketTimeout
+                );
+
+            var serverMonitorStreamFactory = CreateTcpStreamFactory(serverMonitorTcpStreamSettings);
+
+            var serverMonitorConnectionFactory = new BinaryConnectionFactory(
+                serverMonitorConnectionSettings,
+                serverMonitorStreamFactory,
+                new EventAggregator());
+
+            return new ServerMonitorFactory(
+                _serverSettings,
+                serverMonitorConnectionFactory,
+                _eventAggregator);
+        }
+
+        private IStreamFactory CreateTcpStreamFactory(TcpStreamSettings tcpStreamSettings)
+        {
+            var streamFactory = (IStreamFactory)new TcpStreamFactory(tcpStreamSettings);
+            if (_sslStreamSettings != null)
+            {
+                streamFactory = new SslStreamFactory(_sslStreamSettings, streamFactory);
+            }
+
+            return _streamFactoryWrapper(streamFactory);
+        }
     }
 }

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

@@ -15,6 +15,7 @@
 
 using System;
 using System.Net.Sockets;
+using System.Threading;
 using MongoDB.Driver.Core.Misc;
 
 namespace MongoDB.Driver.Core.Configuration
@@ -34,7 +35,7 @@ public class ServerSettings
         /// <summary>
         /// Gets the default heartbeat timeout.
         /// </summary>
-        public static TimeSpan DefaultHeartbeatTimeout => TimeSpan.FromSeconds(10);
+        public static TimeSpan DefaultHeartbeatTimeout => Timeout.InfiniteTimeSpan;
         #endregion
 
         // fields

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

@@ -63,6 +63,17 @@ public TcpStreamSettings(
             _writeTimeout = Ensure.IsNullOrInfiniteOrGreaterThanOrEqualToZero(writeTimeout.WithDefault(null), "writeTimeout");
         }
 
+        internal TcpStreamSettings(TcpStreamSettings other)
+        {
+            _addressFamily = other.AddressFamily;
+            _connectTimeout = other.ConnectTimeout;
+            _readTimeout = other.ReadTimeout;
+            _receiveBufferSize = other.ReceiveBufferSize;
+            _sendBufferSize = other.SendBufferSize;
+            _socketConfigurator = other.SocketConfigurator;
+            _writeTimeout = other.WriteTimeout;
+        }
+
         // properties
         /// <summary>
         /// Gets the address family.

src/MongoDB.Driver/MongoClientSettings.cs

@@ -241,7 +241,7 @@ public TimeSpan HeartbeatTimeout
             set
             {
                 if (_isFrozen) { throw new InvalidOperationException("MongoClientSettings is frozen."); }
-                _heartbeatTimeout = Ensure.IsGreaterThanZero(value, nameof(value));
+                _heartbeatTimeout = Ensure.IsInfiniteOrGreaterThanZero(value, nameof(value));
             }
         }
 

tests/MongoDB.Driver.Core.Tests/Core/Configuration/ClusterBuilderTests.cs

@@ -0,0 +1,68 @@
+/* Copyright 2018-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;
+using FluentAssertions;
+using MongoDB.Bson.TestHelpers;
+using MongoDB.Driver.Core.Authentication;
+using MongoDB.Driver.Core.Connections;
+using MongoDB.Driver.Core.Servers;
+using Xunit;
+
+namespace MongoDB.Driver.Core.Configuration
+{
+    public class ClusterBuilderTests
+    {
+        [Theory]
+        [InlineData(0, 0, 30000, 30000)]
+        [InlineData(-1, -1, 30000, 30000)]
+        [InlineData(20000, 0, 20000, 20000)]
+        [InlineData(20000, -1, 20000, 20000)]
+        [InlineData(20000, 10000, 20000, 10000)]
+        public void CreateServerMonitorFactory_should_return_expected_result(int connectTimeoutMilliseconds, int heartbeatTimeoutMilliseconds, int expectedServerMonitorConnectTimeoutMilliseconds, int expectedServerMonitorSocketTimeoutMilliseconds)
+        {
+            var connectTimeout = TimeSpan.FromMilliseconds(connectTimeoutMilliseconds);
+            var authenticators = new[] { new DefaultAuthenticator(new UsernamePasswordCredential("source", "username", "password")) };
+            var heartbeatTimeout = TimeSpan.FromMilliseconds(heartbeatTimeoutMilliseconds);
+            var expectedServerMonitorConnectTimeout = TimeSpan.FromMilliseconds(expectedServerMonitorConnectTimeoutMilliseconds);
+            var expectedServerMonitorSocketTimeout = TimeSpan.FromMilliseconds(expectedServerMonitorSocketTimeoutMilliseconds);
+            var subject = new ClusterBuilder()
+                .ConfigureTcp(s => s.With(connectTimeout: connectTimeout))
+                .ConfigureConnection(s => s.With(authenticators: authenticators))
+                .ConfigureServer(s => s.With(heartbeatTimeout: heartbeatTimeout));
+
+            var result = (ServerMonitorFactory)subject.CreateServerMonitorFactory();
+
+            var serverMonitorConnectionFactory = (BinaryConnectionFactory)result._connectionFactory();
+            var serverMonitorConnectionSettings = serverMonitorConnectionFactory._settings();
+            serverMonitorConnectionSettings.Authenticators.Should().HaveCount(0);
+
+            var serverMonitorStreamFactory = (TcpStreamFactory)serverMonitorConnectionFactory._streamFactory();
+            var serverMonitorTcpStreamSettings = serverMonitorStreamFactory._settings();
+            serverMonitorTcpStreamSettings.ConnectTimeout.Should().Be(expectedServerMonitorConnectTimeout);
+            serverMonitorTcpStreamSettings.ReadTimeout.Should().Be(expectedServerMonitorSocketTimeout);
+            serverMonitorTcpStreamSettings.WriteTimeout.Should().Be(expectedServerMonitorSocketTimeout);
+
+            var eventSuscriber = result._eventSubscriber();
+
+            var serverSettings = result._settings();
+        }
+    }
+
+    public static class ClusterBuilderReflector
+    {
+        internal static IServerMonitorFactory CreateServerMonitorFactory(this ClusterBuilder obj) => (IServerMonitorFactory)Reflector.Invoke(obj, nameof(CreateServerMonitorFactory));
+    }
+}

tests/MongoDB.Driver.Core.Tests/Core/Configuration/ServerSettingsTests.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using System.Threading;
 using FluentAssertions;
 using Xunit;
 
@@ -34,7 +35,7 @@ public void DefaultHeartbeatTimeout_should_return_expected_result()
         {
             var result = ServerSettings.DefaultHeartbeatTimeout;
 
-            result.Should().Be(TimeSpan.FromSeconds(10));
+            result.Should().Be(Timeout.InfiniteTimeSpan);
         }
 
         [Fact]
@@ -49,15 +50,15 @@ public void constructor_should_initialize_instance()
         [Fact]
         public void constructor_should_throw_when_heartbeatInterval_is_negative()
         {
-            Action action = () => new ServerSettings(heartbeatInterval: TimeSpan.FromSeconds(-1));
+            Action action = () => new ServerSettings(heartbeatInterval: TimeSpan.FromSeconds(-2));
 
             action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("heartbeatInterval");
         }
 
         [Fact]
         public void constructor_should_throw_when_heartbeatTimeout_is_negative()
         {
-            Action action = () => new ServerSettings(heartbeatTimeout: TimeSpan.FromSeconds(-1));
+            Action action = () => new ServerSettings(heartbeatTimeout: TimeSpan.FromSeconds(-2));
 
             action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("heartbeatTimeout");
         }

tests/MongoDB.Driver.Core.Tests/Core/Configuration/TcpStreamSettingsTests.cs

@@ -40,6 +40,30 @@ public void constructor_should_initialize_instance()
             subject.WriteTimeout.Should().Be(null);
         }
 
+        [Fact]
+        public void constructor_with_other_should_initialize_instance()
+        {
+            var other = new TcpStreamSettings(
+                addressFamily: AddressFamily.InterNetworkV6,
+                connectTimeout: TimeSpan.FromSeconds(123),
+                readTimeout: TimeSpan.FromSeconds(456),
+                receiveBufferSize: 123,
+                sendBufferSize: 456,
+                socketConfigurator: (Action<Socket>)((Socket _) => { }),
+                writeTimeout: TimeSpan.FromSeconds(789)
+            );
+
+            var result = new TcpStreamSettings(other);
+
+            result.AddressFamily.Should().Be(other.AddressFamily);
+            result.ConnectTimeout.Should().Be(other.ConnectTimeout);
+            result.ReadTimeout.Should().Be(other.ReadTimeout);
+            result.ReceiveBufferSize.Should().Be(other.ReceiveBufferSize);
+            result.SendBufferSize.Should().Be(other.SendBufferSize);
+            result.SocketConfigurator.Should().Be(other.SocketConfigurator);
+            result.WriteTimeout.Should().Be(other.WriteTimeout);
+        }
+
         [Fact]
         public void constructor_should_throw_when_connectTimeout_is_negative()
         {

tests/MongoDB.Driver.Core.Tests/Core/Connections/BinaryConnectionFactoryTests.cs

@@ -20,6 +20,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using FluentAssertions;
+using MongoDB.Bson.TestHelpers;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Configuration;
 using MongoDB.Driver.Core.Connections;
@@ -106,4 +107,10 @@ public void CreateConnection_should_return_a_BinaryConnection()
             connection.Should().BeOfType<BinaryConnection>();
         }
     }
+
+    public static class BinaryConnectionFactoryReflector
+    {
+        internal static ConnectionSettings _settings(this BinaryConnectionFactory obj) => (ConnectionSettings)Reflector.GetFieldValue(obj, nameof(_settings));
+        internal static IStreamFactory _streamFactory(this BinaryConnectionFactory obj) => (IStreamFactory)Reflector.GetFieldValue(obj, nameof(_streamFactory));
+    }
 }

tests/MongoDB.Driver.Core.Tests/Core/Connections/TcpStreamFactoryTests.cs

@@ -29,6 +29,7 @@
 using MongoDB.Driver.Core.TestHelpers;
 using MongoDB.Bson.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using MongoDB.Bson.TestHelpers;
 
 namespace MongoDB.Driver.Core.Connections
 {
@@ -185,4 +186,9 @@ public void SocketConfigurator_can_be_used_to_set_keepAlive(
             keepAlive.Should().NotBe(0); // .NET returns 1 but Mono returns 8
         }
     }
+
+    public static class TcpStreamFactoryReflector
+    {
+        internal static TcpStreamSettings _settings(this TcpStreamFactory obj) => (TcpStreamSettings)Reflector.GetFieldValue(obj, nameof(_settings));
+    }
 }

tests/MongoDB.Driver.Core.Tests/Core/Servers/ServerMonitorFactoryTests.cs

@@ -0,0 +1,29 @@
+/* Copyright 2018-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 MongoDB.Bson.TestHelpers;
+using MongoDB.Driver.Core.Configuration;
+using MongoDB.Driver.Core.Connections;
+using MongoDB.Driver.Core.Events;
+
+namespace MongoDB.Driver.Core.Servers
+{
+    public static class ServerMonitorFactoryReflector
+    {
+        internal static IConnectionFactory _connectionFactory(this ServerMonitorFactory obj) => (IConnectionFactory)Reflector.GetFieldValue(obj, nameof(_connectionFactory));
+        internal static IEventSubscriber _eventSubscriber(this ServerMonitorFactory obj) => (IEventSubscriber)Reflector.GetFieldValue(obj, nameof(_eventSubscriber));
+        internal static ServerSettings _settings(this ServerMonitorFactory obj) => (ServerSettings)Reflector.GetFieldValue(obj, nameof(_settings));
+    }
+}