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));
}
}
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;
}
}
public override Task <TResult> RunCommandAsync <TResult>(Command <TResult> command, ReadPreference readPreference = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(command, nameof(command));
readPreference = readPreference ?? ReadPreference.Primary;
var renderedCommand = command.Render(_settings.SerializerRegistry);
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new ReadCommandOperation <TResult>(_databaseNamespace, renderedCommand.Document, renderedCommand.ResultSerializer, messageEncoderSettings);
return(ExecuteReadOperationAsync(operation, readPreference, cancellationToken));
}
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));
}
}
// 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>());
}
}
public static string GetStorageEngine()
{
using (var binding = GetReadWriteBinding())
{
var command = new BsonDocument("serverStatus", 1);
var operation = new ReadCommandOperation <BsonDocument>(DatabaseNamespace.Admin, command, BsonDocumentSerializer.Instance, __messageEncoderSettings);
var response = operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
BsonValue storageEngine;
if (response.TryGetValue("storageEngine", out storageEngine) && storageEngine.AsBsonDocument.Contains("name"))
{
return(storageEngine["name"].AsString);
}
else
{
return("mmapv1");
}
}
}
public static IEnumerable <string> GetModules()
{
using (var binding = GetReadBinding())
{
var command = new BsonDocument("buildinfo", 1);
var operation = new ReadCommandOperation <BsonDocument>(DatabaseNamespace.Admin, command, BsonDocumentSerializer.Instance, __messageEncoderSettings);
var response = operation.Execute(binding, CancellationToken.None);
BsonValue modules;
if (response.TryGetValue("modules", out modules))
{
return(modules.AsBsonArray.Select(x => x.ToString()));
}
else
{
return(Enumerable.Empty <string>());
}
}
}
private TCommandResult RunReadCommandAs <TCommandResult>(
BsonDocument command,
IBsonSerializer <TCommandResult> resultSerializer,
ReadPreference readPreference,
out MongoServerInstance serverInstance)
where TCommandResult : CommandResult
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new ReadCommandOperation <TCommandResult>(new DatabaseNamespace(_name), command, resultSerializer, messageEncoderSettings);
using (var binding = _server.GetReadBinding(readPreference))
using (var connectionSource = binding.GetReadConnectionSource())
{
var endPoint = (DnsEndPoint)connectionSource.ServerDescription.EndPoint;
var address = new MongoServerAddress(endPoint.Host, endPoint.Port);
serverInstance = _server.GetServerInstance(address);
return(operation.Execute(connectionSource, readPreference, Timeout.InfiniteTimeSpan, CancellationToken.None));
}
}
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));
}
}
public static string GetStorageEngine()
{
using (var binding = GetReadWriteBinding())
{
var command = new BsonDocument("serverStatus", 1);
var operation = new ReadCommandOperation<BsonDocument>(DatabaseNamespace.Admin, command, BsonDocumentSerializer.Instance, __messageEncoderSettings);
var response = operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
BsonValue storageEngine;
if (response.TryGetValue("storageEngine", out storageEngine) && storageEngine.AsBsonDocument.Contains("name"))
{
return storageEngine["name"].AsString;
}
else
{
return "mmapv1";
}
}
}
public static IEnumerable<string> GetModules()
{
using (var binding = GetReadBinding())
{
var command = new BsonDocument("buildinfo", 1);
var operation = new ReadCommandOperation<BsonDocument>(DatabaseNamespace.Admin, command, BsonDocumentSerializer.Instance, __messageEncoderSettings);
var response = operation.Execute(binding, CancellationToken.None);
BsonValue modules;
if (response.TryGetValue("modules", out modules))
{
return modules.AsBsonArray.Select(x => x.ToString());
}
else
{
return Enumerable.Empty<string>();
}
}
}
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);
}
