public void GetBytesUsingThreadStaticBuffer_should_return_expected_result_when_multiple_threads_are_used([RandomSeed] int seed)
{
const int threadsCount = 10;
const int iterationsCount = 10;
const int maxSize = 1024;
var random = new Random(seed);
var encoding = Utf8Encodings.Strict;
ThreadingUtilities.ExecuteOnNewThreads(threadsCount, _ =>
{
for (int j = 0; j < iterationsCount; j++)
{
var sizeCurrent = random.Next(8, maxSize);
var str = GetString(sizeCurrent);
using var rentedSegment = encoding.GetBytesUsingThreadStaticBuffer(str);
var segment = rentedSegment.Segment;
var encodedExpected = encoding.GetBytes(str);
var encodedActual = segment.ToArray();
encodedActual.ShouldAllBeEquivalentTo(encodedExpected);
}
});
}
/// <summary>
/// Deinitialization method cleaning all the created objects
/// </summary>
public async Task Deinitialize()
{
//Client should wait for master to break the connection
if (IsClient)
{
while (Client.Connection.ConnectedPeersCount > 0)
{
await Task.Delay(20);
}
}
StopConnection();
var type = Type;
var clearObjectsAction = new Action(() =>
{
ClearNetworkObjects(type);
});
ThreadingUtilities.DispatchToMainThread(clearObjectsAction);
LocalAddresses.Clear();
MasterAddresses.Clear();
Type = ClusterNodeType.NotClusterNode;
CurrentSimulation = null;
Log.Info("Deinitialized the Simulation Network data.");
}
private void ProcessRequest(int index)
{
Action <Exception> action1 = null;
WebService.QueuedRequest queuedRequest = this._currentRequests[index];
Guid guid = Guid.NewGuid();
string serverRequestUrl = WebService.GetServerRequestUrl(queuedRequest.Service, queuedRequest.Request, queuedRequest.IsSkyTrakCall);
object[] service = new object[] { queuedRequest.Service, queuedRequest.Request, guid, serverRequestUrl, null, null };
service[4] = (queuedRequest.PostFields.Count != 0 ? string.Format("{0}?{1}", serverRequestUrl, (
from kvp in queuedRequest.PostFields
select string.Format("{0}={1}", kvp.Key, kvp.Value)).Aggregate <string>((string s1, string s2) => string.Concat(s1, "&", s2))) : serverRequestUrl);
service[5] = (queuedRequest.PostFields.Count != 0 ? (
from kvp in queuedRequest.PostFields
select string.Format("{{ {0}, {1} }}", kvp.Key, kvp.Value)).Aggregate <string>((string s1, string s2) => string.Concat(s1, ",\n", s2)) : string.Empty);
AppLog.Log(string.Format("=== CallWebService. Service: {0}. Request: {1}. ID: {2}\nURL {3}\nGET: {4}\nData:\n{5}", service), true);
WebService.Request(serverRequestUrl, queuedRequest.PostFields, (string response) => {
string str;
string str1;
string str2;
bool flag;
AppLog.Log(string.Format("=== CallWebService Response. Service: {0}. Request: {1}. ID: {2}\nURL {3}\nData:\n{4}", new object[] { queuedRequest.Service, queuedRequest.Request, guid, serverRequestUrl, response }), true);
if (string.IsNullOrEmpty(response))
{
NetworkInternetVerification.instance.Reset();
}
WebService.ParseStatus(response, out str2, out str, out str1, out flag);
Action callback = () => queuedRequest.Callback(new WebServiceResponse(queuedRequest.Service, queuedRequest.Request, response, str, str1, str2, flag));
if (!queuedRequest.CallbackInParallelThread)
{
callback();
}
else
{
Action action = callback;
if (action1 == null)
{
action1 = (Exception ex) => AppLog.LogException(ex, true);
}
ThreadingUtilities.Run(action, null, action1);
}
this._currentRequests[index] = null;
});
}
public void SelectServer_loadbalancing_prose_test([Values(false, true)] bool async)
{
RequireServer.Check()
.Supports(Feature.ShardedTransactions, Feature.FailPointsBlockConnection)
.ClusterType(ClusterType.Sharded);
RequireMultipleShardRouters();
// temporary disable the test on Win Auth topologies, due to operations timings irregularities
if (CoreTestConfiguration.ConnectionString.Tls == true &&
RequirePlatform.GetCurrentOperatingSystem() == SupportedOperatingSystem.Windows)
{
throw new SkipException("Win Auth topologies temporary not supported due to timings irregularities.");
}
const string applicationName = "loadBalancingTest";
const int threadsCount = 10;
const int commandsPerThreadCount = 10;
const double maxCommandsOnSlowServerRatio = 0.3; // temporary set slow server load to 30% from 25% until find timings are investigated
const double operationsCountTolerance = 0.10;
var failCommand = BsonDocument.Parse($"{{ configureFailPoint: 'failCommand', mode : {{ times : 10000 }}, data : {{ failCommands : [\"find\"], blockConnection: true, blockTimeMS: 500, appName: '{applicationName}' }} }}");
DropCollection();
var eventCapturer = CreateEventCapturer();
using (var client = CreateDisposableClient(eventCapturer, applicationName))
{
var slowServer = client.Cluster.SelectServer(WritableServerSelector.Instance, default);
var fastServer = client.Cluster.SelectServer(new DelegateServerSelector((_, servers) => servers.Where(s => s.ServerId != slowServer.ServerId)), default);
using var failPoint = FailPoint.Configure(slowServer, NoCoreSession.NewHandle(), failCommand);
var database = client.GetDatabase(_databaseName);
CreateCollection();
var collection = database.GetCollection <BsonDocument>(_collectionName);
// warm up connections
var channels = new ConcurrentBag <IChannelHandle>();
ThreadingUtilities.ExecuteOnNewThreads(threadsCount, i =>
{
channels.Add(slowServer.GetChannel(default));
channels.Add(fastServer.GetChannel(default));
public async Task PoolClearedError_write_retryablity_test([Values(false, true)] bool async)
{
RequireServer.Check()
.Supports(Feature.FailPointsBlockConnection)
.ClusterTypes(ClusterType.ReplicaSet, ClusterType.Sharded);
var heartbeatInterval = TimeSpan.FromMilliseconds(50);
var eventsWaitTimeout = TimeSpan.FromMilliseconds(5000);
var failPointCommand = BsonDocument.Parse(
$@"{{
configureFailPoint : 'failCommand',
mode : {{ 'times' : 1 }},
data :
{{
failCommands : [ 'insert' ],
errorCode : 91,
blockConnection: true,
blockTimeMS: 1000,
errorLabels: [""RetryableWriteError""]
}}
}}");
IServerSelector failPointSelector = WritableServerSelector.Instance;
var settings = DriverTestConfiguration.GetClientSettings();
if (CoreTestConfiguration.Cluster.Description.Type == 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.RetryWrites = true;
var eventCapturer = new EventCapturer()
.Capture <ConnectionPoolClearedEvent>()
.Capture <ConnectionPoolCheckedOutConnectionEvent>()
.Capture <ConnectionPoolCheckingOutConnectionFailedEvent>()
.CaptureCommandEvents("insert");
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 _ =>
{
await collection.InsertOneAsync(new BsonDocument("x", 1));
});
}
else
{
ThreadingUtilities.ExecuteOnNewThreads(2, _ =>
{
collection.InsertOne(new BsonDocument("x", 1));
});
}
// 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);
}
public async Task Ensure_server_session_are_allocated_only_on_connection_checkout([Values(true, false)] bool async)
{
var eventCapturer = new EventCapturer()
.Capture <CommandStartedEvent>();
using var client = DriverTestConfiguration.CreateDisposableClient(
(MongoClientSettings settings) =>
{
settings.RetryWrites = true;
settings.MaxConnectionPoolSize = 1;
settings.ClusterConfigurator = c => c.Subscribe(eventCapturer);
},
logger: null);
var database = client.GetDatabase("test");
database.DropCollection("inventory");
var collection = database.GetCollection <BsonDocument>("inventory");
const int operationsCount = 8;
var singleSessionUsed = false;
for (int i = 0; i < 5; i++)
{
eventCapturer.Clear();
await ThreadingUtilities.ExecuteTasksOnNewThreads(operationsCount, async i =>
{
switch (i)
{
case 0:
if (async)
{
await collection.InsertOneAsync(new BsonDocument("x", 0));
}
else
{
collection.InsertOne(new BsonDocument("x", 0));
}
break;
case 1:
if (async)
{
await collection.DeleteOneAsync(Builders <BsonDocument> .Filter.Eq("_id", 1));
}
else
{
collection.DeleteOne(Builders <BsonDocument> .Filter.Eq("_id", 1));
}
break;
case 2:
if (async)
{
await collection.UpdateOneAsync(Builders <BsonDocument> .Filter.Empty, Builders <BsonDocument> .Update.Set("a", 1));
}
else
{
collection.UpdateOne(Builders <BsonDocument> .Filter.Empty, Builders <BsonDocument> .Update.Set("a", 1));
}
break;
case 3:
var bulkWriteRequests = new WriteModel <BsonDocument>[]
{
new UpdateOneModel <BsonDocument>(Builders <BsonDocument> .Filter.Empty, new BsonDocument("$set", new BsonDocument("1", 1)))
};
if (async)
{
await collection.BulkWriteAsync(bulkWriteRequests);
}
else
{
collection.BulkWrite(bulkWriteRequests);
}
break;
case 4:
if (async)
{
await collection.FindOneAndDeleteAsync(Builders <BsonDocument> .Filter.Empty);
}
else
{
collection.FindOneAndDelete(Builders <BsonDocument> .Filter.Empty);
}
break;
case 5:
if (async)
{
await collection.FindOneAndUpdateAsync(Builders <BsonDocument> .Filter.Empty, Builders <BsonDocument> .Update.Set("a", 1));
}
else
{
collection.FindOneAndUpdate(Builders <BsonDocument> .Filter.Empty, Builders <BsonDocument> .Update.Set("a", 1));
}
break;
case 6:
if (async)
{
await collection.FindOneAndReplaceAsync(Builders <BsonDocument> .Filter.Empty, new BsonDocument("x", 0));
}
else
{
collection.FindOneAndReplace(Builders <BsonDocument> .Filter.Empty, new BsonDocument("x", 0));
}
break;
case 7:
if (async)
{
var cursor = await collection.FindAsync(Builders <BsonDocument> .Filter.Empty);
_ = await cursor.ToListAsync();
}
else
{
_ = collection.Find(Builders <BsonDocument> .Filter.Empty).ToList();
}
break;
}
});
eventCapturer.WaitForOrThrowIfTimeout(e => e.OfType <CommandStartedEvent>().Count() >= operationsCount, TimeSpan.FromSeconds(10));
var lsids = eventCapturer.Events.OfType <CommandStartedEvent>().Select(c => c.Command["lsid"]).ToArray();
var distinctLsidsCount = lsids.Distinct().Count();
distinctLsidsCount.Should().BeLessThan(operationsCount);
if (distinctLsidsCount == 1)
{
singleSessionUsed = true;
break;
}
}
singleSessionUsed.Should().BeTrue("At least one iteration should use single session");
}
public void AquireConnection_non_sufficient_reused_connections_should_timeout(
[Values(true, false)]
bool async)
{
int maxConnecting = MongoInternalDefaults.ConnectionPool.MaxConnecting;
const int initalAcquiredCount = 2;
const int maxAcquiringCount = 4;
const int queueTimeoutMS = 50;
var settings = _settings.With(
waitQueueSize: maxAcquiringCount + initalAcquiredCount + maxConnecting,
maxConnections: maxAcquiringCount + initalAcquiredCount + maxConnecting,
waitQueueTimeout: TimeSpan.FromMilliseconds(queueTimeoutMS),
minConnections: 0);
var allAcquiringCountEvent = new CountdownEvent(maxAcquiringCount + initalAcquiredCount);
var blockEstablishmentEvent = new ManualResetEventSlim(true);
var establishingCount = new CountdownEvent(maxConnecting + initalAcquiredCount);
var mockConnectionFactory = new Mock <IConnectionFactory>();
mockConnectionFactory
.Setup(c => c.CreateConnection(It.IsAny <ServerId>(), It.IsAny <EndPoint>()))
.Returns(() =>
{
var connectionMock = new Mock <IConnection>();
connectionMock
.Setup(c => c.ConnectionId)
.Returns(new ConnectionId(_serverId));
connectionMock
.Setup(c => c.Settings)
.Returns(new ConnectionSettings());
connectionMock
.Setup(c => c.Open(It.IsAny <CancellationToken>()))
.Callback(() =>
{
if (establishingCount.CurrentCount > 0)
{
establishingCount.Signal();
}
blockEstablishmentEvent.Wait();
});
connectionMock
.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>()))
.Returns(() =>
{
if (establishingCount.CurrentCount > 0)
{
establishingCount.Signal();
}
blockEstablishmentEvent.Wait();
return(Task.FromResult(0));
});
return(connectionMock.Object);
});
using var subject = CreateSubject(settings, mockConnectionFactory.Object);
subject.Initialize();
subject.PendingCount.Should().Be(0);
var connectionsAcquired = Enumerable.Range(0, initalAcquiredCount)
.Select(i => AcquireConnection(subject, async))
.ToArray();
// block further establishments
blockEstablishmentEvent.Reset();
var allConnections = new List <IConnection>();
var actualTimeouts = 0;
var expectedTimeouts = maxAcquiringCount - maxConnecting;
ThreadingUtilities.ExecuteOnNewThreads(maxAcquiringCount + maxConnecting + 1, threadIndex =>
{
if (threadIndex < maxConnecting)
{
// maximize maxConnecting
allAcquiringCountEvent.Signal();
AcquireConnection(subject, async);
}
else if (threadIndex < maxConnecting + maxAcquiringCount)
{
// wait until all maxConnecting maximized
establishingCount.Wait();
subject.PendingCount.Should().Be(maxConnecting);
allAcquiringCountEvent.Signal();
try
{
AcquireConnection(subject, async);
}
catch (TimeoutException)
{
Interlocked.Increment(ref actualTimeouts);
}
// speedup the test
if (expectedTimeouts == actualTimeouts)
{
blockEstablishmentEvent.Set();
}
}
else
{
// wait until all trying to acquire
allAcquiringCountEvent.Wait();
// return connections
foreach (var connection in connectionsAcquired)
{
connection.Dispose();
}
}
});
expectedTimeouts.Should().Be(expectedTimeouts);
subject.PendingCount.Should().Be(0);
}
