private async Task InitializeAsync(CancellationToken cancellationToken)
{
_channelSource = await _binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false);
try
{
_channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false);
}
catch (Exception ex) when(RetryableReadOperationExecutor.ShouldConnectionAcquireBeRetried(this, ex))
{
ReplaceChannelSource(await _binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false));
ReplaceChannel(await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false));
}
}
public async Task <IAsyncCursor <TDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false))
{
var readPreference = binding.ReadPreference;
var serverDescription = channelSource.ServerDescription;
var wrappedQuery = CreateWrappedQuery(serverDescription.Type, readPreference);
var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary;
var batch = await ExecuteProtocolAsync(channel, wrappedQuery, slaveOk, cancellationToken).ConfigureAwait(false);
return(new AsyncCursor <TDocument>(
channelSource.Fork(),
_collectionNamespace,
wrappedQuery,
batch.Documents,
batch.CursorId,
_batchSize ?? 0,
Math.Abs(_limit ?? 0),
_resultSerializer,
_messageEncoderSettings));
}
}
/// <inheritdoc />
public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
var bindingHandle = binding as IReadBindingHandle;
if (bindingHandle == null)
{
throw new ArgumentException("The binding value passed to ChangeStreamOperation.ExecuteAsync must implement IReadBindingHandle.", nameof(binding));
}
IAsyncCursor <RawBsonDocument> cursor;
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()))
{
cursor = await ResumeAsync(channelBinding, cancellationToken).ConfigureAwait(false);
if (_startAtOperationTime == null && _resumeAfter == null)
{
var maxWireVersion = channel.ConnectionDescription.IsMasterResult.MaxWireVersion;
if (maxWireVersion >= 7)
{
_startAtOperationTime = binding.Session.OperationTime;
}
}
}
return(new ChangeStreamCursor <TResult>(cursor, _resultSerializer, bindingHandle.Fork(), this));
}
// methods
public async Task <TCommandResult> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
return(await ExecuteProtocolAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <BsonDocument> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
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();
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <TCommandResult> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
using (EventContext.BeginOperation())
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
return(await ExecuteProtocolAsync(channelSource, binding.Session, binding.ReadPreference, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <TResult> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
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);
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc />
public virtual async Task <BsonDocument> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false))
using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork()))
{
var operation = CreateOperation();
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <long> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
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 document = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
return(document["n"].ToInt64());
}
}
/// <inheritdoc/>
public async Task <IAsyncCursor <TValue> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
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 values = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
return(new SingleBatchAsyncCursor <TValue>(values));
}
}
/// <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))
{
var operation = CreateOperation();
var result = await operation.ExecuteAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false);
return(CreateCursor(channelSource, operation.Command, result));
}
}
/// <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))
using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false))
using (var channelBinding = new ChannelReadBinding(channelSource.Server, channel, binding.ReadPreference))
{
var operation = CreateOperation(channel);
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
private async Task InitializeAsync(CancellationToken cancellationToken)
{
_channelSource = await _binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false);
var serverDescription = _channelSource.ServerDescription;
try
{
_channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false);
}
catch (MongoConnectionPoolPausedException)
{
if (RetryableReadOperationExecutor.ShouldConnectionAcquireBeRetried(this, serverDescription))
{
ReplaceChannelSource(await _binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false));
ReplaceChannel(await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false));
}
else
{
throw;
}
}
}
/// <inheritdoc/>
public async Task <long> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
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();
var cursor = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
var result = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false);
return(ExtractCountFromResult(result));
}
}
/// <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, binding.Session.Fork()))
{
var operation = CreateOperation(channel, channelBinding);
var result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
return(CreateCursors(channelSource, operation.Command, result));
}
}
/// <inheritdoc />
public virtual async Task <BsonDocument> ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false))
using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork()))
{
var operation = CreateOperation();
var result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
WriteConcernErrorHelper.ThrowIfHasWriteConcernError(channel.ConnectionDescription.ConnectionId, result);
return(result);
}
}
// methods
/// <inheritdoc/>
public async Task <IAsyncCursor <BsonDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
if (channelSource.ServerDescription.Version >= __serverVersionSupportingListIndexesCommand)
{
return(await ExecuteUsingCommandAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false));
}
else
{
return(await ExecuteUsingQueryAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false));
}
}
}
// methods
public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
EnsureIsReadOnlyPipeline();
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 <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
public async Task <IEnumerable <BsonDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
IReadOperation <IEnumerable <BsonDocument> > operation;
if (channelSource.ServerDescription.Version >= __serverVersionSupportingUserManagementCommands)
{
operation = new FindUsersUsingUserManagementCommandsOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
else
{
operation = new FindUsersUsingSystemUsersCollectionOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
return(await operation.ExecuteAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <IAsyncCursor <TDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken = default(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))
{
var readPreference = binding.ReadPreference;
var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary;
CursorBatch <TDocument> batch;
using (EventContext.BeginFind(_batchSize, _limit))
{
batch = await ExecuteProtocolAsync(channel, channelSource.ServerDescription, readPreference, slaveOk, cancellationToken).ConfigureAwait(false);
}
return(CreateCursor(channelSource, batch, slaveOk));
}
}
/// <inheritdoc/>
public async Task <IAsyncCursor <TDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken = default(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, binding.Session.Fork()))
{
var readPreference = binding.ReadPreference;
var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary;
using (EventContext.BeginFind(_batchSize, _limit))
{
var operation = CreateOperation(channel, channelBinding);
var commandResult = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
return(CreateCursor(channelSource, commandResult, slaveOk));
}
}
}
/// <inheritdoc/>
public async Task <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))
{
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 = await ExecuteProtocolAsync(channel, wrappedQuery, slaveOk, cancellationToken).ConfigureAwait(false);
return(CreateCursor(channelSource, wrappedQuery, batch));
}
}
}
/// <inheritdoc />
public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
var bindingHandle = binding as IReadBindingHandle;
if (bindingHandle == null)
{
throw new ArgumentException("The binding value passed to ChangeStreamOperation.ExecuteAsync must implement IReadBindingHandle.", nameof(binding));
}
IAsyncCursor <RawBsonDocument> cursor;
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()))
{
cursor = await ExecuteAggregateOperationAsync(channelBinding, resuming : false, cancellationToken).ConfigureAwait(false);
SaveInitialOperationTimeIfRequired(channel, channelBinding, cursor);
}
return(new ChangeStreamCursor <TResult>(cursor, _resultSerializer, bindingHandle.Fork(), this));
}
/// <inheritdoc />
public async Task <IChangeStreamCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
var bindingHandle = binding as IReadBindingHandle;
if (bindingHandle == null)
{
throw new ArgumentException("The binding value passed to ChangeStreamOperation.ExecuteAsync must implement IReadBindingHandle.", nameof(binding));
}
IAsyncCursor <RawBsonDocument> cursor;
ICursorBatchInfo cursorBatchInfo;
BsonTimestamp initialOperationTime;
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()))
{
cursor = await ExecuteAggregateOperationAsync(channelBinding, cancellationToken).ConfigureAwait(false);
cursorBatchInfo = (ICursorBatchInfo)cursor;
initialOperationTime = GetInitialOperationTimeIfRequired(channel, channelBinding, cursorBatchInfo);
}
var postBatchResumeToken = GetInitialPostBatchResumeTokenIfRequired(cursorBatchInfo);
return(new ChangeStreamCursor <TResult>(
cursor,
_resultSerializer,
bindingHandle.Fork(),
this,
postBatchResumeToken,
initialOperationTime,
_startAfter,
_resumeAfter,
_startAtOperationTime));
}
/// <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))
{
var operation = CreateOperation();
try
{
var result = await operation.ExecuteAsync(channelSource, binding.ReadPreference, binding.Session, cancellationToken).ConfigureAwait(false);
return(CreateCursor(channelSource, result, operation.Command));
}
catch (MongoCommandException ex)
{
if (IsCollectionNotFoundException(ex))
{
return(new SingleBatchAsyncCursor <BsonDocument>(new List <BsonDocument>()));
}
throw;
}
}
}
// static methods
public static IChannelSourceHandle GetReadChannelSource(this IReadBinding binding, CancellationToken cancellationToken = default(CancellationToken))
{
return(binding.GetReadChannelSourceAsync(cancellationToken).GetAwaiter().GetResult());
}
private async Task InitializeAsync(CancellationToken cancellationToken)
{
_channelSource = await _binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false);
_channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false);
}
// methods
/// <inheritdoc/>
public Task <IChannelSourceHandle> GetReadChannelSourceAsync(CancellationToken cancellationToken)
{
ThrowIfDisposed();
return(_readBinding.GetReadChannelSourceAsync(cancellationToken));
}
