private void AssertAuthenticationSucceeds(
MongoClientSettings settings,
bool async,
bool speculativeAuthenticatationShouldSucceedIfPossible = true)
{
// If we don't use a DisposableClient, the second run of AuthenticationSucceedsWithMongoDB_X509_mechanism
// will fail because the backing Cluster's connections will be associated with a dropped user
using (var client = DriverTestConfiguration.CreateDisposableclient(settings))
{
// The first command executed with the MongoClient triggers either the sync or async variation of the
// MongoClient's IAuthenticator
if (async)
{
_ = client.ListDatabaseNamesAsync().GetAwaiter().GetResult().ToList();
}
else
{
_ = client.ListDatabaseNames().ToList();
}
if (Feature.SpeculativeAuthentication.IsSupported(CoreTestConfiguration.ServerVersion) &&
speculativeAuthenticatationShouldSucceedIfPossible)
{
var cancellationToken = CancellationToken.None;
var serverSelector = new ReadPreferenceServerSelector(settings.ReadPreference);
var server = client.Cluster.SelectServer(serverSelector, cancellationToken);
var channel = server.GetChannel(cancellationToken);
var isMasterResult = channel.ConnectionDescription.IsMasterResult;
isMasterResult.SpeculativeAuthenticate.Should().NotBeNull();
}
}
}
/// <summary>
/// Connects to the server. Normally there is no need to call this method as
/// the driver will connect to the server automatically when needed.
/// </summary>
/// <param name="timeout">How long to wait before timing out.</param>
public virtual void Connect(TimeSpan timeout)
{
var readPreference = _settings.ReadPreference;
var readPreferenceServerSelector = new ReadPreferenceServerSelector(readPreference);
_cluster.SelectServerAsync(readPreferenceServerSelector, timeout, CancellationToken.None).GetAwaiter().GetResult();
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var testDefinition = testCase.Test;
var testData = BsonSerializer.Deserialize <TestData>(testDefinition);
var clusterDescription = ServerSelectionTestHelper.BuildClusterDescription(testData.topology_description);
using var cluster = CreateAndSetupCluster(clusterDescription, testData.mocked_topology_state);
var readPreferenceSelector = new ReadPreferenceServerSelector(ReadPreference.Nearest);
var selectionHistogram = testData.outcome.expected_frequencies.Keys
.ToDictionary(s => clusterDescription.Servers.Single(d => d.EndPoint.ToString().EndsWith(s)).ServerId, s => 0);
var selectionFrequenciesExpected = testData.outcome.expected_frequencies.
ToDictionary(s => clusterDescription.Servers.Single(d => d.EndPoint.ToString().EndsWith(s.Key)).ServerId, s => s.Value);
for (int i = 0; i < testData.iterations; i++)
{
var selectedServer = testData.async
? cluster.SelectServerAsync(readPreferenceSelector, default).GetAwaiter().GetResult()
: cluster.SelectServer(readPreferenceSelector, default);
selectionHistogram[selectedServer.ServerId]++;
}
foreach (var pair in selectionHistogram)
{
var expectedFrequency = selectionFrequenciesExpected[pair.Key];
var actualFrequency = pair.Value / (double)testData.iterations;
actualFrequency.Should().BeInRange(expectedFrequency - testData.outcome.tolerance, expectedFrequency + testData.outcome.tolerance);
}
}
private IReadBindingHandle GetSingleServerReadBinding(CancellationToken cancellationToken)
{
var readPreference = _options.ReadPreference ?? _database.Settings.ReadPreference;
var selector = new ReadPreferenceServerSelector(readPreference);
var server = _cluster.SelectServer(selector, cancellationToken);
var binding = new SingleServerReadBinding(server, readPreference, NoCoreSession.NewHandle());
return(new ReadBindingHandle(binding));
}
/// <summary>
/// Connects to the server. Normally there is no need to call this method as
/// the driver will connect to the server automatically when needed.
/// </summary>
/// <param name="timeout">How long to wait before timing out.</param>
public virtual void Connect(TimeSpan timeout)
{
var readPreference = _settings.ReadPreference;
var readPreferenceServerSelector = new ReadPreferenceServerSelector(readPreference);
using (var timeoutCancellationTokenSource = new CancellationTokenSource(timeout))
{
_cluster.SelectServer(readPreferenceServerSelector, timeoutCancellationTokenSource.Token);
}
}
private async Task <IReadBindingHandle> GetSingleServerReadBindingAsync(CancellationToken cancellationToken)
{
var readPreference = _options.ReadPreference ?? _database.Settings.ReadPreference;
var selector = new ReadPreferenceServerSelector(readPreference);
var server = await _cluster.SelectServerAsync(selector, cancellationToken).ConfigureAwait(false);
var binding = new SingleServerReadBinding(server, readPreference, NoCoreSession.NewHandle());
return(new ReadBindingHandle(binding));
}
private static bool IsReplicaSet(string uri)
{
var clusterBuilder = new ClusterBuilder();
clusterBuilder.ConfigureWithConnectionString(uri);
using (var cluster = clusterBuilder.BuildCluster())
{
cluster.Initialize();
var serverSelector = new ReadPreferenceServerSelector(ReadPreference.PrimaryPreferred);
var server = cluster.SelectServer(serverSelector, CancellationToken.None);
return(server.Description.Type.IsReplicaSetMember());
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "_path", "in_latency_window", "operation", "read_preference", "suitable_servers", "topology_description", "heartbeatFrequencyMS", "error");
var error = definition.GetValue("error", false).ToBoolean();
var heartbeatInterval = TimeSpan.FromMilliseconds(definition.GetValue("heartbeatFrequencyMS", 10000).ToInt64());
var clusterDescription = ServerSelectionTestHelper.BuildClusterDescription((BsonDocument)definition["topology_description"], heartbeatInterval);
IServerSelector selector;
if (definition.GetValue("operation", "read").AsString == "write")
{
selector = WritableServerSelector.Instance;
}
else
{
ReadPreference readPreference;
try
{
readPreference = BuildReadPreference(definition["read_preference"].AsBsonDocument);
}
catch
{
if (error)
{
return;
}
throw;
}
selector = new ReadPreferenceServerSelector(readPreference);
}
if (error)
{
RunErrorTest(clusterDescription, selector);
}
else
{
RunNonErrorTest(definition, clusterDescription, selector, heartbeatInterval);
}
}
public void RunTestDefinition(BsonDocument definition)
{
var error = definition.GetValue("error", false).ToBoolean();
var heartbeatInterval = TimeSpan.FromMilliseconds(definition.GetValue("heartbeatFrequencyMS", 10000).ToInt64());
var clusterDescription = BuildClusterDescription((BsonDocument)definition["topology_description"], heartbeatInterval);
IServerSelector selector;
if (definition.GetValue("operation", "read").AsString == "write")
{
selector = WritableServerSelector.Instance;
}
else
{
ReadPreference readPreference;
try
{
readPreference = BuildReadPreference(definition["read_preference"].AsBsonDocument);
}
catch
{
if (error)
{
return;
}
throw;
}
selector = new ReadPreferenceServerSelector(readPreference);
}
if (error)
{
RunErrorTest(clusterDescription, selector);
}
else
{
RunNonErrorTest(definition, clusterDescription, selector, heartbeatInterval);
}
}
/// <summary>
/// Lets the server know that this thread is about to begin a series of related operations that must all occur
/// on the same connection. The return value of this method implements IDisposable and can be placed in a
/// using statement (in which case RequestDone will be called automatically when leaving the using statement).
/// </summary>
/// <param name="readPreference">The read preference.</param>
/// <returns>A helper object that implements IDisposable and calls <see cref="RequestDone"/> from the Dispose method.</returns>
internal virtual IDisposable RequestStart(ReadPreference readPreference)
{
var serverSelector = new ReadPreferenceServerSelector(readPreference);
return(RequestStart(serverSelector, readPreference));
}
/// <summary>
/// Lets the server know that this thread is about to begin a series of related operations that must all occur
/// on the same connection. The return value of this method implements IDisposable and can be placed in a
/// using statement (in which case RequestDone will be called automatically when leaving the using statement).
/// </summary>
/// <param name="initialDatabase">One of the databases involved in the related operations.</param>
/// <param name="readPreference">The read preference.</param>
/// <returns>A helper object that implements IDisposable and calls <see cref="RequestDone"/> from the Dispose method.</returns>
public virtual IDisposable RequestStart(MongoDatabase initialDatabase, ReadPreference readPreference)
{
var serverSelector = new ReadPreferenceServerSelector(readPreference);
return(RequestStart(serverSelector, readPreference));
}
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);
}
