internal void ShouldInvalidateServer_should_return_expected_result_for_MongoCommandException(ServerErrorCode?code, string message, bool expectedResult) { _subject.Initialize(); var clusterId = new ClusterId(1); var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017)); var connectionId = new ConnectionId(serverId); var command = new BsonDocument("command", 1); var commandResult = new BsonDocument { { "ok", 0 }, { "code", () => (int)code.Value, code.HasValue }, { "errmsg", message, message != null } }; var exception = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, command, commandResult, "errmsg") ?? new MongoCommandException(connectionId, "message", command, commandResult); // this needs for cases when we have just a random exception var result = _subject.ShouldInvalidateServer(Mock.Of <IConnection>(), exception, new ServerDescription(_subject.ServerId, _subject.EndPoint), out _); result.Should().Be(expectedResult); }
// constructors public Server(ClusterId clusterId, IClusterClock clusterClock, ClusterConnectionMode clusterConnectionMode, ServerSettings settings, EndPoint endPoint, IConnectionPoolFactory connectionPoolFactory, IServerMonitorFactory serverMonitorFactory, IEventSubscriber eventSubscriber) { Ensure.IsNotNull(clusterId, nameof(clusterId)); _clusterClock = Ensure.IsNotNull(clusterClock, nameof(clusterClock)); _clusterConnectionMode = clusterConnectionMode; _settings = Ensure.IsNotNull(settings, nameof(settings)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); Ensure.IsNotNull(connectionPoolFactory, nameof(connectionPoolFactory)); Ensure.IsNotNull(serverMonitorFactory, nameof(serverMonitorFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _serverId = new ServerId(clusterId, endPoint); _connectionPool = connectionPoolFactory.CreateConnectionPool(_serverId, endPoint); _state = new InterlockedInt32(State.Initial); _monitor = serverMonitorFactory.Create(_serverId, _endPoint); eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _descriptionChangedEventHandler); }
public ServerMonitor( ServerId serverId, EndPoint endPoint, IConnectionFactory connectionFactory, ServerMonitorSettings serverMonitorSettings, IEventSubscriber eventSubscriber, ServerApi serverApi) : this( serverId, endPoint, connectionFactory, serverMonitorSettings, eventSubscriber, roundTripTimeMonitor : new RoundTripTimeMonitor( connectionFactory, serverId, endPoint, Ensure.IsNotNull(serverMonitorSettings, nameof(serverMonitorSettings)).HeartbeatInterval, serverApi), serverApi) { }
public ServerDescription( ServerId serverId, EndPoint endPoint, ServerState state, ServerType type, TimeSpan averageRoundTripTime, ReplicaSetConfig replicaSetConfig, TagSet tags, SemanticVersion version, Range <int> wireVersionRange) : this( averageRoundTripTime, endPoint, replicaSetConfig, serverId, state, tags, type, version, wireVersionRange) { }
// constructors /// <summary> /// Initializes a new instance of the <see cref="ServerDescription"/> class. /// </summary> /// <param name="serverId">The server identifier.</param> /// <param name="endPoint">The end point.</param> /// <param name="averageRoundTripTime">The average round trip time.</param> /// <param name="heartbeatException">The heartbeat exception.</param> /// <param name="maxBatchCount">The maximum batch count.</param> /// <param name="maxDocumentSize">The maximum size of a document.</param> /// <param name="maxMessageSize">The maximum size of a message.</param> /// <param name="maxWireDocumentSize">The maximum size of a wire document.</param> /// <param name="replicaSetConfig">The replica set configuration.</param> /// <param name="state">The server state.</param> /// <param name="tags">The replica set tags.</param> /// <param name="type">The server type.</param> /// <param name="version">The server version.</param> /// <param name="wireVersionRange">The wire version range.</param> public ServerDescription( ServerId serverId, EndPoint endPoint, Optional <TimeSpan> averageRoundTripTime = default(Optional <TimeSpan>), Optional <Exception> heartbeatException = default(Optional <Exception>), Optional <int> maxBatchCount = default(Optional <int>), Optional <int> maxDocumentSize = default(Optional <int>), Optional <int> maxMessageSize = default(Optional <int>), Optional <int> maxWireDocumentSize = default(Optional <int>), Optional <ReplicaSetConfig> replicaSetConfig = default(Optional <ReplicaSetConfig>), Optional <ServerState> state = default(Optional <ServerState>), Optional <TagSet> tags = default(Optional <TagSet>), Optional <ServerType> type = default(Optional <ServerType>), Optional <SemanticVersion> version = default(Optional <SemanticVersion>), Optional <Range <int> > wireVersionRange = default(Optional <Range <int> >)) { Ensure.IsNotNull(endPoint, "endPoint"); Ensure.IsNotNull(serverId, "serverId"); if (!EndPointHelper.Equals(endPoint, serverId.EndPoint)) { throw new ArgumentException("EndPoint and ServerId.EndPoint must match."); } _averageRoundTripTime = averageRoundTripTime.WithDefault(TimeSpan.Zero); _endPoint = endPoint; _heartbeatException = heartbeatException.WithDefault(null); _maxBatchCount = maxBatchCount.WithDefault(1000); _maxDocumentSize = maxDocumentSize.WithDefault(4 * 1024 * 1024); _maxMessageSize = maxMessageSize.WithDefault(Math.Max(_maxDocumentSize + 1024, 16000000)); _maxWireDocumentSize = maxWireDocumentSize.WithDefault(_maxDocumentSize + 16 * 1024); _replicaSetConfig = replicaSetConfig.WithDefault(null); _serverId = serverId; _state = state.WithDefault(ServerState.Disconnected); _tags = tags.WithDefault(null); _type = type.WithDefault(ServerType.Unknown); _version = version.WithDefault(null); _wireVersionRange = wireVersionRange.WithDefault(null); }
internal void ShouldInvalidateServer_should_return_expected_result_for_MongoWriteConcernException(ServerErrorCode?code, string message, bool expectedResult) { _subject.Initialize(); var clusterId = new ClusterId(1); var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017)); var connectionId = new ConnectionId(serverId); var command = new BsonDocument("command", 1); var commandResult = new BsonDocument { { "ok", 1 }, { "writeConcernError", new BsonDocument { { "code", () => (int)code.Value, code.HasValue }, { "errmsg", message, message != null } } } }; var writeConcernResult = new WriteConcernResult(commandResult); var exception = new MongoWriteConcernException(connectionId, "message", writeConcernResult); var result = _subject.ShouldInvalidateServer(Mock.Of <IConnection>(), exception, new ServerDescription(_subject.ServerId, _subject.EndPoint), out _); result.Should().Be(expectedResult); }
internal void ShouldInvalidateServer_should_return_expected_result_for_exceptionType(string exceptionTypeName, bool expectedResult) { _subject.Initialize(); Exception exception; var clusterId = new ClusterId(1); var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017)); var connectionId = new ConnectionId(serverId); var command = new BsonDocument("command", 1); var commandResult = new BsonDocument("ok", 1); switch (exceptionTypeName) { case nameof(EndOfStreamException): exception = new EndOfStreamException(); break; case nameof(Exception): exception = new Exception(); break; case nameof(IOException): exception = new IOException(); break; case nameof(MongoConnectionException): exception = new MongoConnectionException(connectionId, "message"); break; case nameof(MongoNodeIsRecoveringException): exception = new MongoNodeIsRecoveringException(connectionId, command, commandResult); break; case nameof(MongoNotPrimaryException): exception = new MongoNotPrimaryException(connectionId, command, commandResult); break; case nameof(SocketException): exception = new SocketException(); break; case nameof(TimeoutException): exception = new TimeoutException(); break; case nameof(MongoExecutionTimeoutException): exception = new MongoExecutionTimeoutException(connectionId, "message"); break; default: throw new Exception($"Invalid exceptionTypeName: {exceptionTypeName}."); } var result = _subject.ShouldInvalidateServer(exception); result.Should().Be(expectedResult); }
// constructors public ClusterableServer(ClusterId clusterId, ClusterConnectionMode clusterConnectionMode, ServerSettings settings, EndPoint endPoint, IConnectionPoolFactory connectionPoolFactory, IConnectionFactory heartbeatConnectionFactory, IEventSubscriber eventSubscriber) { Ensure.IsNotNull(clusterId, nameof(clusterId)); _clusterConnectionMode = clusterConnectionMode; _settings = Ensure.IsNotNull(settings, nameof(settings));; _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); Ensure.IsNotNull(connectionPoolFactory, nameof(connectionPoolFactory)); _heartbeatConnectionFactory = Ensure.IsNotNull(heartbeatConnectionFactory, nameof(heartbeatConnectionFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _serverId = new ServerId(clusterId, endPoint); _baseDescription = _currentDescription = new ServerDescription(_serverId, endPoint); _connectionPool = connectionPoolFactory.CreateConnectionPool(_serverId, endPoint); _state = new InterlockedInt32(State.Initial); eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatStartedEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatSucceededEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatFailedEventHandler); eventSubscriber.TryGetEventHandler(out _descriptionChangedEventHandler); }
// constructors public Server( ClusterId clusterId, IClusterClock clusterClock, #pragma warning disable CS0618 // Type or member is obsolete ClusterConnectionMode clusterConnectionMode, ConnectionModeSwitch connectionModeSwitch, #pragma warning restore CS0618 // Type or member is obsolete bool?directConnection, ServerSettings settings, EndPoint endPoint, IConnectionPoolFactory connectionPoolFactory, IEventSubscriber eventSubscriber, ServerApi serverApi) { ClusterConnectionModeHelper.EnsureConnectionModeValuesAreValid(clusterConnectionMode, connectionModeSwitch, directConnection); _clusterClock = Ensure.IsNotNull(clusterClock, nameof(clusterClock)); _clusterConnectionMode = clusterConnectionMode; _connectionModeSwitch = connectionModeSwitch; _directConnection = directConnection; _settings = Ensure.IsNotNull(settings, nameof(settings)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _serverId = new ServerId(clusterId, endPoint); _connectionPool = Ensure.IsNotNull(connectionPoolFactory, nameof(connectionPoolFactory)).CreateConnectionPool(_serverId, endPoint); _state = new InterlockedInt32(State.Initial); _serverApi = serverApi; _outstandingOperationsCount = 0; eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _descriptionChangedEventHandler); }
public void HandleChannelException_should_update_topology_as_expected_on_network_error_or_timeout( string errorType, bool shouldUpdateTopology) { var serverId = new ServerId(_clusterId, _endPoint); var connectionId = new ConnectionId(serverId); Exception innerMostException; switch (errorType) { case "MongoConnectionExceptionWithSocketTimeout": innerMostException = new SocketException((int)SocketError.TimedOut); break; case nameof(MongoConnectionException): innerMostException = new SocketException((int)SocketError.NetworkUnreachable); break; default: throw new ArgumentException("Unknown error type."); } var operationUsingChannelException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException)); var mockConnection = new Mock <IConnectionHandle>(); var isMasterResult = new IsMasterResult(new BsonDocument { { "compressors", new BsonArray() } }); // the server version doesn't matter when we're not testing MongoNotPrimaryExceptions, but is needed when // Server calls ShouldClearConnectionPoolForException var buildInfoResult = new BuildInfoResult(new BsonDocument { { "version", "4.4.0" } }); mockConnection.SetupGet(c => c.Description) .Returns(new ConnectionDescription(new ConnectionId(serverId, 0), isMasterResult, buildInfoResult)); var mockConnectionPool = new Mock <IConnectionPool>(); mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(mockConnection.Object); mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).ReturnsAsync(mockConnection.Object); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(mockConnectionPool.Object); var mockMonitorServerInitialDescription = new ServerDescription(serverId, _endPoint).With(reasonChanged: "Initial D", type: ServerType.Unknown); var mockServerMonitor = new Mock <IServerMonitor>(); mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerInitialDescription); mockServerMonitor.SetupGet(m => m.Lock).Returns(new object()); var mockServerMonitorFactory = new Mock <IServerMonitorFactory>(); mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object); var subject = new DefaultServer(_clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.Object, _capturedEvents, _serverApi); subject.Initialize(); var heartbeatDescription = mockMonitorServerInitialDescription.With(reasonChanged: "Heartbeat", type: ServerType.Standalone); mockServerMonitor.Setup(m => m.Description).Returns(heartbeatDescription); mockServerMonitor.Raise( m => m.DescriptionChanged += null, new ServerDescriptionChangedEventArgs(mockMonitorServerInitialDescription, heartbeatDescription)); subject.Description.Should().Be(heartbeatDescription); subject.HandleChannelException(mockConnection.Object, operationUsingChannelException); if (shouldUpdateTopology) { subject.Description.Type.Should().Be(ServerType.Unknown); subject.Description.ReasonChanged.Should().Contain("ChannelException"); } else { subject.Description.Should().Be(heartbeatDescription); } }
public void ToString_should_return_string_representation() { var subject = new ServerId(__clusterId, __endPoint); subject.ToString().Should().Be("{ ClusterId : 1, EndPoint : \"Unspecified/localhost:27017\" }"); }
/// <inheritdoc/> public IServerMonitor Create(ServerId serverId, EndPoint endPoint) { return(new ServerMonitor(serverId, endPoint, _connectionFactory, _serverMonitorSettings, _eventSubscriber, _serverApi)); }
public void Equals_should_return_false_when_any_field_is_not_equal(string notEqualField) { var averageRoundTripTime = TimeSpan.FromSeconds(1); var canonicalEndPoint = new DnsEndPoint("localhost", 27017); var electionId = new ElectionId(ObjectId.GenerateNewId()); var endPoint = new DnsEndPoint("localhost", 27017); var helloOk = false; var lastUpdateTimestamp = DateTime.UtcNow; var logicalSessionTimeout = TimeSpan.FromMinutes(1); var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); var serverId = new ServerId(__clusterId, endPoint); var state = ServerState.Connected; var tags = new TagSet(new[] { new Tag("x", "a") }); var type = ServerType.ReplicaSetPrimary; var version = new SemanticVersion(3, 6, 0); var wireVersionRange = new Range <int>(6, 14); var subject = new ServerDescription( serverId, endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, canonicalEndPoint: canonicalEndPoint, electionId: electionId, helloOk: helloOk, lastUpdateTimestamp: lastUpdateTimestamp, logicalSessionTimeout: logicalSessionTimeout, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); switch (notEqualField) { case "AverageRoundTripTime": averageRoundTripTime = averageRoundTripTime.Add(TimeSpan.FromSeconds(1)); break; case "CanonicalEndPoint": canonicalEndPoint = new DnsEndPoint("localhost", 27018); break; case "ElectionId": electionId = new ElectionId(ObjectId.Empty); break; case "EndPoint": endPoint = new DnsEndPoint(endPoint.Host, endPoint.Port + 1); serverId = new ServerId(__clusterId, endPoint); break; case "HelloOk": helloOk = !helloOk; break; case "LogicalSessionTimeout": logicalSessionTimeout = TimeSpan.FromMinutes(2); break; case "ReplicaSetConfig": replicaSetConfig = new ReplicaSetConfig(replicaSetConfig.Members, "newname", replicaSetConfig.Primary, replicaSetConfig.Version); break; case "State": state = ServerState.Disconnected; break; case "ServerId": serverId = new ServerId(new ClusterId(), endPoint); break; case "Tags": tags = new TagSet(new[] { new Tag("x", "b") }); break; case "Type": type = ServerType.ReplicaSetSecondary; break; case "Version": version = new SemanticVersion(version.Major, version.Minor, version.Patch + 1); break; case "WireVersionRange": wireVersionRange = new Range <int>(0, 0); break; } var serverDescription2 = new ServerDescription( serverId, endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, canonicalEndPoint: canonicalEndPoint, electionId: electionId, helloOk: helloOk, lastUpdateTimestamp: lastUpdateTimestamp, logicalSessionTimeout: logicalSessionTimeout, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); subject.Equals(serverDescription2).Should().BeFalse(); subject.Equals((object)serverDescription2).Should().BeFalse(); subject.GetHashCode().Should().NotBe(serverDescription2.GetHashCode()); }
public void GetChannel_should_update_topology_and_clear_connection_pool_on_network_error_or_timeout( [Values("timedout", "networkunreachable")] string errorType, [Values(false, true)] bool async) { var serverId = new ServerId(_clusterId, _endPoint); var connectionId = new ConnectionId(serverId); var innerMostException = CoreExceptionHelper.CreateSocketException(errorType); var openConnectionException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException)); var mockConnection = new Mock <IConnectionHandle>(); mockConnection.Setup(c => c.Open(It.IsAny <CancellationToken>())).Throws(openConnectionException); mockConnection.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>())).ThrowsAsync(openConnectionException); var mockConnectionPool = new Mock <IConnectionPool>(); mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(mockConnection.Object); mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).ReturnsAsync(mockConnection.Object); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(mockConnectionPool.Object); var mockMonitorServerDescription = new ServerDescription(serverId, _endPoint); var mockServerMonitor = new Mock <IServerMonitor>(); mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerDescription); mockServerMonitor .Setup(m => m.Invalidate(It.IsAny <string>())) .Callback((string reason) => MockMonitorInvalidate(reason)); var mockServerMonitorFactory = new Mock <IServerMonitorFactory>(); mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object); var subject = new Server(_clusterId, _clusterClock, _clusterConnectionMode, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.Object, _capturedEvents); subject.Initialize(); IChannelHandle channel = null; Exception exception; if (async) { exception = Record.Exception(() => channel = subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult()); } else { exception = Record.Exception(() => channel = subject.GetChannel(CancellationToken.None)); } channel.Should().BeNull(); exception.Should().Be(openConnectionException); subject.Description.Type.Should().Be(ServerType.Unknown); subject.Description.ReasonChanged.Should().Contain("ChannelException during handshake"); mockServerMonitor.Verify(m => m.Invalidate(It.IsAny <string>()), Times.Once); mockConnectionPool.Verify(p => p.Clear(), Times.Once); void MockMonitorInvalidate(string reason) { var currentDescription = mockServerMonitor.Object.Description; mockServerMonitor.SetupGet(m => m.Description).Returns(currentDescription.With(reason)); } }
public void Equals_should_return_false_when_any_field_is_not_equal(string notEqualField) { var averageRoundTripTime = TimeSpan.FromSeconds(1); var endPoint = new DnsEndPoint("localhost", 27017); var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); var serverId = new ServerId(__clusterId, endPoint); var state = ServerState.Connected; var tags = new TagSet(new[] { new Tag("x", "a") }); var type = ServerType.ReplicaSetPrimary; var version = new SemanticVersion(2, 6, 3); var wireVersionRange = new Range <int>(2, 3); var subject = new ServerDescription( serverId, endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); switch (notEqualField) { case "AverageRoundTripTime": averageRoundTripTime = averageRoundTripTime.Add(TimeSpan.FromSeconds(1)); break; case "EndPoint": endPoint = new DnsEndPoint(endPoint.Host, endPoint.Port + 1); serverId = new ServerId(__clusterId, endPoint); break; case "ReplicaSetConfig": replicaSetConfig = new ReplicaSetConfig(replicaSetConfig.Members, "newname", replicaSetConfig.Primary, replicaSetConfig.Version); break; case "State": state = ServerState.Disconnected; break; case "ServerId": serverId = new ServerId(new ClusterId(), endPoint); break; case "Tags": tags = new TagSet(new[] { new Tag("x", "b") }); break; case "Type": type = ServerType.ReplicaSetSecondary; break; case "Version": version = new SemanticVersion(version.Major, version.Minor, version.Patch + 1); break; case "WireVersionRange": wireVersionRange = new Range <int>(0, 0); break; } var serverDescription2 = new ServerDescription( serverId, endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); subject.Equals(serverDescription2).Should().BeFalse(); subject.Equals((object)serverDescription2).Should().BeFalse(); subject.GetHashCode().Should().NotBe(serverDescription2.GetHashCode()); }
// static constructor static ServerDescriptionTests() { __clusterId = new ClusterId(); __endPoint = new DnsEndPoint("localhost", 27017); __serverId = new ServerId(__clusterId, __endPoint); }
/// <inheritdoc/> public IServerMonitor Create(ServerId serverId, EndPoint endPoint) { return(new ServerMonitor(serverId, endPoint, _connectionFactory, _settings.HeartbeatInterval, _settings.HeartbeatTimeout, _eventSubscriber)); }