private BsonValue ExecuteOperation(EvalOperation operation, IWriteBinding binding, bool async)
{
if (async)
{
return operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
return operation.Execute(binding, CancellationToken.None);
}
}
/// <inheritdoc/>
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
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()))
{
var operation = CreateOperation(channelBinding.Session);
BsonDocument result;
try
{
result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
}
catch (MongoCommandException ex)
{
if (!ShouldIgnoreException(ex))
{
throw;
}
result = ex.Result;
}
return(result);
}
}
// methods
public bool Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = binding.GetWriteChannelSource(cancellationToken))
{
var userExists = UserExists(channelSource, binding.Session, cancellationToken);
var roles = new BsonArray();
if (_databaseNamespace.DatabaseName == "admin")
{
roles.Add(_readOnly ? "readAnyDatabase" : "root");
}
else
{
roles.Add(_readOnly ? "read" : "dbOwner");
}
var commandName = userExists ? "updateUser" : "createUser";
var command = new BsonDocument
{
{ commandName, _username },
{ "pwd", _passwordHash },
{ "digestPassword", false },
{ "roles", roles }
};
var operation = new WriteCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
operation.Execute(channelSource, binding.Session, cancellationToken);
}
return(true);
}
/// <inheritdoc />
public virtual async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var context = await RetryableWriteContext.CreateAsync(binding, _retryRequested, cancellationToken).ConfigureAwait(false))
{
return(Execute(context, cancellationToken));
}
}
// public methods
/// <inheritdoc />
public virtual BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var context = RetryableWriteContext.Create(binding, _retryRequested, cancellationToken))
{
return(Execute(context, cancellationToken));
}
}
public Task EnsureCollectionExistsAsync(IWriteBinding binding)
{
var requests = new[] { new InsertRequest(new BsonDocument("_id", 1)) };
var operation = new BulkInsertOperation(_collectionNamespace, requests, _messageEncoderSettings);
return(operation.ExecuteAsync(binding, CancellationToken.None));
}
// methods
public async Task <bool> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users");
var user = await FindUserAsync(channelSource, collectionNamespace, cancellationToken).ConfigureAwait(false);
if (user == null)
{
user = new BsonDocument
{
{ "_id", ObjectId.GenerateNewId() },
{ "user", _username },
{ "pwd", _passwordHash },
{ "readOnly", _readOnly },
};
await InsertUserAsync(channelSource, collectionNamespace, user, cancellationToken).ConfigureAwait(false);
}
else
{
user["pwd"] = _passwordHash;
user["readOnly"] = _readOnly;
await UpdateUserAsync(channelSource, collectionNamespace, user, cancellationToken).ConfigureAwait(false);
}
}
return(true);
}
// constructors
public GridFSForwardOnlyUploadStream(
GridFSBucket <TFileId> bucket,
IWriteBinding binding,
TFileId id,
string filename,
BsonDocument metadata,
IEnumerable <string> aliases,
string contentType,
int chunkSizeBytes,
int batchSize,
bool disableMD5)
{
_bucket = bucket;
_binding = binding;
_id = id;
_filename = filename;
_metadata = metadata; // can be null
_aliases = aliases == null ? null : aliases.ToList(); // can be null
_contentType = contentType; // can be null
_chunkSizeBytes = chunkSizeBytes;
_batchSize = batchSize;
_batch = new List <byte[]>();
_md5 = disableMD5 ? null : IncrementalHash.CreateHash(HashAlgorithmName.MD5);
_disableMD5 = disableMD5;
var idSerializer = bucket.Options.SerializerRegistry.GetSerializer <TFileId>();
var idSerializationInfo = new BsonSerializationInfo("_id", idSerializer, typeof(TFileId));
_idAsBsonValue = idSerializationInfo.SerializeValue(id);
}
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, "binding");
var result = await ExecuteCommandAsync(binding, timeout, cancellationToken);
return(result["value"].AsBsonDocument);
}
/// <summary>
/// Creates and initializes a retryable write 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 write context.</returns>
public static async Task <RetryableWriteContext> CreateAsync(IWriteBinding binding, bool retryRequested, CancellationToken cancellationToken)
{
var context = new RetryableWriteContext(binding, retryRequested);
try
{
await context.InitializeAsync(cancellationToken).ConfigureAwait(false);
if (context.Binding.Session.IsInTransaction &&
ChannelPinningHelper.PinChannelSourceAndChannelIfRequired(
context.ChannelSource,
context.Channel,
context.Binding.Session,
out var pinnedChannelSource,
out var pinnedChannel))
{
context.ReplaceChannelSource(pinnedChannelSource);
context.ReplaceChannel(pinnedChannel);
}
return(context);
}
catch
{
context.Dispose();
throw;
}
}
/// <inheritdoc/>
public async Task <IEnumerable <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();
var result = await emulator.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false);
return(new[] { result });
}
else
{
if (_documentSource.Batch == null)
{
return(await InsertMultipleBatchesAsync(channel, cancellationToken).ConfigureAwait(false));
}
else
{
var result = await InsertSingleBatchAsync(channel, cancellationToken).ConfigureAwait(false);
return(new[] { result });
}
}
}
}
public TResult ExecuteWriteOperation <TResult>(IWriteBinding binding, IWriteOperation <TResult> operation, CancellationToken cancellationToken)
{
_calls.Enqueue(new WriteCall <TResult>
{
Binding = binding,
Operation = operation,
CancellationToken = cancellationToken,
SessionId = binding.Session.Id,
UsedImplicitSession = binding.Session.IsImplicit
});
if (_results.Count > 0)
{
var result = _results.Dequeue();
var exception = result as Exception;
if (exception != null)
{
throw exception;
}
return((TResult)result);
}
return(default(TResult));
}
private static Task Insert(IWriteBinding binding, BsonDocument document)
{
var documentSource = new BatchableSource <BsonDocument>(new[] { document });
var insertOp = new InsertOpcodeOperation <BsonDocument>(__collection, documentSource, BsonDocumentSerializer.Instance, __messageEncoderSettings);
return(insertOp.ExecuteAsync(binding));
}
// public methods
/// <inheritdoc/>
public BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var operation = CreateOperation();
return(operation.Execute(binding, cancellationToken));
}
// public methods
/// <inheritdoc/>
public IEnumerable <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 (Feature.WriteCommands.IsSupported(channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged)
{
var emulator = CreateEmulator();
var result = emulator.Execute(channel, channelSource.Session, cancellationToken);
return(new[] { result });
}
else
{
if (_documentSource.Batch == null)
{
return(InsertMultipleBatches(channel, cancellationToken));
}
else
{
var result = InsertSingleBatch(channel, cancellationToken);
return(new[] { result });
}
}
}
}
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, "binding");
var protocol = CreateProtocol();
return(await protocol.ExecuteAsync(binding, timeout, cancellationToken));
}
/// <inheritdoc/>
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var operation = CreateOperation();
return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false));
}
// public methods
/// <inheritdoc/>
public BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
using (var channelSource = binding.GetWriteChannelSource(cancellationToken))
using (var channel = channelSource.GetChannel(cancellationToken))
using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork()))
{
var operation = CreateOperation(channelBinding.Session, channel.ConnectionDescription);
BsonDocument result;
try
{
result = operation.Execute(channelBinding, cancellationToken);
}
catch (MongoCommandException ex)
{
if (!ShouldIgnoreException(ex))
{
throw;
}
result = ex.Result;
}
WriteConcernErrorHelper.ThrowIfHasWriteConcernError(channel.ConnectionDescription.ConnectionId, result);
return(result);
}
}
// methods
public bool Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = binding.GetWriteChannelSource(cancellationToken))
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users");
var user = FindUser(channelSource, binding.Session, collectionNamespace, cancellationToken);
if (user == null)
{
user = new BsonDocument
{
{ "_id", ObjectId.GenerateNewId() },
{ "user", _username },
{ "pwd", _passwordHash },
{ "readOnly", _readOnly },
};
InsertUser(channelSource, binding.Session, collectionNamespace, user, cancellationToken);
}
else
{
user["pwd"] = _passwordHash;
user["readOnly"] = _readOnly;
UpdateUser(channelSource, binding.Session, collectionNamespace, user, cancellationToken);
}
}
return(true);
}
// helper methods
private void EnsureDatabaseExists(IWriteBinding binding)
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test");
var requests = new[] { new InsertRequest(new BsonDocument()) };
var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings);
insertOperation.Execute(binding);
}
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
var command = CreateCommand();
var operation = new WriteCommandOperation(_databaseNamespace, command, _messageEncoderSettings);
return(await operation.ExecuteAsync(binding, timeout, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc/>
public Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
var command = CreateCommand();
var operation = new WriteCommandOperation <BsonDocument>(CollectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, MessageEncoderSettings);
return(operation.ExecuteAsync(binding, cancellationToken));
}
public BulkWriteOperationResult Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = binding.GetWriteChannelSource(cancellationToken))
using (var channel = channelSource.GetChannel(cancellationToken))
{
return(Execute(channel, cancellationToken));
}
}
// methods
public bool Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
var command = new BsonDocument("dropUser", _username);
var operation = new WriteCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
operation.Execute(binding, cancellationToken);
return(true);
}
public async Task <BsonDocument> ExecuteCommandAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, "binding");
var command = CreateCommand();
var operation = new WriteCommandOperation(_collectionNamespace.DatabaseNamespace, command, _messageEncoderSettings);
return(await operation.ExecuteAsync(binding, timeout, cancellationToken));
}
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, "binding");
var command = CreateCommand();
var operation = new WriteCommandOperation("admin", command);
return(await operation.ExecuteAsync(binding, timeout, cancellationToken));
}
// helper methods
private void EnsureDatabaseExists(IWriteBinding binding)
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test");
var requests = new[] { new InsertRequest(new BsonDocument()) };
var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings);
insertOperation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
/// <inheritdoc/>
public async Task <BsonValue> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var operation = CreateOperation();
var result = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
return(result["retval"]);
}
// public methods
/// <inheritdoc/>
public BsonValue Execute(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var operation = CreateOperation();
var result = operation.Execute(binding, cancellationToken);
return(result["retval"]);
}
public async Task <BulkWriteOperationResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false))
using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false))
{
return(await ExecuteAsync(channel, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var command = CreateCommand();
var operation = new WriteCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false));
}
// constructors
public GridFSForwardOnlyUploadStream(
GridFSBucket bucket,
IWriteBinding binding,
ObjectId id,
string filename,
BsonDocument metadata,
IEnumerable<string> aliases,
string contentType,
int chunkSizeBytes,
int batchSize)
{
_bucket = bucket;
_binding = binding;
_id = id;
_filename = filename;
_metadata = metadata; // can be null
_aliases = aliases == null ? null : aliases.ToList(); // can be null
_contentType = contentType; // can be null
_chunkSizeBytes = chunkSizeBytes;
_batchSize = batchSize;
_batch = new List<byte[]>();
_md5 = MD5.Create();
}
private static Task Update(IWriteBinding binding, BsonDocument query, BsonDocument update)
{
var updateOp = new UpdateOpcodeOperation(
_database,
_collection,
query,
update);
return updateOp.ExecuteAsync(binding);
}
private static Task Update(IWriteBinding binding, BsonDocument criteria, BsonDocument update)
{
var updateOp = new UpdateOpcodeOperation(
__collection,
new UpdateRequest(UpdateType.Update, criteria, update),
__messageEncoderSettings);
return updateOp.ExecuteAsync(binding);
}
private static Task Insert(IWriteBinding binding, BsonDocument document)
{
var documentSource = new BatchableSource<BsonDocument>(new[] { document });
var insertOp = new InsertOpcodeOperation<BsonDocument>(__collection, documentSource, BsonDocumentSerializer.Instance, __messageEncoderSettings);
return insertOp.ExecuteAsync(binding);
}
private async Task Update(IWriteBinding binding, BsonDocument filter, BsonDocument update)
{
var updateOp = new UpdateOpcodeOperation(
_collection,
new UpdateRequest(UpdateType.Update, filter, update),
_messageEncoderSettings);
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token))
{
await updateOp.ExecuteAsync(binding, linked.Token);
}
}
private void EnsureCollectionExists(IWriteBinding binding, CollectionNamespace collectionNamespace)
{
try
{
var operation = new CreateCollectionOperation(collectionNamespace, _messageEncoderSettings);
operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
catch (MongoCommandException ex)
{
if (ex.Message == "Command create failed: collection already exists.")
{
return;
}
throw;
}
}
// helper methods
private void EnsureCollectionDoesNotExist(IWriteBinding binding, CollectionNamespace collectionNamespace)
{
var operation = new DropCollectionOperation(collectionNamespace, _messageEncoderSettings);
operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
// constructors
public SplitReadWriteBinding(IReadBinding readBinding, IWriteBinding writeBinding)
{
_readBinding = Ensure.IsNotNull(readBinding, "readBinding");
_writeBinding = Ensure.IsNotNull(writeBinding, "writeBinding");
}
// 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));
}
// helper methods
private void EnsureDatabaseExists(IWriteBinding binding)
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test");
var requests = new[] { new InsertRequest(new BsonDocument()) };
var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings);
insertOperation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
private static Task Insert(IWriteBinding binding, BsonDocument document)
{
var insertOp = new InsertOpcodeOperation<BsonDocument>(
_database,
_collection,
BsonDocumentSerializer.Instance,
new BatchableSource<BsonDocument>(new[] { document }));
return insertOp.ExecuteAsync(binding);
}
public void Setup()
{
_readBinding = Substitute.For<IReadBinding>();
_writeBinding = Substitute.For<IWriteBinding>();
}
public Task DropDatabaseAsync(IWriteBinding binding)
{
var operation = new DropDatabaseOperation(_collectionNamespace.DatabaseNamespace, _messageEncoderSettings);
return operation.ExecuteAsync(binding, CancellationToken.None);
}
private BsonDocument ExecuteOperation(CreateCollectionOperation subject, IWriteBinding binding, bool async)
{
if (async)
{
return subject.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
return subject.Execute(binding, CancellationToken.None);
}
}
private async Task Insert(IWriteBinding binding, BsonDocument document)
{
var documentSource = new BatchableSource<BsonDocument>(new[] { document });
var insertOp = new InsertOpcodeOperation<BsonDocument>(_collection, documentSource, BsonDocumentSerializer.Instance, _messageEncoderSettings);
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token))
{
await insertOp.ExecuteAsync(binding, linked.Token);
}
}
private static Task Update(IWriteBinding binding, BsonDocument query, BsonDocument update)
{
var updateOp = new UpdateOpcodeOperation(
__collection,
query,
update,
__messageEncoderSettings);
return updateOp.ExecuteAsync(binding);
}
public Task EnsureCollectionExistsAsync(IWriteBinding binding)
{
var requests = new[] { new InsertRequest(new BsonDocument("_id", 1)) };
var operation = new BulkInsertOperation(_collectionNamespace, requests, _messageEncoderSettings);
return operation.ExecuteAsync(binding, CancellationToken.None);
}
