// constructors
public GridFSSeekableDownloadStream(
GridFSBucket bucket,
IReadBinding binding,
GridFSFilesCollectionDocument filesCollectionDocument)
: base(bucket, binding, filesCollectionDocument)
{
}
// constructors
public GridFSSeekableDownloadStream(
GridFSBucket bucket,
IReadBinding binding,
GridFSFileInfo fileInfo)
: base(bucket, binding, fileInfo)
{
}
// constructors
protected GridFSDownloadStreamBase(
GridFSBucket bucket,
IReadBinding binding,
GridFSFileInfo fileInfo)
{
_bucket = bucket;
_binding = binding;
_fileInfo = fileInfo;
}
// constructors
protected GridFSDownloadStreamBase(
GridFSBucket bucket,
IReadBinding binding,
GridFSFilesCollectionDocument filesCollectionDocument)
{
_bucket = bucket;
_binding = binding;
_filesCollectionDocument = filesCollectionDocument;
}
/// <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));
}
}
// 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, binding.Session.Fork()))
{
var operation = CreateOperation(channel, channelBinding);
var result = operation.Execute(channelBinding, cancellationToken);
return(CreateCursor(channelSource, channel, operation.Command, result));
}
}
public static async Task <TResult> ExecuteAsync <TResult>(
this IWireProtocol <TResult> protocol,
IReadBinding binding,
TimeSpan timeout = default(TimeSpan),
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(protocol, "protocol");
var slidingTimeout = new SlidingTimeout(timeout);
using (var connectionSource = await binding.GetReadConnectionSourceAsync(slidingTimeout, cancellationToken).ConfigureAwait(false))
using (var connection = await connectionSource.GetConnectionAsync(slidingTimeout, cancellationToken).ConfigureAwait(false))
{
return(await protocol.ExecuteAsync(connection, slidingTimeout, cancellationToken).ConfigureAwait(false));
}
}
// 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));
}
}
}
public async Task <Cursor <BsonDocument> > ExecuteAsync(IReadBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, "binding");
EnsureIsReadOnlyPipeline();
var slidingTimeout = new SlidingTimeout(timeout);
using (var connectionSource = await binding.GetReadConnectionSourceAsync(slidingTimeout, cancellationToken))
{
var command = CreateCommand();
var operation = new ReadCommandOperation(CollectionNamespace.DatabaseNamespace, command, MessageEncoderSettings);
var result = await operation.ExecuteAsync(connectionSource, binding.ReadPreference, slidingTimeout, cancellationToken);
return(CreateCursor(connectionSource, command, result, timeout, cancellationToken));
}
}
/// <summary>
/// Creates and initializes a retryable read operation context.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="retryRequested">if set to <c>true</c> [retry requested].</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A retryable read context.</returns>
public static async Task <RetryableReadContext> CreateAsync(IReadBinding binding, bool retryRequested, CancellationToken cancellationToken)
{
var context = new RetryableReadContext(binding, retryRequested);
try
{
await context.InitializeAsync(cancellationToken).ConfigureAwait(false);
return(context);
}
catch
{
context.Dispose();
throw;
}
}
private ChangeStreamCursor <BsonDocument> CreateSubject(
IAsyncCursor <RawBsonDocument> cursor = null,
IBsonSerializer <BsonDocument> documentSerializer = null,
IReadBinding binding = null,
IChangeStreamOperation <BsonDocument> changeStreamOperation = null,
BsonDocument postBatchResumeToken = null,
BsonDocument startAfter = null,
BsonDocument resumeAfter = null,
BsonTimestamp startAtOperationTime = null,
BsonTimestamp initialOperationTime = null)
{
cursor = cursor ?? new Mock <IAsyncCursor <RawBsonDocument> >().Object;
documentSerializer = documentSerializer ?? new Mock <IBsonSerializer <BsonDocument> >().Object;
binding = binding ?? new Mock <IReadBinding>().Object;
changeStreamOperation = changeStreamOperation ?? Mock.Of <IChangeStreamOperation <BsonDocument> >();
return(new ChangeStreamCursor <BsonDocument>(cursor, documentSerializer, binding, changeStreamOperation, postBatchResumeToken, initialOperationTime, startAfter, resumeAfter, startAtOperationTime, __dummyMaxWireVersion));
}
// 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));
}
}
private BsonDocument GetCollectionStats(IReadBinding binding, bool async)
{
var command = new BsonDocument
{
{ "collStats", _collectionNamespace.CollectionName }
};
var operation = new ReadCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
if (async)
{
return(operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult());
}
else
{
return(operation.Execute(binding, CancellationToken.None));
}
}
/// <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));
}
var cursor = await ResumeAsync(bindingHandle, cancellationToken).ConfigureAwait(false);
if (_startAtOperationTime == null && _resumeAfter == null)
{
_startAtOperationTime = binding.Session.OperationTime;
}
return(new ChangeStreamCursor <TResult>(cursor, _resultSerializer, bindingHandle.Fork(), this));
}
/// <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 IEnumerable <BsonDocument> Execute(IReadBinding binding, CancellationToken cancellationToken)
{
var filter = _username == null ? (BsonValue)1 : _username;
var command = new BsonDocument("usersInfo", filter);
var operation = new ReadCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var result = operation.Execute(binding, cancellationToken);
BsonValue users;
if (result.TryGetValue("users", out users) && users.IsBsonArray)
{
return(users.AsBsonArray.Select(v => v.AsBsonDocument));
}
else
{
return(Enumerable.Empty <BsonDocument>());
}
}
// 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));
}
}
public Task <TResult> ExecuteReadOperationAsync <TResult>(IReadBinding binding, IReadOperation <TResult> operation, CancellationToken cancellationToken)
{
_calls.Enqueue(new ReadCall <TResult>
{
Binding = binding,
Operation = operation,
CancellationToken = cancellationToken
});
var result = Task.FromResult <TResult>(default(TResult));
if (_results.Count > 0)
{
result = (Task <TResult>)_results.Dequeue();
}
return(result);
}
// methods
public async Task <IEnumerable <BsonDocument> > ExecuteAsync(IReadBinding binding, TimeSpan timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
var slidingTimeout = new SlidingTimeout(timeout);
using (var connectionSource = await binding.GetReadConnectionSourceAsync(slidingTimeout, cancellationToken).ConfigureAwait(false))
{
if (connectionSource.ServerDescription.Version >= __serverVersionSupportingListIndexesCommand)
{
return(await ExecuteUsingCommandAsync(connectionSource, binding.ReadPreference, slidingTimeout, cancellationToken).ConfigureAwait(false));
}
else
{
return(await ExecuteUsingQueryAsync(connectionSource, binding.ReadPreference, slidingTimeout, cancellationToken).ConfigureAwait(false));
}
}
}
/// <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));
}
}
}
/// <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 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))
{
var readPreference = binding.ReadPreference;
var slaveOk = readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary;
using (EventContext.BeginFind(_batchSize, _limit))
{
var operation = CreateOperation(channel.ConnectionDescription.ServerVersion, channelSource.ServerDescription.Type);
var commandResult = operation.Execute(binding, cancellationToken);
return(CreateCursor(channelSource, commandResult, slaveOk));
}
}
}
/// <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));
}
}
}
// methods
public IEnumerable <BsonDocument> Execute(IReadBinding binding, CancellationToken cancellationToken)
{
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()))
{
IReadOperation <IEnumerable <BsonDocument> > operation;
if (Feature.UserManagementCommands.IsSupported(channel.ConnectionDescription.ServerVersion))
{
operation = new FindUsersUsingUserManagementCommandsOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
else
{
operation = new FindUsersUsingSystemUsersCollectionOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
return(operation.Execute(channelBinding, cancellationToken));
}
}
// constructors
public GridFSForwardOnlyDownloadStream(
GridFSBucket bucket,
IReadBinding binding,
GridFSFilesCollectionDocument filesCollectionDocument,
bool checkMD5)
: base(bucket, binding, filesCollectionDocument)
{
_checkMD5 = checkMD5;
if (_checkMD5)
{
_md5 = MD5.Create();
}
_lastChunkNumber = (int)((filesCollectionDocument.Length - 1) / filesCollectionDocument.ChunkSizeBytes);
_lastChunkSize = (int)(filesCollectionDocument.Length % filesCollectionDocument.ChunkSizeBytes);
if (_lastChunkSize == 0)
{
_lastChunkSize = filesCollectionDocument.ChunkSizeBytes;
}
}
public async Task <TResult> ExecuteReadOperationAsync <TResult>(IReadBinding binding, IReadOperation <TResult> operation, TimeSpan timeout, CancellationToken cancellationToken)
{
using (var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
cancellationTokenSource.CancelAfter(timeout);
try
{
return(await operation.ExecuteAsync(binding, cancellationTokenSource.Token).ConfigureAwait(false));
}
catch (OperationCanceledException ex)
{
if (cancellationTokenSource.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
{
var msg = string.Format("Operation timed out after {0}.", timeout);
throw new TimeoutException(msg, ex);
}
throw;
}
}
}
/// <summary>
/// Creates and initializes a retryable read operation context.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="retryRequested">if set to <c>true</c> [retry requested].</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A retryable read context.</returns>
public static async Task <RetryableReadContext> CreateAsync(IReadBinding binding, bool retryRequested, CancellationToken cancellationToken)
{
var context = new RetryableReadContext(binding, retryRequested);
try
{
await context.InitializeAsync(cancellationToken).ConfigureAwait(false);
ChannelPinningHelper.PinChannellIfRequired(
context.ChannelSource,
context.Channel,
context.Binding.Session);
return(context);
}
catch
{
context.Dispose();
throw;
}
}
// public methods
/// <inheritdoc />
public IAsyncCursor <TResult> Execute(IReadBinding binding, CancellationToken cancellationToken)
{
var bindingHandle = binding as IReadBindingHandle;
if (bindingHandle == null)
{
throw new ArgumentException("The binding value passed to ChangeStreamOperation.Execute must implement IReadBindingHandle.", nameof(binding));
}
IAsyncCursor <RawBsonDocument> cursor;
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()))
{
cursor = ExecuteAggregateOperation(channelBinding, resuming: false, cancellationToken);
SaveInitialOperationTimeIfRequired(channel, channelBinding, cursor);
}
return(new ChangeStreamCursor <TResult>(cursor, _resultSerializer, bindingHandle.Fork(), this));
}
// public static methods
/// <summary>
/// Creates and initializes a retryable read operation context.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="retryRequested">if set to <c>true</c> [retry requested].</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A retryable read context.</returns>
public static RetryableReadContext Create(IReadBinding binding, bool retryRequested, CancellationToken cancellationToken)
{
var context = new RetryableReadContext(binding, retryRequested);
try
{
context.Initialize(cancellationToken);
ChannelPinningHelper.PinChannellIfRequired(
context.ChannelSource,
context.Channel,
context.Binding.Session);
return(context);
}
catch
{
context.Dispose();
throw;
}
}
// constructors
public GridFSForwardOnlyDownloadStream(
GridFSBucket bucket,
IReadBinding binding,
GridFSFileInfo fileInfo,
bool checkMD5)
: base(bucket, binding, fileInfo)
{
_checkMD5 = checkMD5;
if (_checkMD5)
{
_md5 = MD5.Create();
}
_lastChunkNumber = (int)((fileInfo.Length - 1) / fileInfo.ChunkSizeBytes);
_lastChunkSize = (int)(fileInfo.Length % fileInfo.ChunkSizeBytes);
if (_lastChunkSize == 0)
{
_lastChunkSize = fileInfo.ChunkSizeBytes;
}
}
/// <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));
}
}
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ChangeStreamCursor{TDocument}" /> class.
/// </summary>
/// <param name="cursor">The cursor.</param>
/// <param name="documentSerializer">The document serializer.</param>
/// <param name="binding">The binding.</param>
/// <param name="changeStreamOperation">The change stream operation.</param>
/// <param name="aggregatePostBatchResumeToken">The post batch resume token from an aggregate command.</param>
/// <param name="initialOperationTime">The initial operation time.</param>
/// <param name="initialStartAfter">The start after value.</param>
/// <param name="initialResumeAfter">The resume after value.</param>
/// <param name="initialStartAtOperationTime">The start at operation time value.</param>
public ChangeStreamCursor(
IAsyncCursor <RawBsonDocument> cursor,
IBsonSerializer <TDocument> documentSerializer,
IReadBinding binding,
IChangeStreamOperation <TDocument> changeStreamOperation,
BsonDocument aggregatePostBatchResumeToken,
BsonTimestamp initialOperationTime,
BsonDocument initialStartAfter,
BsonDocument initialResumeAfter,
BsonTimestamp initialStartAtOperationTime)
{
_cursor = Ensure.IsNotNull(cursor, nameof(cursor));
_documentSerializer = Ensure.IsNotNull(documentSerializer, nameof(documentSerializer));
_binding = Ensure.IsNotNull(binding, nameof(binding));
_changeStreamOperation = Ensure.IsNotNull(changeStreamOperation, nameof(changeStreamOperation));
_postBatchResumeToken = aggregatePostBatchResumeToken;
_initialOperationTime = initialOperationTime;
_initialStartAfter = initialStartAfter;
_initialResumeAfter = initialResumeAfter;
_initialStartAtOperationTime = initialStartAtOperationTime;
}
// public methods
/// <inheritdoc/>
public IAsyncCursor <BsonDocument> Execute(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
using (EventContext.BeginOperation())
using (var channelSource = binding.GetReadChannelSource(cancellationToken))
{
var operation = CreateOperation();
try
{
var result = operation.Execute(channelSource, binding.ReadPreference, binding.Session, cancellationToken);
return(CreateCursor(channelSource, result, operation.Command));
}
catch (MongoCommandException ex)
{
if (IsCollectionNotFoundException(ex))
{
return(new SingleBatchAsyncCursor <BsonDocument>(new List <BsonDocument>()));
}
throw;
}
}
}
public TResult ExecuteReadOperation <TResult>(IReadBinding binding, IReadOperation <TResult> operation, CancellationToken cancellationToken)
{
_calls.Enqueue(new ReadCall <TResult>
{
Binding = binding,
Operation = operation,
CancellationToken = cancellationToken
});
if (_results.Count > 0)
{
var result = _results.Dequeue();
var exception = result as Exception;
if (exception != null)
{
throw exception;
}
return((TResult)result);
}
return(default(TResult));
}
/// <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));
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ReadBindingHandle"/> class.
/// </summary>
/// <param name="readBinding">The read binding.</param>
public ReadBindingHandle(IReadBinding readBinding)
: this(new ReferenceCounted<IReadBinding>(readBinding))
{
}
public FakeGridFSDownloadStream(GridFSBucket bucket, IReadBinding binding, GridFSFileInfo fileInfo)
: base(bucket, binding, fileInfo)
{
}
// constructors
public SplitReadWriteBinding(IReadBinding readBinding, IWriteBinding writeBinding)
{
_readBinding = Ensure.IsNotNull(readBinding, "readBinding");
_writeBinding = Ensure.IsNotNull(writeBinding, "writeBinding");
}
private static Task<Cursor<BsonDocument>> Query(IReadBinding binding, BsonDocument query)
{
var queryOp = new FindOperation<BsonDocument>(__collection, query, BsonDocumentSerializer.Instance, __messageEncoderSettings)
{
Limit = 1
};
return queryOp.ExecuteAsync(binding);
}
private List<BsonDocument> ReadAllFromCollection(IReadBinding binding)
{
var operation = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var cursor = ExecuteOperation(operation, binding, false);
return ReadCursorToEnd(cursor);
}
private BsonDocument GetCollectionStats(IReadBinding binding, bool async)
{
var command = new BsonDocument
{
{ "collStats", _collectionNamespace.CollectionName }
};
var operation = new ReadCommandOperation<BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
if (async)
{
return operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
return operation.Execute(binding, CancellationToken.None);
}
}
private BsonDocument GetCollectionInfo(IReadBinding binding, string collectionName)
{
var commandOperation = new ReadCommandOperation<BsonDocument>(
_collectionNamespace.DatabaseNamespace,
new BsonDocument("listCollections", 1),
BsonDocumentSerializer.Instance,
new MessageEncoderSettings());
var commandResult = commandOperation.Execute(binding, CancellationToken.None);
return commandResult["cursor"]["firstBatch"].AsBsonArray.Where(c => c["name"] == _collectionNamespace.CollectionName).Single().AsBsonDocument;
}
public Task<BsonDocument> GetCollectionStatsAsync(IReadBinding binding)
{
var command = new BsonDocument
{
{ "collStats", _collectionNamespace.CollectionName }
};
var operation = new ReadCommandOperation<BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
return operation.ExecuteAsync(binding, CancellationToken.None);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="SplitReadWriteBinding"/> class.
/// </summary>
/// <param name="readBinding">The read binding.</param>
/// <param name="writeBinding">The write binding.</param>
public SplitReadWriteBinding(IReadBinding readBinding, IWriteBinding writeBinding)
{
_readBinding = Ensure.IsNotNull(readBinding, nameof(readBinding));
_writeBinding = Ensure.IsNotNull(writeBinding, nameof(writeBinding));
}
public void Setup()
{
_readBinding = Substitute.For<IReadBinding>();
_writeBinding = Substitute.For<IWriteBinding>();
}
private static Task<Cursor<BsonDocument>> Query(IReadBinding binding, BsonDocument query)
{
var queryOp = new FindOperation<BsonDocument>(
_database,
_collection,
BsonDocumentSerializer.Instance,
query).WithLimit(1);
return queryOp.ExecuteAsync(binding);
}
private async Task<IAsyncCursor<BsonDocument>> Query(IReadBinding binding, BsonDocument filter)
{
var findOp = new FindOperation<BsonDocument>(_collection, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter,
Limit = -1
};
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token))
{
return await findOp.ExecuteAsync(binding, linked.Token);
}
}
private BsonDocument GetViewInfo(IReadBinding binding, string viewName)
{
var listCollectionsOperation = new ListCollectionsOperation(_collectionNamespace.DatabaseNamespace, _messageEncoderSettings)
{
Filter = new BsonDocument("name", viewName)
};
return listCollectionsOperation.Execute(binding, CancellationToken.None).Single();
}
