public void CreateWrappedQuery_should_create_the_correct_query_when_not_connected_to_a_shard_router()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Comment = "funny",
Filter = BsonDocument.Parse("{x: 1}"),
MaxTime = TimeSpan.FromSeconds(20),
Modifiers = BsonDocument.Parse("{$comment: \"notfunny\", $snapshot: true}"),
Projection = BsonDocument.Parse("{y: 1}"),
Sort = BsonDocument.Parse("{a: 1}")
};
var expectedResult = new BsonDocument
{
{ "$query", BsonDocument.Parse("{x: 1}") },
{ "$orderby", BsonDocument.Parse("{a: 1}") },
{ "$comment", "funny" },
{ "$maxTimeMS", 20000 },
{ "$snapshot", true }
};
var result = subject.CreateWrappedQuery(ServerType.ReplicaSetArbiter, ReadPreference.Secondary);
result.Should().Be(expectedResult);
}
internal static IEnumerable<IFileSystemInformation> EnumerateChildrenInternal(
string directory,
ChildType childType,
string searchPattern,
System.IO.SearchOption searchOption,
FileAttributes excludeAttributes,
IFileService fileService)
{
// We want to be able to see all files as we recurse and open new find handles (that might be over MAX_PATH).
// We've already normalized our base directory.
string extendedDirectory = Paths.AddExtendedPrefix(directory);
// The assertion here is that we want to find files that match the desired pattern in all subdirectories, even if the
// subdirectories themselves don't match the pattern. That requires two passes to avoid overallocating for directories
// with a large number of files.
// First look for items that match the given search pattern in the current directory
using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, searchPattern)))
{
FindResult findResult;
while ((findResult = findOperation.GetNextResult()) != null)
{
bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;
if ((findResult.Attributes & excludeAttributes) == 0
&& findResult.FileName != "."
&& findResult.FileName != ".."
&& ((isDirectory && childType == ChildType.Directory)
|| (!isDirectory && childType == ChildType.File)))
{
yield return FileSystemInformation.Create(findResult, directory, fileService);
}
}
}
if (searchOption != System.IO.SearchOption.AllDirectories) yield break;
// Now recurse into each subdirectory
using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, "*"), directoriesOnly: true))
{
FindResult findResult;
while ((findResult = findOperation.GetNextResult()) != null)
{
// Unfortunately there is no guarantee that the API will return only directories even if we ask for it
bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;
if ((findResult.Attributes & excludeAttributes) == 0
&& isDirectory
&& findResult.FileName != "."
&& findResult.FileName != "..")
{
foreach (var child in EnumerateChildrenInternal(Paths.Combine(directory, findResult.FileName), childType, searchPattern,
searchOption, excludeAttributes, fileService))
{
yield return child;
}
}
}
}
}
public void Constructor_should_initialize_object()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.ResultSerializer.Should().NotBeNull();
subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings);
}
public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-1)]
int value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
Action action = () => subject.BatchSize = value;
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("value");
}
public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-1)]
int value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var exception = Record.Exception(() => { subject.BatchSize = value; });
var argumentOutOfRangeException = exception.Should().BeOfType<ArgumentOutOfRangeException>().Subject;
argumentOutOfRangeException.ParamName.Should().Be("value");
}
public void BatchSize_get_and_set_should_work(
[Values(null, 0, 1)]
int? value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.BatchSize = value;
var result = subject.BatchSize;
result.Should().Be(value);
}
public void AllowPartialResults_get_and_set_should_work(
[Values(null, false, true)]
bool? value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.AllowPartialResults = value;
var result = subject.AllowPartialResults;
result.Should().Be(value);
}
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());
}
// methods
public async Task <IEnumerable <BsonDocument> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users");
var filter = _username == null ? new BsonDocument() : new BsonDocument("user", _username);
var operation = new FindOperation <BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter
};
var cursor = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
return(await cursor.ToListAsync(cancellationToken).ConfigureAwait(false));
}
public void Collation_get_and_set_should_work(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = locale == null ? null : new Collation(locale);
subject.Collation = value;
var result = subject.Collation;
result.Should().Be(value);
}
public void CollectionNamespace_get_should_return_expected_result(
[Values("a", "b")]
string collectionName)
{
var databaseNamespace = new DatabaseNamespace("test");
var collectionNamespace = new CollectionNamespace(databaseNamespace, collectionName);
var subject = new FindOperation<BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var result = subject.CollectionNamespace;
result.Should().Be(collectionNamespace);
}
// methods
public override async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
{
var renderedPipeline = Ensure.IsNotNull(pipeline, "pipeline").Render(_documentSerializer, _settings.SerializerRegistry);
options = options ?? new AggregateOptions();
var last = renderedPipeline.Documents.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
renderedPipeline.Documents,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
MaxTime = options.MaxTime
};
await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
var outputCollectionName = last.GetElement(0).Value.AsString;
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
renderedPipeline.OutputSerializer,
_messageEncoderSettings)
{
BatchSize = options.BatchSize,
MaxTime = options.MaxTime
};
// we want to delay execution of the find because the user may
// not want to iterate the results at all...
return(await Task.FromResult <IAsyncCursor <TResult> >(new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct))).ConfigureAwait(false));
}
else
{
var aggregateOperation = new AggregateOperation <TResult>(
_collectionNamespace,
renderedPipeline.Documents,
renderedPipeline.OutputSerializer,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
BatchSize = options.BatchSize,
MaxTime = options.MaxTime,
UseCursor = options.UseCursor
};
return(await ExecuteReadOperation(aggregateOperation, cancellationToken).ConfigureAwait(false));
}
}
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());
}
// methods
public IEnumerable <BsonDocument> Execute(IReadBinding binding, CancellationToken cancellationToken)
{
var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users");
var filter = _username == null ? new BsonDocument() : new BsonDocument("user", _username);
var operation = new FindOperation <BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter,
RetryRequested = false
};
var cursor = operation.Execute(binding, cancellationToken);
return(cursor.ToList(cancellationToken));
}
// private methods
private async Task GetChunkAsync(long n, CancellationToken cancellationToken)
{
var chunksCollectionNamespace = Bucket.GetChunksCollectionNamespace();
var messageEncoderSettings = Bucket.GetMessageEncoderSettings();
#pragma warning disable 618
var filter = new BsonDocument
{
{ "files_id", FilesCollectionDocument.IdAsBsonValue },
{ "n", n }
};
#pragma warning restore
var operation = new FindOperation <BsonDocument>(
chunksCollectionNamespace,
BsonDocumentSerializer.Instance,
messageEncoderSettings)
{
Filter = filter,
Limit = -1
};
using (var cursor = await operation.ExecuteAsync(Binding, cancellationToken).ConfigureAwait(false))
{
var documents = await cursor.ToListAsync();
if (documents.Count == 0)
{
#pragma warning disable 618
throw new GridFSChunkException(FilesCollectionDocument.IdAsBsonValue, n, "missing");
#pragma warning restore
}
var document = documents[0];
var data = document["data"].AsBsonBinaryData.Bytes;
var chunkSizeBytes = FilesCollectionDocument.ChunkSizeBytes;
var lastChunk = 0;
var expectedChunkSize = n == lastChunk ? FilesCollectionDocument.Length % chunkSizeBytes : chunkSizeBytes;
if (data.Length != expectedChunkSize)
{
#pragma warning disable 618
throw new GridFSChunkException(FilesCollectionDocument.IdAsBsonValue, n, "the wrong size");
#pragma warning restore
}
_chunk = data;
_n = n;
}
}
private async Task <IAsyncCursor <BsonDocument> > Query(IReadBinding binding, BsonDocument filter)
{
var findOp = new FindOperation <BsonDocument>(_collection, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter,
Limit = -1
};
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token))
{
return(await findOp.ExecuteAsync(binding, linked.Token));
}
}
public static void DeleteDirectoryRecursive(string path)
{
var data = FileMethods.TryGetFileInfo(path);
if (!data.HasValue)
{
// Nothing found
throw ErrorHelper.GetIoExceptionForError(WindowsError.ERROR_PATH_NOT_FOUND, path);
}
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != FileAttributes.FILE_ATTRIBUTE_DIRECTORY)
{
// Not a directory, a file
throw ErrorHelper.GetIoExceptionForError(WindowsError.ERROR_FILE_EXISTS, path);
}
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_READONLY) == FileAttributes.FILE_ATTRIBUTE_READONLY)
{
// Make it writable
FileMethods.SetFileAttributes(path, data.Value.Attributes & ~FileAttributes.FILE_ATTRIBUTE_READONLY);
}
// Reparse points don't need to be empty to be deleted. Deleting will simply disconnect the reparse point, which is what we want.
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT) != FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT)
{
using (FindOperation findOperation = new FindOperation(Paths.Combine(path, "*")))
{
FindResult findResult;
while ((findResult = findOperation.GetNextResult()) != null)
{
if (findResult.FileName != "." && findResult.FileName != "..")
{
bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;
if (isDirectory)
{
DeleteDirectoryRecursive(Paths.Combine(path, findResult.FileName));
}
else
{
FileMethods.DeleteFile(Paths.Combine(path, findResult.FileName));
}
}
}
}
}
// We've either emptied or we're a reparse point, delete the directory
DirectoryMethods.RemoveDirectory(path);
}
public void OpenFileWithTrailingSeparator()
{
using (var cleaner = new TestFileCleaner())
{
string testFile = cleaner.CreateTestFile(nameof(OpenFileWithTrailingSeparator));
string fullName = Storage.GetFullPathName(Paths.AddTrailingSeparator(testFile));
FindOperation <string> find = new FindOperation <string>(testFile);
Action action = () => find.FirstOrDefault();
action.Should().Throw <ArgumentException>().And.HResult.Should().Be((int)WindowsError.ERROR_INVALID_PARAMETER.ToHResult());
action = () => Storage.CreateFile(Paths.AddTrailingSeparator(testFile), CreationDisposition.OpenExisting, DesiredAccess.ReadAttributes);
action.Should().Throw <WInteropIOException>().And.HResult.Should().Be((int)WindowsError.ERROR_INVALID_NAME.ToHResult());
}
}
protected override void Given()
{
_subject = new FindOperation <BsonDocument>(
CollectionNamespace,
BsonDocumentSerializer.Instance,
MessageEncoderSettings);
Insert(new[]
{
BsonDocument.Parse("{_id: 1, x: 1}"),
BsonDocument.Parse("{_id: 2, x: 2}"),
BsonDocument.Parse("{_id: 3, x: 3}"),
BsonDocument.Parse("{_id: 4, x: 4}"),
BsonDocument.Parse("{_id: 5, x: 5}"),
BsonDocument.Parse("{_id: 6, x: 6}"),
});
}
// methods
public async Task <IAsyncEnumerable <TResult> > AggregateAsync <TResult>(AggregateModel <TResult> model, TimeSpan?timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(model, "model");
var pipeline = model.Pipeline.Select(x => ConvertToBsonDocument(x)).ToList();
var last = pipeline.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
pipeline,
_messageEncoderSettings)
{
AllowDiskUse = model.AllowDiskUse,
MaxTime = model.MaxTime
};
await ExecuteWriteOperation(operation, timeout, cancellationToken);
var outputCollectionName = last.GetElement(0).Value.AsString;
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
model.ResultSerializer ?? _settings.SerializerRegistry.GetSerializer <TResult>(),
_messageEncoderSettings)
{
BatchSize = model.BatchSize,
MaxTime = model.MaxTime
};
return(await Task.FromResult <IAsyncEnumerable <TResult> >(new AsyncCursorAsyncEnumerable <TResult>(
() => ExecuteReadOperation(findOperation, timeout, cancellationToken),
null)));
}
else
{
var operation = CreateAggregateOperation <TResult>(model, pipeline);
return(await Task.FromResult <IAsyncEnumerable <TResult> >(new AsyncCursorAsyncEnumerable <TResult>(
() => ExecuteReadOperation(operation, timeout, cancellationToken),
null)));
}
}
public async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IEnumerable <object> pipeline, AggregateOptions <TResult> options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(pipeline, "pipeline");
options = options ?? new AggregateOptions <TResult>();
var pipelineDocuments = pipeline.Select(x => ConvertToBsonDocument(x)).ToList();
var last = pipelineDocuments.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
pipelineDocuments,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
MaxTime = options.MaxTime
};
await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
var outputCollectionName = last.GetElement(0).Value.AsString;
var resultSerializer = ResolveResultSerializer(options.ResultSerializer);
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
resultSerializer,
_messageEncoderSettings)
{
BatchSize = options.BatchSize,
MaxTime = options.MaxTime
};
// we want to delay execution of the find because the user may
// not want to iterate the results at all...
return(await Task.FromResult <IAsyncCursor <TResult> >(new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct))).ConfigureAwait(false));
}
else
{
var operation = CreateAggregateOperation <TResult>(options, pipelineDocuments);
return(await ExecuteReadOperation(operation, cancellationToken).ConfigureAwait(false));
}
}
public void FindRecursive()
{
using (var cleaner = new TestFileCleaner())
{
string subdirA = Paths.Combine(cleaner.TempFolder, "A");
Storage.CreateDirectory(subdirA);
string fileB = Paths.Combine(subdirA, "B");
FileHelper.WriteAllText(fileB, "B file");
string subdirC = Paths.Combine(subdirA, "C");
Storage.CreateDirectory(subdirC);
string subdirD = Paths.Combine(subdirA, "D");
Storage.CreateDirectory(subdirD);
string fileE = Paths.Combine(subdirD, "E");
FileHelper.WriteAllText(fileE, "E file");
var files = new FindOperation <string>(subdirA, recursive: true).ToArray();
files.Should().BeEquivalentTo(System.IO.Directory.GetFileSystemEntries(subdirA, "*", System.IO.SearchOption.AllDirectories));
}
}
private IAsyncCursor <BsonDocument> CreateAndRunFindOperation(RetryableReadContext context, bool async)
{
var findOperation = new FindOperation <BsonDocument>(
_collectionNamespace,
BsonDocumentSerializer.Instance,
_messageEncoderSettings)
{
BatchSize = 1
};
if (async)
{
return(findOperation.ExecuteAsync(context, CancellationToken.None).GetAwaiter().GetResult());
}
else
{
return(findOperation.Execute(context, CancellationToken.None));
}
}
internal static IEnumerable <IFileSystemInformation> EnumerateChildrenInternal(
string directory,
ChildType childType,
string searchPattern,
System.IO.SearchOption searchOption,
FileAttributes excludeAttributes,
IFileService fileService)
{
// We want to be able to see all files as we recurse and open new find handles (that might be over MAX_PATH).
// We've already normalized our base directory.
string extendedDirectory = Paths.AddExtendedPrefix(directory);
var transformFilter = new FindTransformFilter(excludeAttributes, fileService);
FindOperation <IFileSystemInformation> findOperation = new FindOperation <IFileSystemInformation>(
extendedDirectory,
searchPattern,
recursive: searchOption == System.IO.SearchOption.AllDirectories ? true : false,
transformFilter,
transformFilter);
return(findOperation);
}
// private methods
private async Task GetFirstBatchAsync(CancellationToken cancellationToken)
{
var chunksCollectionNamespace = Bucket.GetChunksCollectionNamespace();
var messageEncoderSettings = Bucket.GetMessageEncoderSettings();
#pragma warning disable 618
var filter = new BsonDocument("files_id", FileInfo.IdAsBsonValue);
#pragma warning restore
var sort = new BsonDocument("n", 1);
var operation = new FindOperation <BsonDocument>(
chunksCollectionNamespace,
BsonDocumentSerializer.Instance,
messageEncoderSettings)
{
Filter = filter,
Sort = sort
};
_cursor = await operation.ExecuteAsync(Binding, cancellationToken).ConfigureAwait(false);
await GetNextBatchAsync(cancellationToken).ConfigureAwait(false);
}
private async Task <bool> IsFilesCollectionEmptyAsync(IReadWriteBindingHandle binding, CancellationToken cancellationToken)
{
var filesCollectionNamespace = GetFilesCollectionNamespace();
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new FindOperation <BsonDocument>(filesCollectionNamespace, BsonDocumentSerializer.Instance, messageEncoderSettings)
{
Limit = 1,
Projection = new BsonDocument("_id", 1)
};
using (var cursor = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false))
{
if (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false))
{
var batch = cursor.Current;
if (batch.Count() > 0)
{
return(false);
}
}
}
return(true);
}
public void constructor_should_initialize_instance()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.ResultSerializer.Should().NotBeNull();
subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings);
subject.AllowPartialResults.Should().NotHaveValue();
subject.BatchSize.Should().NotHaveValue();
subject.Comment.Should().BeNull();
subject.CursorType.Should().Be(CursorType.NonTailable);
subject.Filter.Should().BeNull();
subject.FirstBatchSize.Should().NotHaveValue();
subject.Hint.Should().BeNull();
subject.Limit.Should().NotHaveValue();
subject.Max.Should().BeNull();
subject.MaxScan.Should().NotHaveValue();
subject.MaxTime.Should().NotHaveValue();
subject.Min.Should().BeNull();
subject.Modifiers.Should().BeNull();
subject.NoCursorTimeout.Should().NotHaveValue();
subject.OplogReplay.Should().NotHaveValue();
subject.Projection.Should().BeNull();
subject.ReadConcern.Should().Be(ReadConcern.Default);
subject.ResultSerializer.Should().Be(BsonDocumentSerializer.Instance);
subject.ReturnKey.Should().NotHaveValue();
subject.ShowRecordId.Should().NotHaveValue();
subject.SingleBatch.Should().NotHaveValue();
subject.Skip.Should().NotHaveValue();
subject.Snapshot.Should().NotHaveValue();
subject.Sort.Should().BeNull();
}
private async Task<GridFSFileInfo> GetFileInfoByNameAsync(IReadBindingHandle binding, string filename, int revision, CancellationToken cancellationToken)
{
var collectionNamespace = GetFilesCollectionNamespace();
var serializerRegistry = _database.Settings.SerializerRegistry;
var fileInfoSerializer = serializerRegistry.GetSerializer<GridFSFileInfo>();
var messageEncoderSettings = GetMessageEncoderSettings();
var filter = new BsonDocument("filename", filename);
var skip = revision >= 0 ? revision : -revision - 1;
var limit = 1;
var sort = new BsonDocument("uploadDate", revision >= 0 ? 1 : -1);
var operation = new FindOperation<GridFSFileInfo>(
collectionNamespace,
fileInfoSerializer,
messageEncoderSettings)
{
Filter = filter,
Limit = limit,
Skip = skip,
Sort = sort
};
using (var cursor = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false))
{
var fileInfoList = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false);
var fileInfo = fileInfoList.FirstOrDefault();
if (fileInfo == null)
{
throw new GridFSFileNotFoundException(filename, revision);
}
return fileInfo;
}
}
public void Sort_get_and_set_should_work(
[Values(null, "{ a : 1 }", "{ b : -1 }")]
string json)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = json == null ? null : BsonDocument.Parse(json);
subject.Sort = value;
var result = subject.Sort;
result.Should().Be(value);
}
public void Comment_get_and_set_should_work(
[Values(null, "a", "b")]
string value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Comment = value;
var result = subject.Comment;
result.Should().Be(value);
}
public void ResultSerializer_get_should_return_expected_result()
{
var resultSerializer = new BsonDocumentSerializer();
var subject = new FindOperation<BsonDocument>(_collectionNamespace, resultSerializer, _messageEncoderSettings);
var result = subject.ResultSerializer;
result.Should().Be(resultSerializer);
}
public void CreateFindOpcodeOperation_should_return_expected_result_when_singleBatch_is_true()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Limit = 1;
subject.SingleBatch = true;
var result = subject.CreateFindOpcodeOperation();
result.Limit.Should().Be(-subject.Limit);
}
public void CursorType_get_and_set_should_work(
[Values(CursorType.NonTailable, CursorType.Tailable)]
CursorType value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CursorType = value;
var result = subject.CursorType;
result.Should().Be(value);
}
public void CreateFindOpcodeOperation_should_return_expected_result()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.AllowPartialResults = true;
subject.BatchSize = 1;
subject.Comment = "comment";
subject.CursorType = CursorType.Tailable;
subject.Filter = new BsonDocument("filter", 1);
subject.FirstBatchSize = 2;
subject.Hint = "x_1";
subject.Limit = 3;
subject.Max = new BsonDocument("max", 1);
subject.MaxScan = 4;
subject.MaxTime = TimeSpan.FromSeconds(1);
subject.Min = new BsonDocument("min", 1);
subject.NoCursorTimeout = true;
subject.OplogReplay = true;
subject.Projection = new BsonDocument("projection", 1);
subject.ReadConcern = ReadConcern.Local;
subject.ReturnKey = true;
subject.ShowRecordId = true;
subject.SingleBatch = false;
subject.Skip = 6;
subject.Snapshot = true;
subject.Sort = new BsonDocument("sort", 1);
var result = subject.CreateFindOpcodeOperation();
result.AllowPartialResults.Should().Be(subject.AllowPartialResults);
result.BatchSize.Should().Be(subject.BatchSize);
result.CollectionNamespace.Should().Be(subject.CollectionNamespace);
result.Comment.Should().Be(subject.Comment);
result.CursorType.Should().Be(subject.CursorType);
result.Filter.Should().Be(subject.Filter);
result.FirstBatchSize.Should().Be(subject.FirstBatchSize);
result.Hint.Should().Be(subject.Hint);
result.Limit.Should().Be(subject.Limit);
result.Max.Should().Be(subject.Max);
result.MaxScan.Should().Be(subject.MaxScan);
result.MaxTime.Should().Be(subject.MaxTime);
result.MessageEncoderSettings.Should().BeSameAs(subject.MessageEncoderSettings);
result.Min.Should().Be(subject.Min);
result.Modifiers.Should().Be(subject.Modifiers);
result.NoCursorTimeout.Should().Be(subject.NoCursorTimeout);
result.OplogReplay.Should().Be(subject.OplogReplay);
result.Projection.Should().Be(subject.Projection);
result.ResultSerializer.Should().Be(subject.ResultSerializer);
result.ShowRecordId.Should().Be(subject.ShowRecordId);
result.Skip.Should().Be(subject.Skip);
result.Snapshot.Should().Be(subject.Snapshot);
result.Sort.Should().Be(subject.Sort);
}
private async Task<IAsyncCursor<BsonDocument>> Query(IReadBinding binding, BsonDocument filter)
{
var findOp = new FindOperation<BsonDocument>(_collection, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Filter = filter,
Limit = -1
};
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token))
{
return await findOp.ExecuteAsync(binding, linked.Token);
}
}
public void findOperationTest()
{
var f = new FindOperation();
Assert.AreEqual("0 + 8 - 1 + 90 - 45", f.findOperation(new[] { 0, 8, 1, 90, 45 }, 52));
}
public void Execute_should_find_all_the_documents_matching_the_query_when_split_across_batches(
[Values(false, true)]
bool async)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
BatchSize = 2
};
var cursor = ExecuteOperation(subject, async);
var result = ReadCursorToEnd(cursor, async);
result.Should().HaveCount(5);
}
private async Task<bool> IsFilesCollectionEmptyAsync(IReadWriteBindingHandle binding, CancellationToken cancellationToken)
{
var filesCollectionNamespace = GetFilesCollectionNamespace();
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new FindOperation<BsonDocument>(filesCollectionNamespace, BsonDocumentSerializer.Instance, messageEncoderSettings)
{
Limit = 1,
SingleBatch = true,
Projection = new BsonDocument("_id", 1)
};
using (var cursor = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false))
{
if (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false))
{
var batch = cursor.Current;
if (batch.Count() > 0)
{
return false;
}
}
}
return true;
}
public void ExecuteAsync_should_throw_when_binding_is_null()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
Func<Task> action = () => subject.ExecuteAsync(null, CancellationToken.None);
action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("binding");
}
public void Execute_should_raise_an_error_when_an_unsupported_read_concern_is_specified(
[Values(false, true)]
bool async)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
ReadConcern = ReadConcern.Majority
};
Action act = () => ExecuteOperation(subject, async);
act.ShouldThrow<MongoClientException>();
}
public void Execute_should_find_documents_matching_options(
[Values(false, true)]
bool async)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Comment = "funny",
Filter = BsonDocument.Parse("{ y : 1 }"),
Limit = 4,
MaxTime = TimeSpan.FromSeconds(20),
Projection = BsonDocument.Parse("{ y : 1 }"),
Skip = 1,
Sort = BsonDocument.Parse("{ _id : -1 }")
};
var cursor = ExecuteOperation(subject, async);
var result = ReadCursorToEnd(cursor, async);
result.Should().HaveCount(1);
}
public void MaxTime_get_and_set_should_work(
[Values(null, 1)]
int? seconds)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = seconds == null ? (TimeSpan?)null : TimeSpan.FromSeconds(seconds.Value);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void MessageEncoderSettings_get_should_return_expected_result(
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.Standard)]
GuidRepresentation guidRepresentation)
{
var messageEncoderSettings = new MessageEncoderSettings { { "GuidRepresentation", guidRepresentation } };
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, messageEncoderSettings);
var result = subject.MessageEncoderSettings;
result.Should().BeEquivalentTo(messageEncoderSettings);
}
private string Find(FindOperation op, HtmlDocument doc)
{
return op(doc);
}
public void ReadConcern_get_and_set_should_work()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.ReadConcern = ReadConcern.Local;
var result = subject.ReadConcern;
result.Should().Be(ReadConcern.Local);
}
public void Limit_get_and_set_should_work(
[Values(-2, -1, 0, 1, 2)]
int? value)
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Limit = value;
var result = subject.Limit;
result.Should().Be(value);
}
public override async Task <IAsyncCursor <TResult> > MapReduceAsync <TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions <TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(map, "map");
Ensure.IsNotNull(reduce, "reduce");
options = options ?? new MapReduceOptions <TDocument, TResult>();
var outputOptions = options.OutputOptions ?? MapReduceOutputOptions.Inline;
var resultSerializer = ResolveResultSerializer <TResult>(options.ResultSerializer);
if (outputOptions == MapReduceOutputOptions.Inline)
{
var operation = new MapReduceOperation <TResult>(
_collectionNamespace,
map,
reduce,
resultSerializer,
_messageEncoderSettings)
{
Filter = options.Filter == null ? null : options.Filter.Render(_documentSerializer, _settings.SerializerRegistry),
FinalizeFunction = options.Finalize,
JavaScriptMode = options.JavaScriptMode,
Limit = options.Limit,
MaxTime = options.MaxTime,
Scope = options.Scope,
Sort = options.Sort == null ? null : options.Sort.Render(_documentSerializer, _settings.SerializerRegistry),
Verbose = options.Verbose
};
return(await ExecuteReadOperation(operation, cancellationToken).ConfigureAwait(false));
}
else
{
var collectionOutputOptions = (MapReduceOutputOptions.CollectionOutput)outputOptions;
var databaseNamespace = collectionOutputOptions.DatabaseName == null ?
_collectionNamespace.DatabaseNamespace :
new DatabaseNamespace(collectionOutputOptions.DatabaseName);
var outputCollectionNamespace = new CollectionNamespace(databaseNamespace, collectionOutputOptions.CollectionName);
var operation = new MapReduceOutputToCollectionOperation(
_collectionNamespace,
outputCollectionNamespace,
map,
reduce,
_messageEncoderSettings)
{
Filter = options.Filter == null ? null : options.Filter.Render(_documentSerializer, _settings.SerializerRegistry),
FinalizeFunction = options.Finalize,
JavaScriptMode = options.JavaScriptMode,
Limit = options.Limit,
MaxTime = options.MaxTime,
NonAtomicOutput = collectionOutputOptions.NonAtomic,
Scope = options.Scope,
OutputMode = collectionOutputOptions.OutputMode,
ShardedOutput = collectionOutputOptions.Sharded,
Sort = options.Sort == null ? null : options.Sort.Render(_documentSerializer, _settings.SerializerRegistry),
Verbose = options.Verbose
};
await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
var findOperation = new FindOperation <TResult>(
outputCollectionNamespace,
resultSerializer,
_messageEncoderSettings)
{
MaxTime = options.MaxTime
};
// we want to delay execution of the find because the user may
// not want to iterate the results at all...
var deferredCursor = new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct));
return(await Task.FromResult(deferredCursor).ConfigureAwait(false));
}
}
public void CreateFindCommandOperation_should_return_expected_result_when_modifiers_are_provided()
{
var subject = new FindOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
ReadConcern = ReadConcern.Majority
};
subject.Modifiers = new BsonDocument
{
{ "$hint", "x_1" },
{ "$max", new BsonDocument("max", 1) },
{ "$maxScan", 1 },
{ "$maxTimeMS", 2000 },
{ "$min", new BsonDocument("min", 1) },
{ "$orderby", new BsonDocument("sort", 1) },
{ "$showDiskLoc", true },
{ "$snapshot", true }
};
var result = subject.CreateFindCommandOperation();
result.Hint.Should().Be(subject.Modifiers["$hint"]);
result.Max.Should().Be(subject.Modifiers["$max"].AsBsonDocument);
result.MaxScan.Should().Be(subject.Modifiers["$maxScan"].AsInt32);
result.MaxTime.Should().Be(TimeSpan.FromMilliseconds(subject.Modifiers["$maxTimeMS"].AsInt32));
result.Min.Should().Be(subject.Modifiers["$min"].AsBsonDocument);
result.ReadConcern.Should().Be(subject.ReadConcern);
result.ShowRecordId.Should().Be(subject.Modifiers["$showDiskLoc"].AsBoolean);
result.Snapshot.Should().Be(subject.Modifiers["$snapshot"].AsBoolean);
result.Sort.Should().Be(subject.Modifiers["$orderby"].AsBsonDocument);
}
// private methods
private async Task GetFirstBatchAsync(CancellationToken cancellationToken)
{
var chunksCollectionNamespace = Bucket.GetChunksCollectionNamespace();
var messageEncoderSettings = Bucket.GetMessageEncoderSettings();
#pragma warning disable 618
var filter = new BsonDocument("files_id", FilesCollectionDocument.IdAsBsonValue);
#pragma warning restore
var sort = new BsonDocument("n", 1);
var operation = new FindOperation<BsonDocument>(
chunksCollectionNamespace,
BsonDocumentSerializer.Instance,
messageEncoderSettings)
{
Filter = filter,
Sort = sort
};
_cursor = await operation.ExecuteAsync(Binding, cancellationToken).ConfigureAwait(false);
await GetNextBatchAsync(cancellationToken).ConfigureAwait(false);
}
