public void GetChannel_should_update_topology_and_clear_connection_pool_on_network_error_or_timeout( [Values("TimedOutSocketException", "NetworkUnreachableSocketException")] string errorType, [Values(false, true)] bool async) { var serverId = new ServerId(_clusterId, _endPoint); var connectionId = new ConnectionId(serverId); var innerMostException = CoreExceptionHelper.CreateException(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 connectionFactory = new Mock <IConnectionFactory>(); connectionFactory.Setup(cf => cf.CreateConnection(serverId, _endPoint)).Returns(mockConnection.Object); var mockExceptionHandler = new Mock <IConnectionExceptionHandler>(); var connectionPoolSettings = new ConnectionPoolSettings(); var connectionPool = new ExclusiveConnectionPool(serverId, _endPoint, connectionPoolSettings, connectionFactory.Object, new EventAggregator(), mockExceptionHandler.Object); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(connectionPool); var mockMonitorServerDescription = new ServerDescription(serverId, _endPoint); var mockServerMonitor = new Mock <IServerMonitor>(); mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerDescription); 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); connectionPool._connectionExceptionHandler(subject); subject.Initialize(); connectionPool.SetReady(); 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"); }
public static bool ShouldInvalidateServer(this DefaultServer server, IConnection connection, Exception exception, ServerDescription description, out TopologyVersion responseTopologyVersion) { return((bool)Reflector.Invoke(server, nameof(ShouldInvalidateServer), connection, exception, description, out responseTopologyVersion)); }
public void Equals_should_return_true_when_all_fields_are_equal() { ServerDescription subject = new ServerDescription(__serverId, __endPoint); ServerDescription serverDescription2 = new ServerDescription(__serverId, __endPoint); subject.Equals(serverDescription2).Should().BeTrue(); subject.Equals((object)serverDescription2).Should().BeTrue(); subject.GetHashCode().Should().Be(serverDescription2.GetHashCode()); }
private bool ShouldInvalidateServer( IConnection connection, Exception exception, ServerDescription description, out TopologyVersion invalidatingResponseTopologyVersion) { if (exception is MongoConnectionException mongoConnectionException && mongoConnectionException.ContainsTimeoutException) { invalidatingResponseTopologyVersion = null; return(false); } if (__invalidatingExceptions.Contains(exception.GetType())) { invalidatingResponseTopologyVersion = null; return(true); } var exceptionsToCheck = new[] { exception as MongoCommandException, (exception as MongoWriteConcernException)?.MappedWriteConcernResultException } .OfType <MongoCommandException>(); foreach (MongoCommandException commandException in exceptionsToCheck) { if (IsStateChangeException(commandException)) { return(!IsStaleStateChangeError(commandException.Result, out invalidatingResponseTopologyVersion)); } } invalidatingResponseTopologyVersion = null; return(false); bool IsStaleStateChangeError(BsonDocument response, out TopologyVersion nonStaleResponseTopologyVersion) { if (ConnectionPool.Generation > connection.Generation) { // stale generation number nonStaleResponseTopologyVersion = null; return(true); } var responseTopologyVersion = TopologyVersion.FromMongoCommandResponse(response); // We use FresherThanOrEqualTo instead of FresherThan because a state change should come with a new // topology version. // We cannot use StalerThan(responseTopologyVersion, description.TopologyVersion) because due to how // TopologyVersions comparisons are defined, FresherThanOrEqualTo(x, y) does not imply StalerThan(y, x) bool isStale = TopologyVersion.IsFresherThanOrEqualTo(description.TopologyVersion, responseTopologyVersion); nonStaleResponseTopologyVersion = isStale ? null : responseTopologyVersion; return(isStale); } }
public void A_description_changed_event_with_a_heartbeat_exception_should_clear_the_connection_pool() { _subject.Initialize(); var description = new ServerDescription(_subject.ServerId, _subject.EndPoint) .With(heartbeatException: new Exception("ughhh")); _serverMonitor.DescriptionChanged += Raise.EventWith(new ServerDescriptionChangedEventArgs(description, description)); _connectionPool.Received().Clear(); }
public void A_description_changed_event_with_a_heartbeat_exception_should_clear_the_connection_pool() { _subject.Initialize(); var description = new ServerDescription(_subject.ServerId, _subject.EndPoint) .With(heartbeatException: new Exception("ughhh")); _mockServerMonitor.Raise(m => m.DescriptionChanged += null, new ServerDescriptionChangedEventArgs(description, description)); _mockConnectionPool.Verify(p => p.Clear(), Times.Once); }
public void MaxWireVersion_should_be_the_same_as_wireVersionRange_max() { var clusterId = new ClusterId(1); var endPoint = new DnsEndPoint("localhost", 27017); var serverId = new ServerId(clusterId, endPoint); var wireVersionRange = new Range <int>(0, 14); var subject = new ServerDescription(serverId, endPoint, wireVersionRange: wireVersionRange, type: ServerType.Standalone); subject.MaxWireVersion.Should().Be(wireVersionRange.Max); }
private void SetDescriptionIfChanged(ServerDescription newDescription) { var oldDescription = Interlocked.CompareExchange(ref _currentDescription, null, null); if (oldDescription.Equals(newDescription)) { return; } SetDescription(oldDescription, newDescription); }
private void OnDescriptionChanged(ServerDescription oldDescription, ServerDescription newDescription) { var handler = DescriptionChanged; if (handler != null) { var args = new ServerDescriptionChangedEventArgs(oldDescription, newDescription); try { handler(this, args); } catch { } // ignore exceptions } }
public void IsCompatibleWithDriver_should_return_expected_result(int[] minMaxWireVersions, bool expectedResult) { var clusterId = new ClusterId(1); var endPoint = new DnsEndPoint("localhost", 27017); var serverId = new ServerId(clusterId, endPoint); var wireVersionRange = minMaxWireVersions == null ? null : new Range <int>(minMaxWireVersions[0], minMaxWireVersions[1]); var subject = new ServerDescription(serverId, endPoint, wireVersionRange: wireVersionRange); var result = subject.IsCompatibleWithDriver; result.Should().Be(expectedResult); }
public void WithHeartbeat_should_return_new_instance_when_a_field_is_not_equal(string notEqualField) { var averageRoundTripTime = TimeSpan.FromSeconds(1); var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); 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 "ReplicaSetConfig": replicaSetConfig = new ReplicaSetConfig(replicaSetConfig.Members, "newname", replicaSetConfig.Primary, replicaSetConfig.Version); 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 = subject.With( averageRoundTripTime: averageRoundTripTime, replicaSetConfig: replicaSetConfig, state: ServerState.Connected, tags: tags, type: type, version: version, wireVersionRange: wireVersionRange); subject.Equals(serverDescription2).Should().BeFalse(); subject.Equals((object)serverDescription2).Should().BeFalse(); subject.GetHashCode().Should().NotBe(serverDescription2.GetHashCode()); }
// constructors public ClusterableServer(ServerSettings settings, ClusterId clusterId, EndPoint endPoint, IConnectionPoolFactory connectionPoolFactory, IConnectionFactory hearbeatConnectionFactory, IServerListener listener) { _settings = Ensure.IsNotNull(settings, "settings");; Ensure.IsNotNull(clusterId, "clusterId"); _endPoint = Ensure.IsNotNull(endPoint, "endPoint"); _connectionPoolFactory = Ensure.IsNotNull(connectionPoolFactory, "connectionPoolFactory"); _heartbeatConnectionFactory = Ensure.IsNotNull(hearbeatConnectionFactory, "hearbeatConnectionFactory"); _listener = listener; _serverId = new ServerId(clusterId, endPoint); _baseDescription = _currentDescription = new ServerDescription(_serverId, endPoint); _connectionPool = connectionPoolFactory.CreateConnectionPool(_serverId, endPoint); _state = new InterlockedInt32(State.Initial); }
// static constructor static ServerDescriptionTests() { __clusterId = new ClusterId(); __endPoint = new DnsEndPoint("localhost", 27017); __serverId = new ServerId(__clusterId, __endPoint); __subject = new ServerDescription( __serverId, __endPoint, state: ServerState.Connected, type: ServerType.Standalone, averageRoundTripTime: TimeSpan.FromSeconds(1), version: new SemanticVersion(2, 6, 3), wireVersionRange: new Range <int>(0, 2)); }
public static bool ShouldInvalidateServer(this Server server, IConnectionHandle connection, Exception exception, ServerDescription description, out TopologyVersion responseTopologyVersion) { var methodInfo = typeof(Server).GetMethod(nameof(ShouldInvalidateServer), BindingFlags.NonPublic | BindingFlags.Instance); var parameters = new object[] { connection, exception, description, null }; int outParameterIndex = Array.IndexOf(parameters, null); var shouldInvalidate = (bool)methodInfo.Invoke(server, parameters); responseTopologyVersion = (TopologyVersion)parameters[outParameterIndex]; return(shouldInvalidate); }
public void Constructor_with_serverId_and_endPoint_only_should_return_disconnected_instance() { var subject = new ServerDescription(__serverId, __endPoint); subject.AverageRoundTripTime.Should().Be(TimeSpan.Zero); subject.EndPoint.Should().Be(__endPoint); subject.ReplicaSetConfig.Should().BeNull(); subject.ServerId.Should().Be(__serverId); subject.State.Should().Be(ServerState.Disconnected); subject.Tags.Should().BeNull(); subject.Type.Should().Be(ServerType.Unknown); subject.Version.Should().BeNull(); subject.WireVersionRange.Should().BeNull(); }
public ServerMonitor(ServerId serverId, EndPoint endPoint, IConnectionFactory connectionFactory, TimeSpan heartbeatInterval, TimeSpan timeout, IEventSubscriber eventSubscriber) { _serverId = Ensure.IsNotNull(serverId, nameof(serverId)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); _connectionFactory = Ensure.IsNotNull(connectionFactory, nameof(connectionFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _baseDescription = _currentDescription = new ServerDescription(_serverId, endPoint, heartbeatInterval: heartbeatInterval); _heartbeatInterval = heartbeatInterval; _timeout = timeout; _state = new InterlockedInt32(State.Initial); eventSubscriber.TryGetEventHandler(out _heartbeatStartedEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatSucceededEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatFailedEventHandler); }
// static constructor static ServerDescriptionTests() { __clusterId = new ClusterId(); __endPoint = new DnsEndPoint("localhost", 27017); __serverId = new ServerId(__clusterId, __endPoint); __subject = new ServerDescription( __serverId, __endPoint, ServerState.Connected, ServerType.Standalone, TimeSpan.FromSeconds(1), null, null, new SemanticVersion(2, 6, 3), new Range <int>(0, 2)); }
public void Constructor_with_multiple_parameters_should_return_properly_initialized_instance() { var averageRoundTripTime = TimeSpan.FromSeconds(1); var canonicalEndPoint = new DnsEndPoint("localhost", 27017); var electionId = new ElectionId(ObjectId.GenerateNewId()); var helloOk = true; 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 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, logicalSessionTimeout: logicalSessionTimeout, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); subject.AverageRoundTripTime.Should().Be(TimeSpan.FromSeconds(1)); subject.CanonicalEndPoint.Should().Be(canonicalEndPoint); subject.ElectionId.Should().Be(electionId); subject.EndPoint.Should().Be(__endPoint); subject.HelloOk.Should().Be(helloOk); subject.LogicalSessionTimeout.Should().Be(logicalSessionTimeout); subject.ReplicaSetConfig.Should().Be(replicaSetConfig); subject.ServerId.Should().Be(__serverId); subject.State.Should().Be(state); subject.Tags.Should().Be(tags); subject.Type.Should().Be(type); }
public void Equals_should_return_true_when_all_fields_are_equal() { var lastUpdateTimestamp = DateTime.UtcNow; ServerDescription subject = new ServerDescription( __serverId, __endPoint, type: ServerType.Standalone, lastUpdateTimestamp: lastUpdateTimestamp); ServerDescription serverDescription2 = new ServerDescription( __serverId, __endPoint, type: ServerType.Standalone, lastUpdateTimestamp: lastUpdateTimestamp); subject.Equals(serverDescription2).Should().BeTrue(); subject.Equals((object)serverDescription2).Should().BeTrue(); subject.GetHashCode().Should().Be(serverDescription2.GetHashCode()); }
private void OnDescriptionChanged(ServerDescription newDescription) { var oldDescription = Interlocked.CompareExchange(ref _currentDescription, null, null); if (oldDescription.Equals(newDescription)) { return; } Interlocked.Exchange(ref _currentDescription, newDescription); var handler = DescriptionChanged; if (handler != null) { var args = new ServerDescriptionChangedEventArgs(oldDescription, newDescription); try { handler(this, args); } catch { } // ignore exceptions } }
public void With_should_return_same_instance_when_all_fields_are_equal() { var averageRoundTripTime = TimeSpan.FromSeconds(1); var helloOk = true; var lastUpdateTimestamp = DateTime.UtcNow; var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); 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, averageRoundTripTime: averageRoundTripTime, helloOk: helloOk, lastUpdateTimestamp: lastUpdateTimestamp, replicaSetConfig: replicaSetConfig, state: state, tags: tags, type: type, version: version, wireVersionRange: wireVersionRange); var result = subject.With( averageRoundTripTime: averageRoundTripTime, helloOk: helloOk, lastUpdateTimestamp: lastUpdateTimestamp, replicaSetConfig: replicaSetConfig, state: ServerState.Connected, tags: tags, type: type, version: version, wireVersionRange: wireVersionRange); result.ShouldBeEquivalentTo(subject); }
public ServerMonitor(ServerId serverId, EndPoint endPoint, IConnectionFactory connectionFactory, ServerMonitorSettings serverMonitorSettings, IEventSubscriber eventSubscriber, IRoundTripTimeMonitor roundTripTimeMonitor) { _monitorCancellationTokenSource = new CancellationTokenSource(); _serverId = Ensure.IsNotNull(serverId, nameof(serverId)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); _connectionFactory = Ensure.IsNotNull(connectionFactory, nameof(connectionFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _serverMonitorSettings = Ensure.IsNotNull(serverMonitorSettings, nameof(serverMonitorSettings)); _baseDescription = _currentDescription = new ServerDescription(_serverId, endPoint, reasonChanged: "InitialDescription", heartbeatInterval: serverMonitorSettings.HeartbeatInterval); _roundTripTimeMonitor = Ensure.IsNotNull(roundTripTimeMonitor, nameof(roundTripTimeMonitor)); _state = new InterlockedInt32(State.Initial); eventSubscriber.TryGetEventHandler(out _heartbeatStartedEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatSucceededEventHandler); eventSubscriber.TryGetEventHandler(out _heartbeatFailedEventHandler); eventSubscriber.TryGetEventHandler(out _sdamInformationEventHandler); _heartbeatCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_monitorCancellationTokenSource.Token); }
public void Constructor_with_serverId_and_endPoint_only_should_return_disconnected_instance() { var subject = new ServerDescription(__serverId, __endPoint); subject.AverageRoundTripTime.Should().Be(TimeSpan.Zero); subject.CanonicalEndPoint.Should().BeNull(); subject.ElectionId.Should().BeNull(); subject.EndPoint.Should().Be(__endPoint); subject.HelloOk.Should().BeFalse(); subject.LogicalSessionTimeout.Should().NotHaveValue(); subject.ReplicaSetConfig.Should().BeNull(); subject.ServerId.Should().Be(__serverId); subject.State.Should().Be(ServerState.Disconnected); subject.Tags.Should().BeNull(); subject.Type.Should().Be(ServerType.Unknown); #pragma warning disable CS0618 // Type or member is obsolete subject.Version.Should().BeNull(); #pragma warning restore CS0618 // Type or member is obsolete subject.WireVersionRange.Should().BeNull(); }
// 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); }
public LoadBalancedServer( ClusterId clusterId, IClusterClock clusterClock, ServerSettings serverSettings, EndPoint endPoint, IConnectionPoolFactory connectionPoolFactory, IEventSubscriber eventSubscriber, ServerApi serverApi) : base( clusterId, clusterClock, #pragma warning disable CS0618 // Type or member is obsolete ClusterConnectionMode.Automatic, ConnectionModeSwitch.UseConnectionMode, #pragma warning restore CS0618 // Type or member is obsolete directConnection: null, serverSettings, endPoint, connectionPoolFactory, eventSubscriber, serverApi) { _baseDescription = _currentDescription = new ServerDescription(ServerId, endPoint, reasonChanged: "ServerInitialDescription"); }
// 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); _baseDescription = new ServerDescription(_serverId, endPoint, reasonChanged: "ServerInitialDescription", heartbeatInterval: settings.HeartbeatInterval); _currentDescription = _baseDescription; eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _descriptionChangedEventHandler); }
public void WithHeartbeat_should_return_same_instance_when_all_fields_are_equal() { var averageRoundTripTime = TimeSpan.FromSeconds(1); var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); 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>(0, 2); var subject = new ServerDescription( __serverId, __endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, replicaSetConfig: replicaSetConfig, tags: tags, version: version, wireVersionRange: wireVersionRange); var serverDescription2 = subject.With( averageRoundTripTime: averageRoundTripTime, replicaSetConfig: replicaSetConfig, state: ServerState.Connected, tags: tags, type: type, version: version, wireVersionRange: wireVersionRange); serverDescription2.Should().BeSameAs(subject); }
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 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(2, 6, 3); var wireVersionRange = new Range <int>(2, 3); var subject = new ServerDescription( serverId, endPoint, state: state, type: type, averageRoundTripTime: averageRoundTripTime, canonicalEndPoint: canonicalEndPoint, 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 "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, 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 With_should_return_new_instance_when_a_field_is_not_equal(string notEqualField) { var averageRoundTripTime = TimeSpan.FromSeconds(1); var canonicalEndPoint = new DnsEndPoint("localhost", 27017); var electionId = new ElectionId(ObjectId.GenerateNewId()); var heartbeatException = new Exception(); var heartbeatInterval = TimeSpan.FromSeconds(10); var lastUpdateTimestamp = DateTime.UtcNow; var lastWriteTimestamp = DateTime.UtcNow; var logicalSessionTimeout = TimeSpan.FromMinutes(1); var maxBatchCount = 1000; var maxDocumentSize = 16000000; var maxMessageSize = 48000000; var maxWireDocumentSize = 16000000; var replicaSetConfig = new ReplicaSetConfig( new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) }, "name", new DnsEndPoint("localhost", 27017), 1); 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, averageRoundTripTime: averageRoundTripTime, canonicalEndPoint: canonicalEndPoint, electionId: electionId, heartbeatException: heartbeatException, heartbeatInterval: heartbeatInterval, lastUpdateTimestamp: lastUpdateTimestamp, lastWriteTimestamp: lastWriteTimestamp, logicalSessionTimeout: logicalSessionTimeout, maxBatchCount: maxBatchCount, maxDocumentSize: maxDocumentSize, maxMessageSize: maxMessageSize, maxWireDocumentSize: maxWireDocumentSize, replicaSetConfig: replicaSetConfig, state: state, tags: tags, type: type, 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 "HeartbeatException": heartbeatException = new Exception(); break; case "HeartbeatInterval": heartbeatInterval = TimeSpan.FromSeconds(11); break; case "LastUpdateTimestamp": lastUpdateTimestamp = lastUpdateTimestamp.Add(TimeSpan.FromSeconds(1)); break; case "LastWriteTimestamp": lastWriteTimestamp = lastWriteTimestamp.Add(TimeSpan.FromSeconds(1)); break; case "LogicalSessionTimeout": logicalSessionTimeout = TimeSpan.FromMinutes(2); break; case "MaxBatchCount": maxBatchCount += 1; break; case "MaxDocumentSize": maxDocumentSize += 1; break; case "MaxMessageSize": maxMessageSize += 1; break; case "MaxWireDocumentSize": maxWireDocumentSize += 1; break; case "ReplicaSetConfig": replicaSetConfig = new ReplicaSetConfig(replicaSetConfig.Members, "newname", replicaSetConfig.Primary, replicaSetConfig.Version); break; case "State": state = ServerState.Disconnected; 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 result = subject.With( averageRoundTripTime: averageRoundTripTime, canonicalEndPoint: canonicalEndPoint, electionId: electionId, heartbeatException: heartbeatException, heartbeatInterval: heartbeatInterval, lastUpdateTimestamp: lastUpdateTimestamp, lastWriteTimestamp: lastWriteTimestamp, logicalSessionTimeout: logicalSessionTimeout, maxBatchCount: maxBatchCount, maxDocumentSize: maxDocumentSize, maxMessageSize: maxMessageSize, maxWireDocumentSize: maxWireDocumentSize, replicaSetConfig: replicaSetConfig, state: state, tags: tags, type: type, version: version, wireVersionRange: wireVersionRange); result.Should().NotBeSameAs(subject); result.Equals(subject).Should().BeFalse(); result.Equals((object)subject).Should().BeFalse(); result.GetHashCode().Should().NotBe(subject.GetHashCode()); }
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); } }