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