private IReadOnlyList <IAsyncCursor <TDocument> > CreateCursors(IChannelSourceHandle channelSource, BsonDocument command, BsonDocument result)
{
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);
}
private bool UserExists(IChannelSourceHandle channelSource, ICoreSessionHandle session, CancellationToken cancellationToken)
{
try
{
var command = new BsonDocument("usersInfo", _username);
var operation = new ReadCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var result = operation.Execute(channelSource, ReadPreference.Primary, session, cancellationToken);
BsonValue users;
if (result.TryGetValue("users", out users) && users.IsBsonArray && users.AsBsonArray.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (MongoCommandException ex)
{
if (ex.Code == 13)
{
return(false);
}
throw;
}
}
internal static bool PinChannelSourceAndChannelIfRequired(
IChannelSourceHandle channelSource,
IChannelHandle channel,
ICoreSessionHandle session,
out IChannelSourceHandle pinnedChannelSource,
out IChannelHandle pinnedChannel)
{
if (IsInLoadBalancedMode(channel.ConnectionDescription))
{
var server = channelSource.Server;
pinnedChannelSource = new ChannelSourceHandle(
new ChannelChannelSource(
server,
channel.Fork(),
session.Fork()));
if (session.IsInTransaction && !IsChannelPinned(session.CurrentTransaction))
{
session.CurrentTransaction.PinChannel(channel.Fork());
session.CurrentTransaction.PinnedServer = server;
}
pinnedChannel = channel.Fork();
return(true);
}
pinnedChannelSource = null;
pinnedChannel = null;
return(false);
}
private async Task <IAsyncCursor <BsonDocument> > ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken)
{
var databaseNamespace = _collectionNamespace.DatabaseNamespace;
var command = new BsonDocument("listIndexes", _collectionNamespace.CollectionName);
var operation = new ReadCommandOperation <BsonDocument>(databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
try
{
var response = await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false);
var cursorDocument = response["cursor"].AsBsonDocument;
var cursor = new AsyncCursor <BsonDocument>(
channelSource.Fork(),
CollectionNamespace.FromFullName(cursorDocument["ns"].AsString),
command,
cursorDocument["firstBatch"].AsBsonArray.OfType <BsonDocument>().ToList(),
cursorDocument["id"].ToInt64(),
0,
0,
BsonDocumentSerializer.Instance,
_messageEncoderSettings);
return(cursor);
}
catch (MongoCommandException ex)
{
if (ex.Code == 26)
{
return(new SingleBatchAsyncCursor <BsonDocument>(new List <BsonDocument>()));
}
throw;
}
}
// private methods
private Mock <IWriteBinding> CreateMockWriteBinding(IChannelSourceHandle channelSource)
{
var mockBinding = new Mock <IWriteBinding>();
mockBinding.Setup(b => b.GetWriteChannelSource(It.IsAny <CancellationToken>())).Returns(channelSource);
mockBinding.Setup(b => b.GetWriteChannelSourceAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(channelSource));
return(mockBinding);
}
// private methods
private IWriteBinding CreateFakeWriteBinding(IChannelSourceHandle channelSource)
{
var binding = Substitute.For <IWriteBinding>();
binding.GetWriteChannelSource(CancellationToken.None).ReturnsForAnyArgs(channelSource);
binding.GetWriteChannelSourceAsync(CancellationToken.None).ReturnsForAnyArgs(Task.FromResult(channelSource));
return(binding);
}
/// <summary>
/// Replaces the channel source.
/// </summary>
/// <param name="channelSource">The channel source.</param>
public void ReplaceChannelSource(IChannelSourceHandle channelSource)
{
Ensure.IsNotNull(channelSource, nameof(channelSource));
_channelSource?.Dispose();
_channel?.Dispose();
_channelSource = channelSource;
_channel = null;
}
private AsyncCursor <TResult> CreateCursor(IChannelSourceHandle channelSource, IChannelHandle channel, BsonDocument command, AggregateResult result)
{
if (SupportedFeatures.IsAggregateCursorResultSupported(channel.ConnectionDescription.ServerVersion) && _useCursor.GetValueOrDefault(true))
{
return(CreateCursorFromCursorResult(channelSource, command, result));
}
return(CreateCursorFromInlineResult(command, result));
}
private async Task InsertUserAsync(IChannelSourceHandle channelSource, CollectionNamespace collectionNamespace, BsonDocument user, CancellationToken cancellationToken)
{
var inserts = new[] { new InsertRequest(user) };
var operation = new BulkMixedWriteOperation(collectionNamespace, inserts, _messageEncoderSettings)
{
WriteConcern = WriteConcern.Acknowledged
};
await operation.ExecuteAsync(channelSource, cancellationToken).ConfigureAwait(false);
}
// private methods
private IReadBinding CreateFakeReadBinding(ReadPreference readPreference, IChannelSourceHandle channelSource)
{
var binding = Substitute.For <IReadBinding>();
binding.ReadPreference.Returns(readPreference);
binding.GetReadChannelSource(CancellationToken.None).ReturnsForAnyArgs(channelSource);
binding.GetReadChannelSourceAsync(CancellationToken.None).ReturnsForAnyArgs(Task.FromResult(channelSource));
return(binding);
}
private AsyncCursor <TResult> CreateCursor(IChannelSourceHandle channelSource, BsonDocument command, AggregateResult result)
{
if (_useCursor.GetValueOrDefault(true))
{
return(CreateCursorFromCursorResult(channelSource, command, result));
}
return(CreateCursorFromInlineResult(command, result));
}
private Task <BsonDocument> ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, CancellationToken cancellationToken)
{
var databaseNamespace = _collectionNamespace.DatabaseNamespace;
var command = CreateCommand();
var resultSerializer = BsonDocumentSerializer.Instance;
var operation = new WriteCommandOperation <BsonDocument>(databaseNamespace, command, resultSerializer, _messageEncoderSettings);
return(operation.ExecuteAsync(channelSource, cancellationToken));
}
private void InsertUser(IChannelSourceHandle channelSource, ICoreSessionHandle session, CollectionNamespace collectionNamespace, BsonDocument user, CancellationToken cancellationToken)
{
var inserts = new[] { new InsertRequest(user) };
var operation = new BulkMixedWriteOperation(collectionNamespace, inserts, _messageEncoderSettings)
{
WriteConcern = WriteConcern.Acknowledged
};
operation.Execute(channelSource, session, cancellationToken);
}
private async Task UpdateUserAsync(IChannelSourceHandle channelSource, CollectionNamespace collectionNamespace, BsonDocument user, CancellationToken cancellationToken)
{
var filter = new BsonDocument("_id", user["_id"]);
var updates = new[] { new UpdateRequest(UpdateType.Replacement, filter, user) };
var operation = new BulkMixedWriteOperation(collectionNamespace, updates, _messageEncoderSettings)
{
WriteConcern = WriteConcern.Acknowledged
};
await operation.ExecuteAsync(channelSource, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Executes a write operation using a channel source.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="operation">The write operation.</param>
/// <param name="channelSource">The channel source.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Task whose result is the result of the operation.</returns>
public static async Task <TResult> ExecuteAsync <TResult>(
this IWriteOperation <TResult> operation,
IChannelSourceHandle channelSource,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, "operation");
using (var writeBinding = new ChannelSourceReadWriteBinding(channelSource.Fork(), ReadPreference.Primary))
{
return(await operation.ExecuteAsync(writeBinding, cancellationToken).ConfigureAwait(false));
}
}
private AsyncCursor <TResult> CreateCursor(IChannelSourceHandle channelSource, IChannelHandle channel, BsonDocument command, AggregateResult result)
{
if (result.CursorId.HasValue)
{
return(CreateCursorFromCursorResult(channelSource, command, result));
}
else
{
return(CreateCursorFromInlineResult(command, result));
}
}
/// <summary>
/// Executes a write operation using a channel source.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="operation">The write operation.</param>
/// <param name="channelSource">The channel source.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The result of the operation.</returns>
public static TResult Execute <TResult>(
this IWriteOperation <TResult> operation,
IChannelSourceHandle channelSource,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, nameof(operation));
using (var writeBinding = new ChannelSourceReadWriteBinding(channelSource.Fork(), ReadPreference.Primary))
{
return(operation.Execute(writeBinding, cancellationToken));
}
}
private async Task <IAsyncCursor <BsonDocument> > ExecuteUsingQueryAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken)
{
var systemIndexesCollection = _collectionNamespace.DatabaseNamespace.SystemIndexesCollection;
var filter = new BsonDocument("ns", _collectionNamespace.FullName);
var operation = new FindOperation <BsonDocument>(systemIndexesCollection, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter
};
return(await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false));
}
private void UpdateUser(IChannelSourceHandle channelSource, ICoreSessionHandle session, CollectionNamespace collectionNamespace, BsonDocument user, CancellationToken cancellationToken)
{
var filter = new BsonDocument("_id", user["_id"]);
var updates = new[] { new UpdateRequest(UpdateType.Replacement, filter, user) };
var operation = new BulkMixedWriteOperation(collectionNamespace, updates, _messageEncoderSettings)
{
WriteConcern = WriteConcern.Acknowledged
};
operation.Execute(channelSource, session, cancellationToken);
}
private BsonDocument FindUser(IChannelSourceHandle channelSource, ICoreSessionHandle session, CollectionNamespace collectionNamespace, CancellationToken cancellationToken)
{
var operation = new FindOperation <BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = new BsonDocument("user", _username),
Limit = -1
};
var cursor = operation.Execute(channelSource, ReadPreference.Primary, session, cancellationToken);
var userDocuments = cursor.ToList();
return(userDocuments.FirstOrDefault());
}
private async Task <IReadOnlyList <BsonDocument> > ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken)
{
var command = new BsonDocument
{
{ "listCollections", 1 },
{ "filter", _filter, _filter != null }
};
var operation = new ReadCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var response = await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false);
return(response["collections"].AsBsonArray.Select(value => (BsonDocument)value).ToList());
}
// private methods
private IAsyncCursor <TDocument> CreateCursor(IChannelSourceHandle channelSource, BsonDocument query, CursorBatch <TDocument> batch)
{
return(new AsyncCursor <TDocument>(
channelSource.Fork(),
_collectionNamespace,
query,
batch.Documents,
batch.CursorId,
_batchSize,
_limit < 0 ? Math.Abs(_limit.Value) : _limit,
_resultSerializer,
_messageEncoderSettings));
}
private AsyncCursor <TResult> CreateCursorFromCursorResult(IChannelSourceHandle channelSource, BsonDocument command, AggregateResult result)
{
return(new AsyncCursor <TResult>(
channelSource.Fork(),
CollectionNamespace,
command,
result.Results,
result.CursorId.GetValueOrDefault(0),
_batchSize ?? 0,
0, // limit
_resultSerializer,
MessageEncoderSettings));
}
/// <summary>
/// Executes a read operation using a channel source.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="operation">The read operation.</param>
/// <param name="channelSource">The channel source.</param>
/// <param name="readPreference">The read preference.</param>
/// <param name="session">The session.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A Task whose result is the result of the operation.
/// </returns>
public static async Task <TResult> ExecuteAsync <TResult>(
this IReadOperation <TResult> operation,
IChannelSourceHandle channelSource,
ReadPreference readPreference,
ICoreSessionHandle session,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, nameof(operation));
using (var readBinding = new ChannelSourceReadWriteBinding(channelSource.Fork(), readPreference, session.Fork()))
{
return(await operation.ExecuteAsync(readBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <summary>
/// Executes a read operation using a channel source.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="operation">The read operation.</param>
/// <param name="channelSource">The channel source.</param>
/// <param name="readPreference">The read preference.</param>
/// <param name="session">The session.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// The result of the operation.
/// </returns>
public static TResult Execute <TResult>(
this IReadOperation <TResult> operation,
IChannelSourceHandle channelSource,
ReadPreference readPreference,
ICoreSessionHandle session,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, nameof(operation));
using (var readBinding = new ChannelSourceReadWriteBinding(channelSource.Fork(), readPreference, session.Fork()))
{
return(operation.Execute(readBinding, cancellationToken));
}
}
private async Task <BsonDocument> FindUserAsync(IChannelSourceHandle channelSource, CollectionNamespace collectionNamespace, CancellationToken cancellationToken)
{
var operation = new FindOperation <BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = new BsonDocument("user", _username),
Limit = -1
};
var cursor = await operation.ExecuteAsync(channelSource, ReadPreference.Primary, cancellationToken).ConfigureAwait(false);
var userDocuments = await cursor.ToListAsync().ConfigureAwait(false);
return(userDocuments.FirstOrDefault());
}
private void Initialize(CancellationToken cancellationToken)
{
_channelSource = _binding.GetReadChannelSource(cancellationToken);
try
{
_channel = _channelSource.GetChannel(cancellationToken);
}
catch (Exception ex) when(RetryableReadOperationExecutor.ShouldConnectionAcquireBeRetried(this, ex))
{
ReplaceChannelSource(_binding.GetReadChannelSource(cancellationToken));
ReplaceChannel(_channelSource.GetChannel(cancellationToken));
}
}
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));
}
}
private AsyncCursor <TDocument> CreateCursor(IChannelSourceHandle channelSource, CursorBatch <TDocument> batch, bool slaveOk)
{
return(new AsyncCursor <TDocument>(
channelSource.Fork(),
_collectionNamespace,
_filter ?? new BsonDocument(),
batch.Documents,
batch.CursorId,
_batchSize,
_limit < 0 ? Math.Abs(_limit.Value) : _limit,
_resultSerializer,
_messageEncoderSettings,
null)); // maxTime
}
private async Task <BsonDocument> ExecuteUsingInsertAsync(IChannelSourceHandle channelSource, CancellationToken cancellationToken)
{
var systemIndexesCollection = _collectionNamespace.DatabaseNamespace.SystemIndexesCollection;
foreach (var createIndexRequest in _requests)
{
var document = createIndexRequest.CreateIndexDocument();
document.InsertAt(0, new BsonElement("ns", _collectionNamespace.FullName));
var documentSource = new BatchableSource <BsonDocument>(new[] { document });
var operation = new InsertOpcodeOperation(systemIndexesCollection, documentSource, _messageEncoderSettings);
await operation.ExecuteAsync(channelSource, cancellationToken).ConfigureAwait(false);
}
return(new BsonDocument("ok", 1));
}
public void Setup()
{
_channelSource = Substitute.For<IChannelSourceHandle>();
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ChannelSourceReadWriteBinding"/> class.
/// </summary>
/// <param name="channelSource">The channel source.</param>
/// <param name="readPreference">The read preference.</param>
public ChannelSourceReadWriteBinding(IChannelSourceHandle channelSource, ReadPreference readPreference)
{
_channelSource = Ensure.IsNotNull(channelSource, "channelSource");
_readPreference = Ensure.IsNotNull(readPreference, "readPreference");
}
