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));
}
