public ServerTests() { _clusterId = new ClusterId(); _endPoint = new DnsEndPoint("localhost", 27017); _clusterClock = new Mock <IClusterClock>().Object; #pragma warning disable CS0618 // Type or member is obsolete _clusterConnectionMode = ClusterConnectionMode.Standalone; _connectionModeSwitch = ConnectionModeSwitch.UseConnectionMode; #pragma warning restore CS0618 // Type or member is obsolete _directConnection = null; _mockConnectionPool = new Mock <IConnectionPool>(); _mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(new Mock <IConnectionHandle>().Object); _mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(new Mock <IConnectionHandle>().Object)); _mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); _mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(_mockConnectionPool.Object); _mockServerMonitor = new Mock <IServerMonitor>(); _mockServerMonitorFactory = new Mock <IServerMonitorFactory>(); _mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(_mockServerMonitor.Object); _capturedEvents = new EventCapturer(); _serverApi = new ServerApi(ServerApiVersion.V1, true, true); _settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan); _subject = new DefaultServer(_clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, _mockConnectionPoolFactory.Object, _mockServerMonitorFactory.Object, _capturedEvents, _serverApi); _connectionId = new ConnectionId(_subject.ServerId); }
public DefaultServer( 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, IServerMonitorFactory monitorFactory, IEventSubscriber eventSubscriber, ServerApi serverApi) : base( clusterId, clusterClock, clusterConnectionMode, connectionModeSwitch, directConnection, settings, endPoint, connectionPoolFactory, eventSubscriber, serverApi) { _monitor = Ensure.IsNotNull(monitorFactory, nameof(monitorFactory)).Create(ServerId, endPoint); _baseDescription = _currentDescription = new ServerDescription(ServerId, endPoint, reasonChanged: "ServerInitialDescription", heartbeatInterval: settings.HeartbeatInterval); }
public ServerTests() { _clusterId = new ClusterId(); _endPoint = new DnsEndPoint("localhost", 27017); _clusterClock = new Mock <IClusterClock>().Object; _clusterConnectionMode = ClusterConnectionMode.Standalone; _mockConnectionPool = new Mock <IConnectionPool>(); _mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(new Mock <IConnectionHandle>().Object); _mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(new Mock <IConnectionHandle>().Object)); _mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); _mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(_mockConnectionPool.Object); _mockServerMonitor = new Mock <IServerMonitor>(); _mockServerMonitor.Setup(m => m.Description).Returns(new ServerDescription(new ServerId(_clusterId, _endPoint), _endPoint)); _mockServerMonitorFactory = new Mock <IServerMonitorFactory>(); _mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(_mockServerMonitor.Object); _capturedEvents = new EventCapturer(); _settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan); _subject = new Server(_clusterId, _clusterClock, _clusterConnectionMode, _settings, _endPoint, _mockConnectionPoolFactory.Object, _mockServerMonitorFactory.Object, _capturedEvents); }
public IClusterableServer CreateServer(ClusterId clusterId, IClusterClock clusterClock, EndPoint endPoint) { ServerTuple result; if (!_servers.TryGetValue(endPoint, out result)) { var description = new ServerDescription(new ServerId(clusterId, endPoint), endPoint); if (_eventSubscriber == null) { var mockServer = new Mock <IClusterableServer>() { DefaultValue = DefaultValue.Mock }; mockServer.SetupGet(s => s.Description).Returns(description); mockServer.SetupGet(s => s.EndPoint).Returns(endPoint); mockServer.SetupGet(s => s.ServerId).Returns(new ServerId(clusterId, endPoint)); result = new ServerTuple { Server = mockServer.Object }; } else { var mockMonitorFactory = new Mock <IServerMonitorFactory>(); var mockMonitor = new Mock <IServerMonitor>() { DefaultValue = DefaultValue.Mock }; mockMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), It.IsAny <EndPoint>())).Returns(mockMonitor.Object); mockMonitor.SetupGet(m => m.Description).Returns(description); result = new ServerTuple { Server = new Server( clusterId, clusterClock, ClusterConnectionMode.Automatic, new ServerSettings(), endPoint, (new Mock <IConnectionPoolFactory> { DefaultValue = DefaultValue.Mock }).Object, mockMonitorFactory.Object, _eventSubscriber), Monitor = mockMonitor.Object }; } _servers[endPoint] = result; } return(result.Server); }
// methods /// <inheritdoc/> public IClusterableServer CreateServer(ClusterId clusterId, IClusterClock clusterClock, EndPoint endPoint) { return(new Server( clusterId, clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, endPoint, _connectionPoolFactory, _serverMonitorFactory, _eventSubscriber)); }
public LoadBalancedCluster( ClusterSettings settings, IClusterableServerFactory serverFactory, IEventSubscriber eventSubscriber, IDnsMonitorFactory dnsMonitorFactory) { #pragma warning disable CS0618 // Type or member is obsolete Ensure.That(settings.ConnectionModeSwitch != ConnectionModeSwitch.UseConnectionMode, $"{nameof(ConnectionModeSwitch.UseConnectionMode)} must not be used for a {nameof(LoadBalancedCluster)}."); if (settings.ConnectionModeSwitch == ConnectionModeSwitch.UseDirectConnection) { Ensure.That(!settings.DirectConnection.GetValueOrDefault(), $"DirectConnection mode is not supported for {nameof(LoadBalancedCluster)}."); } #pragma warning restore CS0618 // Type or member is obsolete Ensure.That(settings.LoadBalanced, $"Only Load balanced mode is supported for a {nameof(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(); _dnsMonitorCancellationTokenSource = new CancellationTokenSource(); _dnsMonitorFactory = Ensure.IsNotNull(dnsMonitorFactory, nameof(dnsMonitorFactory)); _settings = Ensure.IsNotNull(settings, nameof(settings)); _serverFactory = Ensure.IsNotNull(serverFactory, nameof(serverFactory)); _serverReadyTaskCompletionSource = new TaskCompletionSource <bool>(); _serverSessionPool = new CoreServerSessionPool(this); _state = new InterlockedInt32(State.Initial); _description = ClusterDescription.CreateInitial( _clusterId, #pragma warning disable CS0618 // Type or member is obsolete ClusterConnectionMode.Automatic, ConnectionModeSwitch.UseConnectionMode, #pragma warning restore CS0618 // Type or member is obsolete null); _eventSubscriber = eventSubscriber; eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _descriptionChangedEventHandler); }
public LoadBalancedTests() { _clusterId = new ClusterId(); _endPoint = new DnsEndPoint("localhost", 27017); _clusterClock = new Mock <IClusterClock>().Object; _mockConnectionPool = new Mock <IConnectionPool>(); _mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(new Mock <IConnectionHandle>().Object); _mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(new Mock <IConnectionHandle>().Object)); _mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); _mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(_mockConnectionPool.Object); _capturedEvents = new EventCapturer(); _serverApi = new ServerApi(ServerApiVersion.V1, true, true); _settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan); _subject = new LoadBalancedServer(_clusterId, _clusterClock, _settings, _endPoint, _mockConnectionPoolFactory.Object, _capturedEvents, _serverApi); _connectionId = new ConnectionId(_subject.ServerId); }
// 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 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, #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 IClusterableServer CreateServer(ClusterType clusterType, ClusterId clusterId, IClusterClock clusterClock, EndPoint endPoint) { ServerTuple result; if (!_servers.TryGetValue(endPoint, out result) || result.HasBeenRemoved) { var serverId = new ServerId(clusterId, endPoint); var description = new ServerDescription(serverId, endPoint, reasonChanged: "Initial D"); if (_eventSubscriber == null) { var mockServer = new Mock <IClusterableServer>() { DefaultValue = DefaultValue.Mock }; mockServer.SetupGet(s => s.Description).Returns(description); mockServer.SetupGet(s => s.EndPoint).Returns(endPoint); mockServer.SetupGet(s => s.ServerId).Returns(new ServerId(clusterId, endPoint)); mockServer .Setup(s => s.Dispose()) .Callback( () => { _servers[mockServer.Object.EndPoint].HasBeenRemoved = true; }); result = new ServerTuple { Server = mockServer.Object }; } else { var mockMonitorFactory = new Mock <IServerMonitorFactory>(); var mockMonitor = new Mock <IServerMonitor>() { DefaultValue = DefaultValue.Mock }; mockMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), It.IsAny <EndPoint>())).Returns(mockMonitor.Object); mockMonitor.SetupGet(m => m.Description).Returns(description); mockMonitor .Setup(s => s.Dispose()) .Callback( () => { _servers[mockMonitor.Object.Description.EndPoint].HasBeenRemoved = true; }); var mockConnection = new Mock <IConnectionHandle>(); var mockConnectionPool = new Mock <IConnectionPool>(); var poolGeneration = 0; var connectionGeneration = 0; // need to use a func to close over connectionGeneration mockConnection.Setup(c => c.Generation).Returns(valueFunction: () => connectionGeneration); // need to use a func to close over poolGeneration mockConnectionPool.Setup(p => p.Generation).Returns(valueFunction: () => poolGeneration); Action acquireConnectionCallback = () => { connectionGeneration = poolGeneration; }; mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Callback(acquireConnectionCallback) .Returns(mockConnection.Object); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Callback(acquireConnectionCallback) .ReturnsAsync(mockConnection.Object); mockConnectionPool.Setup(p => p.Clear()).Callback(() => { ++poolGeneration; }); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory> { DefaultValue = DefaultValue.Mock }; mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), endPoint)) .Returns(mockConnectionPool.Object); result = new ServerTuple { Server = CreateServer(clusterType, mockConnectionPoolFactory.Object, mockMonitorFactory.Object), Monitor = mockMonitor.Object }; } _servers[endPoint] = result; } return(result.Server); IClusterableServer CreateServer(ClusterType clusterType, IConnectionPoolFactory connectionPoolFactory, IServerMonitorFactory serverMonitorFactory) { switch (clusterType) { case ClusterType.LoadBalanced: return(new LoadBalancedServer( clusterId, clusterClock, new ServerSettings(), endPoint, connectionPoolFactory, _eventSubscriber, serverApi: null)); default: return(new DefaultServer( 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, new ServerSettings(), endPoint, connectionPoolFactory, serverMonitorFactory, _eventSubscriber, serverApi: null)); } } }
// methods /// <inheritdoc/> public IClusterableServer CreateServer(ClusterType clusterType, ClusterId clusterId, IClusterClock clusterClock, EndPoint endPoint) => clusterType switch {
public ClusterClockAdvancingCoreSession(ICoreSession wrapped, IClusterClock clusterClock) : base(wrapped, ownsWrapped: false) { _clusterClock = Ensure.IsNotNull(clusterClock, nameof(clusterClock)); }