public Task <T> RunCommandAsync <T>(object command, TimeSpan?timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(command, "command");
var commandDocument = command as BsonDocument;
if (commandDocument == null)
{
if (command is string)
{
commandDocument = BsonDocument.Parse((string)command);
}
else
{
var commandSerializer = _settings.SerializerRegistry.GetSerializer(command.GetType());
commandDocument = new BsonDocumentWrapper(command, commandSerializer);
}
}
var isReadCommand = CanCommandBeSentToSecondary.Delegate(commandDocument);
var serializer = _settings.SerializerRegistry.GetSerializer <T>();
var messageEncoderSettings = GetMessageEncoderSettings();
if (isReadCommand)
{
var operation = new ReadCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteReadOperation <T>(operation, timeout, cancellationToken));
}
else
{
var operation = new WriteCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteWriteOperation <T>(operation, timeout, cancellationToken));
}
}
// 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);
}
// 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);
}
// methods
public async Task <bool> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken)
{
var command = new BsonDocument("dropUser", _username);
var operation = new WriteCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
return(true);
}
private void ExecuteCommand(BsonDocument command)
{
var adminDatabase = new DatabaseNamespace("admin");
var operation = new WriteCommandOperation <BsonDocument>(
adminDatabase,
command,
BsonDocumentSerializer.Instance,
new MessageEncoderSettings());
operation.Execute(_binding, CancellationToken.None);
}
private void ExecuteCommand(BsonDocument command, bool waitForConnected)
{
if (waitForConnected)
{
// server can transition to unknown state during the test, wait until server is connected
SpinWait.SpinUntil(() => _server.Description.State == ServerState.Connected, 1000);
}
var adminDatabase = new DatabaseNamespace("admin");
var operation = new WriteCommandOperation <BsonDocument>(
adminDatabase,
command,
BsonDocumentSerializer.Instance,
new MessageEncoderSettings());
operation.Execute(_binding, CancellationToken.None);
}
internal TCommandResult RunCommandAs <TCommandResult>(
IMongoCommand command,
IBsonSerializer <TCommandResult> resultSerializer,
ReadPreference readPreference)
where TCommandResult : CommandResult
{
var commandDocument = command.ToBsonDocument();
var isReadCommand = CanCommandBeSentToSecondary.Delegate(commandDocument);
if (readPreference != ReadPreference.Primary)
{
var timeoutAt = DateTime.UtcNow + _server.Settings.ConnectTimeout;
var cluster = _server.Cluster;
var clusterType = cluster.Description.Type;
while (clusterType == ClusterType.Unknown)
{
// TODO: find a way to block until the cluster description changes
if (DateTime.UtcNow >= timeoutAt)
{
throw new TimeoutException();
}
Thread.Sleep(TimeSpan.FromMilliseconds(20));
clusterType = cluster.Description.Type;
}
if (clusterType == ClusterType.ReplicaSet && !isReadCommand)
{
readPreference = ReadPreference.Primary;
}
}
var messageEncoderSettings = GetMessageEncoderSettings();
if (isReadCommand)
{
var operation = new ReadCommandOperation <TCommandResult>(_namespace, commandDocument, resultSerializer, messageEncoderSettings);
return(ExecuteReadOperation(operation, readPreference));
}
else
{
var operation = new WriteCommandOperation <TCommandResult>(_namespace, commandDocument, resultSerializer, messageEncoderSettings);
return(ExecuteWriteOperation(operation));
}
}
private TCommandResult RunWriteCommandAs <TCommandResult>(
BsonDocument command,
IBsonSerializer <TCommandResult> resultSerializer,
out MongoServerInstance serverInstance)
where TCommandResult : CommandResult
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new WriteCommandOperation <TCommandResult>(new DatabaseNamespace(_name), command, resultSerializer, messageEncoderSettings);
using (var binding = _server.GetWriteBinding())
using (var connectionSource = binding.GetWriteConnectionSource())
{
var endPoint = (DnsEndPoint)connectionSource.ServerDescription.EndPoint;
var address = new MongoServerAddress(endPoint.Host, endPoint.Port);
serverInstance = _server.GetServerInstance(address);
return(operation.Execute(connectionSource, Timeout.InfiniteTimeSpan, CancellationToken.None));
}
}
public override Task <TResult> RunCommandAsync <TResult>(Command <TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(command, "command");
readPreference = readPreference ?? ReadPreference.Primary;
var renderedCommand = command.Render(_settings.SerializerRegistry);
var messageEncoderSettings = GetMessageEncoderSettings();
if (readPreference == ReadPreference.Primary)
{
var operation = new WriteCommandOperation <TResult>(_databaseNamespace, renderedCommand.Document, renderedCommand.ResultSerializer, messageEncoderSettings);
return(ExecuteWriteOperation <TResult>(operation, cancellationToken));
}
else
{
var operation = new ReadCommandOperation <TResult>(_databaseNamespace, renderedCommand.Document, renderedCommand.ResultSerializer, messageEncoderSettings);
return(ExecuteReadOperation <TResult>(operation, readPreference, cancellationToken));
}
}
internal TCommandResult RunCommandAs <TCommandResult>(
IMongoCommand command,
IBsonSerializer <TCommandResult> resultSerializer,
ReadPreference readPreference)
where TCommandResult : CommandResult
{
var commandDocument = command.ToBsonDocument();
var messageEncoderSettings = GetMessageEncoderSettings();
if (readPreference == ReadPreference.Primary)
{
var operation = new WriteCommandOperation <TCommandResult>(_namespace, commandDocument, resultSerializer, messageEncoderSettings);
return(ExecuteWriteOperation(operation));
}
else
{
var operation = new ReadCommandOperation <TCommandResult>(_namespace, commandDocument, resultSerializer, messageEncoderSettings);
return(ExecuteReadOperation(operation, readPreference));
}
}
public Task <T> RunCommandAsync <T>(object command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(command, "command");
readPreference = readPreference ?? ReadPreference.Primary;
var commandDocument = BsonDocumentHelper.ToBsonDocument(_settings.SerializerRegistry, command);
var serializer = _settings.SerializerRegistry.GetSerializer <T>();
var messageEncoderSettings = GetMessageEncoderSettings();
if (readPreference == ReadPreference.Primary)
{
var operation = new WriteCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteWriteOperation <T>(operation, cancellationToken));
}
else
{
var operation = new ReadCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteReadOperation <T>(operation, readPreference, cancellationToken));
}
}
public Task <T> RunCommandAsync <T>(object command, CancellationToken cancellationToken)
{
Ensure.IsNotNull(command, "command");
var commandDocument = BsonDocumentHelper.ToBsonDocument(_settings.SerializerRegistry, command);
var isReadCommand = CanCommandBeSentToSecondary.Delegate(commandDocument);
var serializer = _settings.SerializerRegistry.GetSerializer <T>();
var messageEncoderSettings = GetMessageEncoderSettings();
if (isReadCommand)
{
var operation = new ReadCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteReadOperation <T>(operation, cancellationToken));
}
else
{
var operation = new WriteCommandOperation <T>(_databaseNamespace, commandDocument, serializer, messageEncoderSettings);
return(ExecuteWriteOperation <T>(operation, cancellationToken));
}
}
