private IReadOnlyList <IAsyncCursor <TDocument> > CreateCursors(IChannelSourceHandle channelSource, BsonDocument command, BsonDocument result) { var cursors = new List <AsyncCursor <TDocument> >(); foreach (var cursorDocument in result["cursors"].AsBsonArray.Select(v => v["cursor"].AsBsonDocument)) { var cursorId = cursorDocument["id"].ToInt64(); var firstBatch = cursorDocument["firstBatch"].AsBsonArray.Select(v => { var bsonDocument = (BsonDocument)v; using (var reader = new BsonDocumentReader(bsonDocument)) { var context = BsonDeserializationContext.CreateRoot(reader); var document = _serializer.Deserialize(context); return(document); } }) .ToList(); var cursor = new AsyncCursor <TDocument>( channelSource.Fork(), _collectionNamespace, command, firstBatch, cursorId, _batchSize ?? 0, 0, // limit _serializer, _messageEncoderSettings); cursors.Add(cursor); } return(cursors); }
public void Session_reference_count_should_be_decremented_as_soon_as_possible(int collectionSize, int batchSize) { RequireServer.Check(); DropCollection(); var documents = Enumerable.Range(1, collectionSize).Select(n => new BsonDocument("_id", n)); Insert(documents); _session.ReferenceCount().Should().Be(1); var cancellationToken = CancellationToken.None; using (var binding = new ReadPreferenceBinding(CoreTestConfiguration.Cluster, ReadPreference.Primary, _session.Fork())) using (var channelSource = (ChannelSourceHandle)binding.GetReadChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { var query = new BsonDocument(); long cursorId; var firstBatch = GetFirstBatch(channel, query, batchSize, cancellationToken, out cursorId); using (var cursor = new AsyncCursor <BsonDocument>(channelSource, _collectionNamespace, firstBatch, cursorId, batchSize, null, BsonDocumentSerializer.Instance, new MessageEncoderSettings())) { AssertExpectedSessionReferenceCount(_session, cursor); while (cursor.MoveNext(cancellationToken)) { AssertExpectedSessionReferenceCount(_session, cursor); } AssertExpectedSessionReferenceCount(_session, cursor); } } _session.ReferenceCount().Should().Be(1); }
private async Task <IAsyncCursor <BsonDocument> > ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken) { var databaseNamespace = _collectionNamespace.DatabaseNamespace; var command = new BsonDocument("listIndexes", _collectionNamespace.CollectionName); var operation = new ReadCommandOperation <BsonDocument>(databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); try { var response = await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false); var cursorDocument = response["cursor"].AsBsonDocument; var cursor = new AsyncCursor <BsonDocument>( channelSource.Fork(), CollectionNamespace.FromFullName(cursorDocument["ns"].AsString), command, cursorDocument["firstBatch"].AsBsonArray.OfType <BsonDocument>().ToList(), cursorDocument["id"].ToInt64(), 0, 0, BsonDocumentSerializer.Instance, _messageEncoderSettings); return(cursor); } catch (MongoCommandException ex) { if (ex.Code == 26) { return(new SingleBatchAsyncCursor <BsonDocument>(new List <BsonDocument>())); } throw; } }
// private methods private void Close(AsyncCursor <BsonDocument> asyncCursor, bool async, CancellationToken cancellationToken) { if (async) { asyncCursor.CloseAsync(cancellationToken).GetAwaiter().GetResult(); } else { asyncCursor.Close(cancellationToken); } }
private IAsyncCursor <BsonDocument> CreateCursor(IChannelSourceHandle channelSource, BsonDocument result, BsonDocument command) { var cursorDocument = result["cursor"].AsBsonDocument; var cursor = new AsyncCursor <BsonDocument>( channelSource.Fork(), CollectionNamespace.FromFullName(cursorDocument["ns"].AsString), command, cursorDocument["firstBatch"].AsBsonArray.OfType <BsonDocument>().ToList(), cursorDocument["id"].ToInt64(), 0, 0, BsonDocumentSerializer.Instance, _messageEncoderSettings); return(cursor); }
/// <inheritdoc/> public async Task <IReadOnlyList <IAsyncCursor <TDocument> > > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetReadChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { var command = CreateCommand(); var operation = new ReadCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); var result = await operation.ExecuteAsync(channelSource, binding.ReadPreference, cancellationToken).ConfigureAwait(false); var cursors = new List <AsyncCursor <TDocument> >(); foreach (var cursorDocument in result["cursors"].AsBsonArray.Select(v => v["cursor"].AsBsonDocument)) { var cursorId = cursorDocument["id"].ToInt64(); var firstBatch = cursorDocument["firstBatch"].AsBsonArray.Select(v => { var bsonDocument = (BsonDocument)v; using (var reader = new BsonDocumentReader(bsonDocument)) { var context = BsonDeserializationContext.CreateRoot(reader); var document = _serializer.Deserialize(context); return(document); } }) .ToList(); var cursor = new AsyncCursor <TDocument>( channelSource.Fork(), _collectionNamespace, command, firstBatch, cursorId, _batchSize ?? 0, 0, // limit _serializer, _messageEncoderSettings); cursors.Add(cursor); } return(cursors); } }
// private methods private AsyncCursorEnumerator <BsonDocument> CreateSubject(int count) { var firstBatch = Enumerable.Range(0, count) .Select(i => new BsonDocument("_id", i)) .ToArray(); var cursor = new AsyncCursor <BsonDocument>( channelSource: new Mock <IChannelSource>().Object, collectionNamespace: new CollectionNamespace("foo", "bar"), firstBatch: firstBatch, cursorId: 0, batchSize: null, limit: null, serializer: BsonDocumentSerializer.Instance, messageEncoderSettings: new MessageEncoderSettings()); return(new AsyncCursorEnumerator <BsonDocument>(cursor, CancellationToken.None)); }
public void Constructor_should_call_Dispose_on_connectionSource_if_cursorId_is_zero(int cursorId, bool shouldCallDispose) { var connectionSource = Substitute.For <IConnectionSource>(); var subject = new AsyncCursor <BsonDocument>( connectionSource, new CollectionNamespace("databaseName", "collectionName"), new BsonDocument(), // query new BsonDocument[0], // firstBatch cursorId, 0, // batchSize 0, // limit BsonDocumentSerializer.Instance, null, // messageEncoderSettings Timeout.InfiniteTimeSpan, CancellationToken.None); connectionSource.Received(shouldCallDispose ? 1 : 0).Dispose(); }
public void constructor_should_initialize_instance() { var channelSource = new Mock <IChannelSource>().Object; var databaseNamespace = new DatabaseNamespace("test"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "test"); var query = new BsonDocument("x", 1); var firstBatch = new BsonDocument[] { new BsonDocument("y", 2) }; var cursorId = 1L; var batchSize = 2; var limit = 3; var serializer = BsonDocumentSerializer.Instance; var messageEncoderSettings = new MessageEncoderSettings(); var maxTime = TimeSpan.FromSeconds(1); var result = new AsyncCursor <BsonDocument>( channelSource, collectionNamespace, query, firstBatch, cursorId, batchSize, limit, serializer, messageEncoderSettings, maxTime); var reflector = new Reflector(result); reflector.BatchSize.Should().Be(batchSize); reflector.ChannelSource.Should().Be(channelSource); reflector.CollectionNamespace.Should().Be(collectionNamespace); reflector.Count.Should().Be(firstBatch.Length); reflector.CurrentBatch.Should().BeNull(); reflector.CursorId.Should().Be(cursorId); reflector.Disposed.Should().BeFalse(); reflector.FirstBatch.Should().Equal(firstBatch); reflector.Limit.Should().Be(limit); reflector.MaxTime.Should().Be(maxTime); reflector.MessageEncoderSettings.Should().BeEquivalentTo(messageEncoderSettings); reflector.Query.Should().Be(query); reflector.Serializer.Should().Be(serializer); }
private IReadOnlyList <IAsyncCursor <TDocument> > CreateCursors(IChannelSourceHandle channelSource, BsonDocument command, BsonDocument result) { var cursors = new List <AsyncCursor <TDocument> >(); using (var getMoreChannelSource = new ChannelSourceHandle(new ServerChannelSource(channelSource.Server, channelSource.Session.Fork()))) { foreach (var cursorDocument in result["cursors"].AsBsonArray.Select(v => v["cursor"].AsBsonDocument)) { var cursorId = cursorDocument["id"].ToInt64(); var firstBatch = cursorDocument["firstBatch"].AsBsonArray.Select(v => { var bsonDocument = (BsonDocument)v; using (var reader = new BsonDocumentReader(bsonDocument)) { var context = BsonDeserializationContext.CreateRoot(reader); var document = _serializer.Deserialize(context); return(document); } }) .ToList(); // it's not affected by loadbalancing logic since it was deprecated in server version 4.1. var cursor = new AsyncCursor <TDocument>( getMoreChannelSource.Fork(), _collectionNamespace, command, firstBatch, cursorId, _batchSize ?? 0, 0, // limit _serializer, _messageEncoderSettings); cursors.Add(cursor); } } return(cursors); }
public void constructor_should_initialize_instance() { var channelSource = new Mock <IChannelSource>().Object; var databaseNamespace = new DatabaseNamespace("test"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "test"); var firstBatch = new BsonDocument[] { new BsonDocument("y", 2) }; var cursorId = 1L; var batchSize = 2; var limit = 3; var serializer = BsonDocumentSerializer.Instance; var messageEncoderSettings = new MessageEncoderSettings(); var maxTime = TimeSpan.FromSeconds(1); var result = new AsyncCursor <BsonDocument>( channelSource, collectionNamespace, comment: null, firstBatch, cursorId, batchSize, limit, serializer, messageEncoderSettings, maxTime); result._batchSize().Should().Be(batchSize); result._channelSource().Should().Be(channelSource); result._collectionNamespace().Should().Be(collectionNamespace); result._count().Should().Be(firstBatch.Length); result._currentBatch().Should().BeNull(); result._cursorId().Should().Be(cursorId); result._disposed().Should().BeFalse(); result._firstBatch().Should().Equal(firstBatch); result._limit().Should().Be(limit); result._maxTime().Should().Be(maxTime); result._messageEncoderSettings().Should().BeEquivalentTo(messageEncoderSettings); result._serializer().Should().Be(serializer); }
private async Task <IAsyncCursor <BsonDocument> > ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken) { var command = new BsonDocument { { "listCollections", 1 }, { "filter", _filter, _filter != null } }; var operation = new ReadCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); var response = await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false); var cursorDocument = response["cursor"].AsBsonDocument; var cursor = new AsyncCursor <BsonDocument>( channelSource.Fork(), CollectionNamespace.FromFullName(cursorDocument["ns"].AsString), command, cursorDocument["firstBatch"].AsBsonArray.OfType <BsonDocument>().ToList(), cursorDocument["id"].ToInt64(), 0, 0, BsonDocumentSerializer.Instance, _messageEncoderSettings); return(cursor); }
public static MessageEncoderSettings _messageEncoderSettings(this AsyncCursor <BsonDocument> obj) => (MessageEncoderSettings)Reflector.GetFieldValue(obj, nameof(_messageEncoderSettings));
public static TimeSpan?_maxTime(this AsyncCursor <BsonDocument> obj) => (TimeSpan?)Reflector.GetFieldValue(obj, nameof(_maxTime));
public static int _limit(this AsyncCursor <BsonDocument> obj) => (int)Reflector.GetFieldValue(obj, nameof(_limit));
public static IReadOnlyList <BsonDocument> _firstBatch(this AsyncCursor <BsonDocument> obj) => (IReadOnlyList <BsonDocument>)Reflector.GetFieldValue(obj, nameof(_firstBatch));
public static bool _disposed(this AsyncCursor <BsonDocument> obj) => (bool)Reflector.GetFieldValue(obj, nameof(_disposed));
public static long _cursorId(this AsyncCursor <BsonDocument> obj) => (long)Reflector.GetFieldValue(obj, nameof(_cursorId));
public static BsonDocument _query(this AsyncCursor <BsonDocument> obj) => (BsonDocument)Reflector.GetFieldValue(obj, nameof(_query));
public static IChannelSource _channelSource(this AsyncCursor <BsonDocument> obj) => (IChannelSource)Reflector.GetFieldValue(obj, nameof(_channelSource));
// private fields public static int?_batchSize(this AsyncCursor <BsonDocument> obj) => (int?)Reflector.GetFieldValue(obj, nameof(_batchSize));
// private methods public static BsonDocument CreateGetMoreCommand(this AsyncCursor <BsonDocument> obj, ConnectionDescription connectionDescription) => (BsonDocument)Reflector.Invoke(obj, nameof(CreateGetMoreCommand), connectionDescription);
// constructors public Reflector(AsyncCursor <BsonDocument> instance) { _instance = instance; }
public static IBsonSerializer <BsonDocument> _serializer(this AsyncCursor <BsonDocument> obj) => (IBsonSerializer <BsonDocument>)Reflector.GetFieldValue(obj, nameof(_serializer));
public static BsonDocument CreateKillCursorsCommand(this AsyncCursor <BsonDocument> obj) => (BsonDocument)Reflector.Invoke(obj, nameof(CreateKillCursorsCommand));
public static CollectionNamespace _collectionNamespace(this AsyncCursor <BsonDocument> obj) => (CollectionNamespace)Reflector.GetFieldValue(obj, nameof(_collectionNamespace));