/// <summary>
/// Checks whether the server is alive (throws an exception if not).
/// </summary>
public void Ping()
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new PingOperation(messageEncoderSettings);
var server = GetServer();
using (var binding = new SingleServerReadBinding(server, ReadPreference.PrimaryPreferred, NoCoreSession.NewHandle()))
{
operation.Execute(binding, CancellationToken.None);
}
}
public void Execute_should_return_expected_result()
{
RequireServer.Check();
var subject = new CurrentOpUsingCommandOperation(_adminDatabaseNamespace, _messageEncoderSettings);
using (var binding = new ReadPreferenceBinding(CoreTestConfiguration.Cluster, ReadPreference.PrimaryPreferred, NoCoreSession.NewHandle()))
{
var result = subject.Execute(binding, CancellationToken.None);
result.Contains("inprog");
}
}
public IActionResult RunScript(string query)
{
if (string.IsNullOrEmpty(query))
{
return(Json(new { Result = false, Message = "Empty query!" }));
}
try
{
var bscript = new BsonJavaScript(query);
var operation = new EvalOperation(_mongoDBContext.Database().DatabaseNamespace, bscript, null);
var writeBinding = new WritableServerBinding(_mongoDBContext.Database().Client.Cluster, NoCoreSession.NewHandle());
var result = operation.Execute(writeBinding, CancellationToken.None);
var xx = result["_ns"];
return(Json(new { Result = true, Message = result.ToString() }));
}
catch (Exception ex)
{
return(Json(new { Result = false, Message = ex.Message }));
}
}
protected override void CallMethod(CancellationToken cancellationToken)
{
var server = GetServer();
TestRunner.ConfigureFailPoint(server, NoCoreSession.NewHandle(), _failCommand);
}
protected override async Task CallMethodAsync(CancellationToken cancellationToken)
{
var server = await GetServerAsync().ConfigureAwait(false);
await TestRunner.ConfigureFailPointAsync(server, NoCoreSession.NewHandle(), _failCommand).ConfigureAwait(false);
}
public void Execute_should_return_expected_result()
{
RequireServer.Check().VersionGreaterThanOrEqualTo("3.1.2");
var subject = new CurrentOpOperation(_adminDatabaseNamespace, _messageEncoderSettings);
using (var binding = new ReadPreferenceBinding(CoreTestConfiguration.Cluster, ReadPreference.PrimaryPreferred, NoCoreSession.NewHandle()))
{
var result = subject.Execute(binding);
result.Contains("inprog");
}
}
private (IConnectionPool, FailPoint, ICluster, Func <object, bool>) SetupConnectionData(BsonDocument test, EventCapturer eventCapturer, bool isUnit)
{
ParseSettings(test, out var connectionPoolSettings, out var connectionSettings);
IConnectionPool connectionPool;
ICluster cluster = null;
FailPoint failPoint = null;
Func <object, bool> eventsFilter = _ => true;
if (isUnit)
{
var endPoint = new DnsEndPoint("localhost", 27017);
var serverId = new ServerId(new ClusterId(), endPoint);
var connectionFactory = new Mock <IConnectionFactory>();
var connectionExceptionHandler = new Mock <IConnectionExceptionHandler>();
connectionFactory
.Setup(c => c.CreateConnection(serverId, endPoint))
.Returns(() =>
{
var connection = new MockConnection(serverId, connectionSettings, eventCapturer);
return(connection);
});
connectionPool = new ExclusiveConnectionPool(
serverId,
endPoint,
connectionPoolSettings,
connectionFactory.Object,
eventCapturer,
connectionExceptionHandler.Object);
connectionPool.Initialize();
}
else
{
var async = test.GetValue(Schema.async).ToBoolean();
cluster = CoreTestConfiguration.CreateCluster(b => b
.ConfigureServer(s => s.With(
heartbeatInterval: TimeSpan.FromMinutes(10)))
.ConfigureConnectionPool(c => c.With(
maxConnecting: connectionPoolSettings.MaxConnecting,
maxConnections: connectionPoolSettings.MaxConnections,
minConnections: connectionPoolSettings.MinConnections,
maintenanceInterval: connectionPoolSettings.MaintenanceInterval,
waitQueueTimeout: connectionPoolSettings.WaitQueueTimeout))
.ConfigureConnection(s => s.With(applicationName: $"{connectionSettings.ApplicationName}_async_{async}"))
.Subscribe(eventCapturer));
var server = cluster.SelectServer(WritableServerSelector.Instance, CancellationToken.None);
connectionPool = server._connectionPool();
if (test.TryGetValue(Schema.Intergration.failPoint, out var failPointDocument))
{
if (failPointDocument.AsBsonDocument.Contains("data"))
{
var data = failPointDocument["data"].AsBsonDocument;
if (data.TryGetValue("appName", out var appNameValue))
{
data["appName"] = $"{appNameValue}_async_{async}";
}
}
var resetPool = connectionPoolSettings.MinConnections > 0;
if (resetPool)
{
eventCapturer.WaitForOrThrowIfTimeout(events => events.Any(e => e is ConnectionCreatedEvent), TimeSpan.FromMilliseconds(500));
var connectionIdsToIgnore = new HashSet <int>(eventCapturer.Events
.OfType <ConnectionCreatedEvent>()
.Select(c => c.ConnectionId.LocalValue)
.ToList());
eventsFilter = o =>
{
if (o is ConnectionOpenedEvent
or ConnectionClosedEvent
or ConnectionCreatedEvent
or ConnectionFailedEvent)
{
var connectionId = o.ConnectionId();
return(!connectionIdsToIgnore.Contains(connectionId.LocalValue) &&
EndPointHelper.Equals(connectionId.ServerId.EndPoint, server.EndPoint));
}
if (o is ConnectionPoolReadyEvent
or ConnectionPoolClearedEvent)
{
var serverId = o.ServerId();
return(EndPointHelper.Equals(serverId.EndPoint, server.EndPoint));
}
return(true);
};
connectionPool.Clear(closeInUseConnections: false);
eventCapturer.WaitForOrThrowIfTimeout(events => events.Any(e => e is ConnectionPoolClearedEvent), TimeSpan.FromMilliseconds(500));
}
var failPointServer = CoreTestConfiguration.Cluster.SelectServer(new EndPointServerSelector(server.EndPoint), default);
failPoint = FailPoint.Configure(failPointServer, NoCoreSession.NewHandle(), failPointDocument.AsBsonDocument);
if (resetPool)
{
eventCapturer.Clear();
connectionPool.SetReady();
}
}
}
return(connectionPool, failPoint, cluster, eventsFilter);
}
private void DoWork(ICluster cluster)
{
var rand = new Random();
using (var binding = new WritableServerBinding(cluster, NoCoreSession.NewHandle()))
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
var i = rand.Next(0, 10000);
IReadOnlyList <BsonDocument> docs;
using (var cursor = Query(binding, new BsonDocument("i", i)))
{
try
{
if (cursor.MoveNext(_cancellationTokenSource.Token))
{
docs = cursor.Current.ToList();
}
else
{
docs = null;
}
//Console.Write(".");
}
catch
{
Console.Write("+");
continue;
}
}
if (docs == null || docs.Count == 0)
{
try
{
Insert(binding, new BsonDocument().Add("i", i));
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
else
{
try
{
var filter = new BsonDocument("_id", docs[0]["_id"]);
var update = new BsonDocument("$set", new BsonDocument("i", i + 1));
Update(binding, filter, update);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
}
}
}
public async Task PoolClearedError_read_retryablity_test([Values(true, false)] bool async)
{
RequireServer.Check().Supports(Feature.FailPointsBlockConnection);
var heartbeatInterval = TimeSpan.FromMilliseconds(50);
var eventsWaitTimeout = TimeSpan.FromMilliseconds(5000);
var failPointCommand = BsonDocument.Parse(
$@"{{
configureFailPoint : 'failCommand',
mode : {{ 'times' : 1 }},
data :
{{
failCommands : [ 'find' ],
errorCode : 91,
blockConnection: true,
blockTimeMS: 1000
}}
}}");
IServerSelector failPointSelector = new ReadPreferenceServerSelector(ReadPreference.Primary);
var settings = DriverTestConfiguration.GetClientSettings();
if (CoreTestConfiguration.Cluster.Description.Type == Core.Clusters.ClusterType.Sharded)
{
var serverAddress = settings.Servers.First();
settings.Servers = new[] { serverAddress };
// set settings.DirectConnection = true after removing obsolete ConnectionMode
#pragma warning disable CS0618 // Type or member is obsolete
settings.ConnectionMode = ConnectionMode.Direct;
#pragma warning restore CS0618 // Type or member is obsolete
failPointSelector = new EndPointServerSelector(new DnsEndPoint(serverAddress.Host, serverAddress.Port));
}
settings.MaxConnectionPoolSize = 1;
settings.RetryReads = true;
var eventCapturer = new EventCapturer()
.Capture <ConnectionPoolClearedEvent>()
.Capture <ConnectionPoolCheckedOutConnectionEvent>()
.Capture <ConnectionPoolCheckingOutConnectionFailedEvent>()
.CaptureCommandEvents("find");
var failpointServer = DriverTestConfiguration.Client.Cluster.SelectServer(failPointSelector, default);
using var failPoint = FailPoint.Configure(failpointServer, NoCoreSession.NewHandle(), failPointCommand);
using var client = CreateClient(settings, eventCapturer, heartbeatInterval);
var database = client.GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName);
var collection = database.GetCollection <BsonDocument>(DriverTestConfiguration.CollectionNamespace.CollectionName);
eventCapturer.Clear();
if (async)
{
await ThreadingUtilities.ExecuteTasksOnNewThreads(2, async __ =>
{
var cursor = await collection.FindAsync(FilterDefinition <BsonDocument> .Empty);
_ = await cursor.ToListAsync();
});
}
else
{
ThreadingUtilities.ExecuteOnNewThreads(2, __ =>
{
_ = collection.Find(FilterDefinition <BsonDocument> .Empty).ToList();
});
}
// wait for 2 CommandSucceededEvent events, meaning that all other events should be received
eventCapturer.WaitForOrThrowIfTimeout(
events => events.OfType <CommandSucceededEvent>().Count() == 2,
eventsWaitTimeout);
eventCapturer.Events.OfType <CommandStartedEvent>().Count().Should().Be(3);
eventCapturer.Events.OfType <CommandFailedEvent>().Count().Should().Be(1);
eventCapturer.Events.OfType <CommandSucceededEvent>().Count().Should().Be(2);
eventCapturer.Events.OfType <ConnectionPoolClearedEvent>().Count().Should().Be(1);
eventCapturer.Events.OfType <ConnectionPoolCheckedOutConnectionEvent>().Count().Should().Be(3);
eventCapturer.Events.OfType <ConnectionPoolCheckingOutConnectionFailedEvent>().Count().Should().Be(1);
}
private IDisposable RequestStart(IServerSelector serverSelector, ReadPreference readPreference)
{
var request = __threadStaticRequest;
if (request != null)
{
var selected = serverSelector.SelectServers(_cluster.Description, new[] { request.ServerDescription }).ToList();
if (selected.Count == 0)
{
throw new InvalidOperationException("A nested call to RequestStart was made that is not compatible with the existing request.");
}
request.NestingLevel++;
return(new RequestStartResult(this));
}
IReadBindingHandle channelBinding;
ConnectionId connectionId;
var server = _cluster.SelectServer(serverSelector, CancellationToken.None);
using (var channel = server.GetChannel(CancellationToken.None))
{
if (readPreference.ReadPreferenceMode == ReadPreferenceMode.Primary)
{
channelBinding = new ReadWriteBindingHandle(new ChannelReadWriteBinding(server, channel.Fork(), NoCoreSession.NewHandle()));
}
else
{
channelBinding = new ReadBindingHandle(new ChannelReadBinding(server, channel.Fork(), readPreference, NoCoreSession.NewHandle()));
}
connectionId = channel.ConnectionDescription.ConnectionId;
}
var serverDescription = server.Description;
var serverInstance = _serverInstances.Single(i => EndPointHelper.Equals(i.EndPoint, serverDescription.EndPoint));
var session = _operationExecutor.StartImplicitSession(CancellationToken.None);
__threadStaticRequest = new Request(serverDescription, serverInstance, channelBinding, connectionId, session);
return(new RequestStartResult(this));
}
