private async Task InitializeAsync(CancellationToken cancellationToken)
{
_channelSource = await _binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false);
var serverDescription = _channelSource.ServerDescription;
try
{
_channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false);
}
catch (Exception ex) when(RetryableWriteOperationExecutor.ShouldConnectionAcquireBeRetried(this, serverDescription, ex))
{
ReplaceChannelSource(await _binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false));
ReplaceChannel(await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false));
}
}
// methods
public async Task <bool> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
var userExists = await UserExistsAsync(channelSource, cancellationToken).ConfigureAwait(false);
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);
await operation.ExecuteAsync(channelSource, cancellationToken).ConfigureAwait(false);
}
return(true);
}
/// <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, channel.ConnectionDescription);
BsonDocument result;
try
{
result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
}
catch (MongoCommandException ex)
{
if (!ShouldIgnoreException(ex))
{
throw;
}
result = ex.Result;
}
WriteConcernErrorHelper.ThrowIfHasWriteConcernError(channel.ConnectionDescription.ConnectionId, result);
return(result);
}
}
// 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);
}
/// <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 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));
}
}
// methods
/// <inheritdoc/>
public async Task <TCommandResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(binding, nameof(binding));
using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
return(await ExecuteProtocolAsync(channelSource, ReadPreference.Primary, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <IEnumerable <WriteConcernResult> > ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
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)
{
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))
{
var operation = CreateWriteOperation(channel.ConnectionDescription, binding.Session);
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <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))
{
return(await ExecuteAsync(channel, cancellationToken).ConfigureAwait(false));
}
}
/// <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);
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <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()))
{
var operation = CreateOperation(channel.ConnectionDescription.ServerVersion);
var result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false);
WriteConcernErrorHelper.ThrowIfHasWriteConcernError(channel.ConnectionDescription.ConnectionId, result);
return(result);
}
}
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
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 <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var mayUseSecondary = new MayUseSecondary(_readPreference);
using (var channelSource = await binding.GetWriteChannelSourceAsync(mayUseSecondary, 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, channel.ConnectionDescription, mayUseSecondary.EffectiveReadPreference);
return(await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false));
}
}
/// <inheritdoc/>
public async Task <BulkWriteOperationResult> 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))
{
var helper = new BatchHelper(this, channel);
foreach (var batch in helper.GetBatches())
{
batch.Result = await ExecuteBatchAsync(channel, channelSource.Session, batch.Run, batch.IsLast, cancellationToken).ConfigureAwait(false);
}
return(helper.GetFinalResultOrThrow());
}
}
/// <inheritdoc/>
public async Task <TResult> 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))
{
var operation = CreateOperation(channel.ConnectionDescription.ServerVersion);
using (var rawBsonDocument = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false))
{
return(ProcessCommandResult(channel.ConnectionDescription.ConnectionId, rawBsonDocument));
}
}
}
/// <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));
}
}
// methods
public async Task<bool> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false))
{
IWriteOperation<bool> operation;
if (channelSource.ServerDescription.Version >= __serverVersionSupportingUserManagementCommands)
{
operation = new DropUserUsingUserManagementCommandsOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
else
{
operation = new DropUserUsingSystemUsersCollectionOperation(_databaseNamespace, _username, _messageEncoderSettings);
}
return await operation.ExecuteAsync(channelSource, cancellationToken).ConfigureAwait(false);
}
}
/// <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));
}
}
}
private async Task InitializeAsync(CancellationToken cancellationToken)
{
_channelSource = await _binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false);
_channel = await _channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false);
}
// static methods
public static IChannelSourceHandle GetWriteChannelSource(this IWriteBinding binding, CancellationToken cancellationToken = default(CancellationToken))
{
return(binding.GetWriteChannelSourceAsync(cancellationToken).GetAwaiter().GetResult());
}
/// <inheritdoc/>
public Task <IChannelSourceHandle> GetWriteChannelSourceAsync(CancellationToken cancellationToken)
{
ThrowIfDisposed();
return(_writeBinding.GetWriteChannelSourceAsync(cancellationToken));
}
