private CursorBatch <TDocument> GetNextBatch(CancellationToken cancellationToken) { using (EventContext.BeginOperation(_operationId)) using (var channel = _channelSource.GetChannel(cancellationToken)) { if (Feature.FindCommand.IsSupported(channel.ConnectionDescription.ServerVersion)) { return(ExecuteGetMoreCommand(channel, cancellationToken)); } else { return(ExecuteGetMoreProtocol(channel, cancellationToken)); } } }
/// <inheritdoc/> public async Task <BulkWriteOperationResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var context = await RetryableWriteContext.CreateAsync(binding, _retryRequested, cancellationToken).ConfigureAwait(false)) { EnsureHintIsSupportedIfAnyRequestHasHint(); context.DisableRetriesIfAnyWriteRequestIsNotRetryable(_requests); var helper = new BatchHelper(_requests, _isOrdered, _writeConcern); foreach (var batch in helper.GetBatches()) { batch.Result = await ExecuteBatchAsync(context, batch, cancellationToken).ConfigureAwait(false); } return(helper.GetFinalResultOrThrow(context.Channel.ConnectionDescription.ConnectionId)); } }
private async Task <CursorBatch <TDocument> > GetNextBatchAsync(CancellationToken cancellationToken) { using (EventContext.BeginOperation(_operationId)) using (var channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) { if (SupportedFeatures.IsFindCommandSupported(channel.ConnectionDescription.ServerVersion)) { return(await ExecuteGetMoreCommandAsync(channel, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteGetMoreProtocolAsync(channel, cancellationToken).ConfigureAwait(false)); } } }
/// <inheritdoc/> public WriteConcernResult Execute(RetryableWriteContext context, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) { if (_writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(emulator.Execute(context, cancellationToken)); } else { return(ExecuteProtocol(context.Channel, cancellationToken)); } } }
/// <inheritdoc/> public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { if (channelSource.ServerDescription.Version >= __serverVersionSupportingCreateIndexesCommand) { return(await ExecuteUsingCommandAsync(channelSource, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteUsingInsertAsync(channelSource, cancellationToken).ConfigureAwait(false)); } } }
/// <inheritdoc/> public async Task <IReadOnlyList <IAsyncCursor <TDocument> > > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) using (var channelBinding = new ChannelReadBinding(channelSource.Server, channel, binding.ReadPreference)) { var operation = CreateOperation(channel.ConnectionDescription.ServerVersion); var result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false); return(CreateCursors(channelSource, operation.Command, result)); } }
/// <inheritdoc/> public async Task <WriteConcernResult> ExecuteAsync(RetryableWriteContext context, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) { if (_writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(await emulator.ExecuteAsync(context, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteProtocolAsync(context.Channel, cancellationToken).ConfigureAwait(false)); } } }
public async Task <BulkWriteOperationResult> ExecuteAsync(IChannelHandle channel, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) { if (SupportedFeatures.AreWriteCommandsSupported(channel.ConnectionDescription.ServerVersion)) { return(await ExecuteBatchesAsync(channel, cancellationToken).ConfigureAwait(false)); } else { var emulator = CreateEmulator(); return(await emulator.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false)); } } }
// public methods public BulkWriteOperationResult Execute(IChannelHandle channel, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) { if (SupportedFeatures.AreWriteCommandsSupported(channel.ConnectionDescription.ServerVersion)) { return(ExecuteBatches(channel, cancellationToken)); } else { var emulator = CreateEmulator(); return(emulator.Execute(channel, cancellationToken)); } } }
/// <inheritdoc/> public async Task <WriteConcernResult> ExecuteAsync(RetryableWriteContext context, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) { if (Feature.WriteCommands.IsSupported(context.Channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(await emulator.ExecuteAsync(context, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteProtocolAsync(context.Channel, cancellationToken).ConfigureAwait(false)); } } }
/// <inheritdoc/> public IAsyncCursor <TDocument> Execute(RetryableReadContext context, CancellationToken cancellationToken) { Ensure.IsNotNull(context, nameof(context)); using (EventContext.BeginOperation()) using (EventContext.BeginFind(_batchSize, _limit)) { var readPreference = context.Binding.ReadPreference; var serverDescription = context.ChannelSource.ServerDescription; var wrappedQuery = CreateWrappedQuery(serverDescription.Type, readPreference, out var secondaryOk); var batch = ExecuteProtocol(context.Channel, wrappedQuery, secondaryOk, cancellationToken); return(CreateCursor(context.ChannelSource, context.Channel, wrappedQuery, batch)); } }
// methods /// <inheritdoc/> public IAsyncCursor <TResult> Execute(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); EnsureIsReadOnlyPipeline(); using (EventContext.BeginOperation()) using (var channelSource = binding.GetReadChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) using (var channelBinding = new ChannelReadBinding(channelSource.Server, channel, binding.ReadPreference)) { var operation = CreateOperation(channel); var result = operation.Execute(channelBinding, cancellationToken); return(CreateCursor(channelSource, channel, operation.Command, result)); } }
/// <inheritdoc/> public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork())) { foreach (var createIndexRequest in _requests) { var operation = CreateOperation(channel.ConnectionDescription.ServerVersion, createIndexRequest); await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false); } return(new BsonDocument("ok", 1)); } }
/// <inheritdoc/> public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); EnsureIsReadOnlyPipeline(); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) using (var channelBinding = new ChannelReadBinding(channelSource.Server, channel, binding.ReadPreference, binding.Session.Fork())) { var operation = CreateOperation(channel, channelBinding); var result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false); return(CreateCursor(channelSource, channel, operation.Command, result)); } }
// public methods /// <inheritdoc/> public BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork())) { foreach (var createIndexRequest in _requests) { var operation = CreateOperation(channel.ConnectionDescription.ServerVersion, createIndexRequest); operation.Execute(channelBinding, cancellationToken); } return(new BsonDocument("ok", 1)); } }
/// <inheritdoc/> public WriteConcernResult Execute(RetryableWriteContext context, CancellationToken cancellationToken) { Ensure.IsNotNull(context, nameof(context)); using (EventContext.BeginOperation()) { if (Feature.WriteCommands.IsSupported(context.Channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(emulator.Execute(context, cancellationToken)); } else { return(ExecuteProtocol(context.Channel, cancellationToken)); } } }
// methods /// <inheritdoc/> public async Task <IAsyncCursor <BsonDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { if (channelSource.ServerDescription.Version >= __versionSupportingListCollectionsCommand) { return(await ExecuteUsingCommandAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteUsingQueryAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false)); } } }
private void KillCursor(long cursorId, CancellationToken cancellationToken) { try { using (EventContext.BeginOperation(_operationId)) using (EventContext.BeginKillCursors(_collectionNamespace)) using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10))) using (var channel = _channelSource.GetChannel(cancellationTokenSource.Token)) { ExecuteKillCursorsProtocol(channel, cancellationToken); } } catch { // ignore exceptions } }
private void KillCursors(CancellationToken cancellationToken) { using (EventContext.BeginOperation(_operationId)) using (EventContext.BeginKillCursors(_collectionNamespace)) using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10))) using (var channel = _channelSource.GetChannel(cancellationTokenSource.Token)) { if (Feature.KillCursorsCommand.IsSupported(channel.ConnectionDescription.ServerVersion)) { ExecuteKillCursorsCommand(channel, cancellationToken); } else { ExecuteKillCursorsProtocol(channel, cancellationToken); } } }
private async Task KillCursorsAsync(CancellationToken cancellationToken) { using (EventContext.BeginOperation(_operationId)) using (EventContext.BeginKillCursors(_collectionNamespace)) using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10))) using (var channel = await _channelSource.GetChannelAsync(cancellationTokenSource.Token).ConfigureAwait(false)) { if (Feature.KillCursorsCommand.IsSupported(channel.ConnectionDescription.ServerVersion)) { await ExecuteKillCursorsCommandAsync(channel, cancellationToken).ConfigureAwait(false); } else { await ExecuteKillCursorsProtocolAsync(channel, cancellationToken).ConfigureAwait(false); } } }
/// <inheritdoc/> public async Task <IAsyncCursor <TDocument> > ExecuteAsync(RetryableReadContext context, CancellationToken cancellationToken) { Ensure.IsNotNull(context, nameof(context)); using (EventContext.BeginOperation()) using (EventContext.BeginFind(_batchSize, _limit)) { var readPreference = context.Binding.ReadPreference; var serverDescription = context.ChannelSource.ServerDescription; var wrappedQuery = CreateWrappedQuery(serverDescription.Type, readPreference); var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary; var batch = await ExecuteProtocolAsync(context.Channel, wrappedQuery, slaveOk, cancellationToken).ConfigureAwait(false); return(CreateCursor(context.ChannelSource, wrappedQuery, batch)); } }
private async Task KillCursorAsync(long cursorId, CancellationToken cancellationToken) { try { using (EventContext.BeginOperation(_operationId)) using (EventContext.BeginKillCursors(_collectionNamespace)) using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10))) using (var channel = await _channelSource.GetChannelAsync(cancellationTokenSource.Token).ConfigureAwait(false)) { await ExecuteKillCursorsProtocolAsync(channel, cancellationToken).ConfigureAwait(false); } } catch { // ignore exceptions } }
/// <inheritdoc/> public async Task <IReadOnlyList <IAsyncCursor <TDocument> > > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { var command = CreateCommand(); var operation = new ReadCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); var result = await operation.ExecuteAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false); var cursors = new List <AsyncCursor <TDocument> >(); foreach (var cursorDocument in result["cursors"].AsBsonArray.Select(v => v["cursor"].AsBsonDocument)) { var cursorId = cursorDocument["id"].ToInt64(); var firstBatch = cursorDocument["firstBatch"].AsBsonArray.Select(v => { var bsonDocument = (BsonDocument)v; using (var reader = new BsonDocumentReader(bsonDocument)) { var context = BsonDeserializationContext.CreateRoot(reader); var document = _serializer.Deserialize(context); return(document); } }) .ToList(); var cursor = new AsyncCursor <TDocument>( channelSource.Fork(), _collectionNamespace, command, firstBatch, cursorId, _batchSize ?? 0, 0, // limit _serializer, _messageEncoderSettings); cursors.Add(cursor); } return(cursors); } }
// methods /// <inheritdoc/> public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); EnsureIsReadOnlyPipeline(); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { var command = CreateCommand(channelSource.ServerDescription.Version); var serializer = new AggregateResultDeserializer(_resultSerializer); var operation = new ReadCommandOperation <AggregateResult>(CollectionNamespace.DatabaseNamespace, command, serializer, MessageEncoderSettings); var result = await operation.ExecuteAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false); return(CreateCursor(channelSource, command, result)); } }
/// <inheritdoc/> public async Task <WriteConcernResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) { if (SupportedFeatures.AreWriteCommandsSupported(channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(await emulator.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false)); } else { return(await ExecuteProtocolAsync(channel, cancellationToken).ConfigureAwait(false)); } } }
// public methods /// <inheritdoc/> public WriteConcernResult Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { if (SupportedFeatures.AreWriteCommandsSupported(channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); return(emulator.Execute(channel, cancellationToken)); } else { return(ExecuteProtocol(channel, cancellationToken)); } } }
/// <inheritdoc/> public IAsyncCursor <TDocument> Execute(IReadBinding binding, CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = binding.GetReadChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) using (var channelBinding = new ChannelReadBinding(channelSource.Server, channel, binding.ReadPreference, binding.Session.Fork())) { var readPreference = binding.ReadPreference; using (EventContext.BeginFind(_batchSize, _limit)) { var operation = CreateOperation(channel, channelBinding); var commandResult = operation.Execute(channelBinding, cancellationToken); return(CreateCursor(channelSource, commandResult)); } } }
// public methods /// <inheritdoc/> public IEnumerable <WriteConcernResult> Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var context = RetryableWriteContext.Create(binding, false, cancellationToken)) { if (_writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); var result = emulator.Execute(context, cancellationToken); return(new[] { result }); } else { return(InsertBatches(context.Channel, cancellationToken)); } } }
public BinaryConnection_CommandEventTests() { _capturedEvents = new EventCapturer() .Capture <CommandStartedEvent>() .Capture <CommandSucceededEvent>() .Capture <CommandFailedEvent>(); _mockStreamFactory = new Mock <IStreamFactory>(); _endPoint = new DnsEndPoint("localhost", 27017); var serverId = new ServerId(new ClusterId(), _endPoint); _mockConnectionInitializer = new Mock <IConnectionInitializer>(); _mockConnectionInitializer.Setup(i => i.SendHelloAsync(It.IsAny <IConnection>(), CancellationToken.None)) .Returns(() => Task.FromResult(new ConnectionDescription( new ConnectionId(serverId), new HelloResult(new BsonDocument { { "maxWireVersion", WireVersion.Server36 } })))); _mockConnectionInitializer.Setup(i => i.AuthenticateAsync(It.IsAny <IConnection>(), It.IsAny <ConnectionDescription>(), CancellationToken.None)) .Returns(() => Task.FromResult(new ConnectionDescription( new ConnectionId(serverId), new HelloResult(new BsonDocument { { "maxWireVersion", WireVersion.Server36 } })))); _subject = new BinaryConnection( serverId: serverId, endPoint: _endPoint, settings: new ConnectionSettings(), streamFactory: _mockStreamFactory.Object, connectionInitializer: _mockConnectionInitializer.Object, eventSubscriber: _capturedEvents); _stream = new BlockingMemoryStream(); _mockStreamFactory.Setup(f => f.CreateStreamAsync(_endPoint, CancellationToken.None)) .Returns(Task.FromResult <Stream>(_stream)); _subject.OpenAsync(CancellationToken.None).Wait(); _capturedEvents.Clear(); _operationIdDisposer = EventContext.BeginOperation(); }
/// <inheritdoc/> public IAsyncCursor <TDocument> Execute(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = binding.GetReadChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { var readPreference = binding.ReadPreference; var serverDescription = channelSource.ServerDescription; var wrappedQuery = CreateWrappedQuery(serverDescription.Type, readPreference); var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary; using (EventContext.BeginFind(_batchSize, _limit)) { var batch = ExecuteProtocol(channel, wrappedQuery, slaveOk, cancellationToken); return(CreateCursor(channelSource, wrappedQuery, batch)); } } }