コード例 #1
0
 /// <inheritdoc />
 public virtual Task <IAsyncCursor <TResult> > WatchAsync <TResult>(
     IClientSessionHandle session,
     PipelineDefinition <ChangeStreamDocument <TDocument>, TResult> pipeline,
     ChangeStreamOptions options         = null,
     CancellationToken cancellationToken = default(CancellationToken))
 {
     throw new NotImplementedException(); // implemented by subclasses
 }
コード例 #2
0
 // public static methods
 public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult>(
     PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
     ChangeStreamOptions options,
     ReadConcern readConcern,
     MessageEncoderSettings messageEncoderSettings,
     bool retryRequested)
 {
     return(CreateChangeStreamOperation(pipeline, LinqProvider.V2, options, readConcern, messageEncoderSettings, retryRequested));
 }
コード例 #3
0
        /// <summary>
        /// Watches changes on all collection in a database.
        /// </summary>
        /// <param name="database">The database.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A change stream.
        /// </returns>
        public static Task <IChangeStreamCursor <ChangeStreamDocument <BsonDocument> > > WatchAsync(
            this IMongoDatabase database,
            ChangeStreamOptions options         = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(database, nameof(database));
            var emptyPipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >();

            return(database.WatchAsync(emptyPipeline, options, cancellationToken));
        }
コード例 #4
0
        /// <summary>
        /// Watches changes on all collections in all databases.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A change stream.
        /// </returns>
        public static IAsyncCursor <ChangeStreamDocument <BsonDocument> > Watch(
            this IMongoClient client,
            ChangeStreamOptions options         = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(client, nameof(client));
            var emptyPipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >();

            return(client.Watch(emptyPipeline, options, cancellationToken));
        }
コード例 #5
0
 private ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult>(
     PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
     ChangeStreamOptions options)
 {
     return(ChangeStreamHelper.CreateChangeStreamOperation(
                pipeline,
                options,
                _settings.ReadConcern,
                GetMessageEncoderSettings(),
                _settings.RetryReads));
 }
コード例 #6
0
 public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult, TDocument>(
     IMongoCollection <TDocument> collection,
     PipelineDefinition <ChangeStreamDocument <TDocument>, TResult> pipeline,
     IBsonSerializer <TDocument> documentSerializer,
     ChangeStreamOptions options,
     ReadConcern readConcern,
     MessageEncoderSettings messageEncoderSettings,
     bool retryRequested)
 {
     return(CreateChangeStreamOperation(collection, pipeline, documentSerializer, LinqProvider.V2, options, readConcern, messageEncoderSettings, retryRequested));
 }
コード例 #7
0
        public override Task <IChangeStreamCursor <TResult> > WatchAsync <TResult>(
            IClientSessionHandle session,
            PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
            ChangeStreamOptions options         = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(session, nameof(session));
            Ensure.IsNotNull(pipeline, nameof(pipeline));
            var operation = CreateChangeStreamOperation(pipeline, options);

            return(ExecuteReadOperationAsync(session, operation, cancellationToken));
        }
コード例 #8
0
        /// <summary>
        /// Watches changes on all collection in a database.
        /// </summary>
        /// <param name="database">The database.</param>
        /// <param name="session">The session.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A change stream.
        /// </returns>
        public static IChangeStreamCursor <ChangeStreamDocument <BsonDocument> > Watch(
            this IMongoDatabase database,
            IClientSessionHandle session,
            ChangeStreamOptions options         = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(database, nameof(database));
            Ensure.IsNotNull(session, nameof(session));
            var emptyPipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >();

            return(database.Watch(session, emptyPipeline, options, cancellationToken));
        }
コード例 #9
0
        /// <summary>
        /// Watches changes on all collections in all databases.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="session">The session.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A change stream.
        /// </returns>
        public static Task <IChangeStreamCursor <ChangeStreamDocument <BsonDocument> > > WatchAsync(
            this IMongoClient client,
            IClientSessionHandle session,
            ChangeStreamOptions options         = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(client, nameof(client));
            Ensure.IsNotNull(session, nameof(session));
            var emptyPipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >();

            return(client.WatchAsync(session, emptyPipeline, options, cancellationToken));
        }
コード例 #10
0
ファイル: ChangeStreamHelper.cs プロジェクト: LJM74520/nice
        private static void SetOperationOptions <TResult>(
            ChangeStreamOperation <TResult> operation,
            ChangeStreamOptions options,
            ReadConcern readConcern)
        {
            options = options ?? new ChangeStreamOptions();

            operation.BatchSize            = options.BatchSize;
            operation.Collation            = options.Collation;
            operation.FullDocument         = options.FullDocument;
            operation.MaxAwaitTime         = options.MaxAwaitTime;
            operation.ReadConcern          = readConcern;
            operation.ResumeAfter          = options.ResumeAfter;
            operation.StartAtOperationTime = options.StartAtOperationTime;
        }
コード例 #11
0
ファイル: ChangeStreamHelper.cs プロジェクト: LJM74520/nice
        // public static methods
        public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult>(
            PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
            ChangeStreamOptions options,
            ReadConcern readConcern,
            MessageEncoderSettings messageEncoderSettings)
        {
            var renderedPipeline = RenderPipeline(pipeline, BsonDocumentSerializer.Instance);

            var operation = new ChangeStreamOperation <TResult>(
                renderedPipeline.Documents,
                renderedPipeline.OutputSerializer,
                messageEncoderSettings);

            SetOperationOptions(operation, options, readConcern);

            return(operation);
        }
コード例 #12
0
ファイル: ChangeStreamHelper.cs プロジェクト: LJM74520/nice
        public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult, TDocument>(
            IMongoCollection <TDocument> collection,
            PipelineDefinition <ChangeStreamDocument <TDocument>, TResult> pipeline,
            IBsonSerializer <TDocument> documentSerializer,
            ChangeStreamOptions options,
            ReadConcern readConcern,
            MessageEncoderSettings messageEncoderSettings)
        {
            var renderedPipeline = RenderPipeline(pipeline, documentSerializer);

            var operation = new ChangeStreamOperation <TResult>(
                collection.CollectionNamespace,
                renderedPipeline.Documents,
                renderedPipeline.OutputSerializer,
                messageEncoderSettings);

            SetOperationOptions(operation, options, readConcern);

            return(operation);
        }
コード例 #13
0
        public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult>(
            IMongoDatabase database,
            PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
            ChangeStreamOptions options,
            ReadConcern readConcern,
            MessageEncoderSettings messageEncoderSettings,
            bool retryRequested)
        {
            var renderedPipeline = RenderPipeline(pipeline, BsonDocumentSerializer.Instance);

            var operation = new ChangeStreamOperation <TResult>(
                database.DatabaseNamespace,
                renderedPipeline.Documents,
                renderedPipeline.OutputSerializer,
                messageEncoderSettings)
            {
                RetryRequested = retryRequested
            };

            SetOperationOptions(operation, options, readConcern);

            return(operation);
        }
コード例 #14
0
        public void Watch_should_invoke_the_correct_operation(
            [Values(false, true)] bool usingSession,
            [Values(false, true)] bool async)
        {
            var session  = CreateSession(usingSession);
            var pipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >().Limit(1);
            var options  = new ChangeStreamOptions
            {
                BatchSize            = 123,
                Collation            = new Collation("en-us"),
                FullDocument         = ChangeStreamFullDocumentOption.UpdateLookup,
                MaxAwaitTime         = TimeSpan.FromSeconds(123),
                ResumeAfter          = new BsonDocument(),
                StartAfter           = new BsonDocument(),
                StartAtOperationTime = new BsonTimestamp(1, 2)
            };
            var cancellationToken = new CancellationTokenSource().Token;
            var renderedPipeline  = new[] { BsonDocument.Parse("{ $limit : 1 }") };

            if (usingSession)
            {
                if (async)
                {
                    _subject.WatchAsync(session, pipeline, options, cancellationToken).GetAwaiter().GetResult();
                }
                else
                {
                    _subject.Watch(session, pipeline, options, cancellationToken);
                }
            }
            else
            {
                if (async)
                {
                    _subject.WatchAsync(pipeline, options, cancellationToken).GetAwaiter().GetResult();
                }
                else
                {
                    _subject.Watch(pipeline, options, cancellationToken);
                }
            }

            var call = _operationExecutor.GetReadCall <IChangeStreamCursor <ChangeStreamDocument <BsonDocument> > >();

            if (usingSession)
            {
                call.SessionId.Should().BeSameAs(session.ServerSession.Id);
            }
            else
            {
                call.UsedImplicitSession.Should().BeTrue();
            }
            call.CancellationToken.Should().Be(cancellationToken);

            var changeStreamOperation = call.Operation.Should().BeOfType <ChangeStreamOperation <ChangeStreamDocument <BsonDocument> > >().Subject;

            changeStreamOperation.BatchSize.Should().Be(options.BatchSize);
            changeStreamOperation.Collation.Should().BeSameAs(options.Collation);
            changeStreamOperation.CollectionNamespace.Should().BeNull();
            changeStreamOperation.DatabaseNamespace.Should().Be(_subject.DatabaseNamespace);
            changeStreamOperation.FullDocument.Should().Be(options.FullDocument);
            changeStreamOperation.MaxAwaitTime.Should().Be(options.MaxAwaitTime);
            changeStreamOperation.MessageEncoderSettings.Should().NotBeNull();
            changeStreamOperation.Pipeline.Should().Equal(renderedPipeline);
            changeStreamOperation.ReadConcern.Should().Be(_subject.Settings.ReadConcern);
            changeStreamOperation.ResultSerializer.Should().BeOfType <ChangeStreamDocumentSerializer <BsonDocument> >();
            changeStreamOperation.ResumeAfter.Should().Be(options.ResumeAfter);
            changeStreamOperation.RetryRequested.Should().BeTrue();
            changeStreamOperation.StartAfter.Should().Be(options.StartAfter);
            changeStreamOperation.StartAtOperationTime.Should().Be(options.StartAtOperationTime);
        }