protected override async Task <EventSubscription> Subscribe(
            Checkpoint _,
            CancellationToken cancellationToken
            )
        {
            var settings = new PersistentSubscriptionSettings(true);

            PersistentSubscription sub;

            try {
                sub = await LocalSubscribe();
            }
            catch (PersistentSubscriptionNotFoundException) {
                await _persistentSubscriptionsClient.CreateAsync(
                    _stream,
                    SubscriptionId,
                    settings,
                    cancellationToken : cancellationToken
                    );

                sub = await LocalSubscribe();
            }

            return(new EventSubscription(SubscriptionId, new Stoppable(() => sub.Dispose())));

            void HandleDrop(PersistentSubscription __, SubscriptionDroppedReason reason, Exception?exception)
            => Dropped(EsdbMappings.AsDropReason(reason), exception);

            async Task HandleEvent(
                PersistentSubscription subscription,
                ResolvedEvent re,
                int?retryCount,
                CancellationToken ct
                )
            {
                try {
                    await Handler(AsReceivedEvent(re), ct);

                    await subscription.Ack(re);
                }
                catch (Exception e) {
                    await subscription.Nack(PersistentSubscriptionNakEventAction.Retry, e.Message, re);
                }
            }

            Task <PersistentSubscription> LocalSubscribe()
            => _persistentSubscriptionsClient.SubscribeAsync(
                _stream,
                SubscriptionId,
                HandleEvent,
                HandleDrop,
                cancellationToken: cancellationToken
                );
Exemplo n.º 2
0
        protected override async Task <EventSubscription> Subscribe(
            Checkpoint checkpoint,
            CancellationToken cancellationToken
            )
        {
            var subTask = checkpoint.Position == null
                ? EventStoreClient.SubscribeToStreamAsync(
                _options.StreamName,
                HandleEvent,
                _options.ResolveLinkTos,
                HandleDrop,
                _options.ConfigureOperation,
                _options.Credentials,
                cancellationToken
                )
                : EventStoreClient.SubscribeToStreamAsync(
                _options.StreamName,
                StreamPosition.FromInt64((long)checkpoint.Position),
                HandleEvent,
                _options.ResolveLinkTos,
                HandleDrop,
                _options.ConfigureOperation,
                _options.Credentials,
                cancellationToken
                );

            var sub = await subTask.Ignore();

            return(new EventSubscription(SubscriptionId, new Stoppable(() => sub.Dispose())));

            async Task HandleEvent(EventStore.Client.StreamSubscription _, ResolvedEvent re, CancellationToken ct)
            {
                await Handler(AsReceivedEvent(re), ct).Ignore();
            }

            void HandleDrop(EventStore.Client.StreamSubscription _, SubscriptionDroppedReason reason, Exception?ex)
            => Dropped(EsdbMappings.AsDropReason(reason), ex);

            ReceivedEvent AsReceivedEvent(ResolvedEvent re)
            {
                var evt = DeserializeData(
                    re.Event.ContentType,
                    re.Event.EventType,
                    re.Event.Data,
                    re.Event.EventStreamId,
                    re.Event.EventNumber
                    );

                return(new ReceivedEvent(
                           re.Event.EventId.ToString(),
                           re.Event.EventType,
                           re.Event.ContentType,
                           re.Event.Position.CommitPosition,
                           re.Event.EventNumber,
                           re.Event.EventStreamId,
                           re.Event.EventNumber,
                           re.Event.Created,
                           evt
                           // re.Event.Metadata
                           ));
            }
        }
Exemplo n.º 3
0
        protected override async Task <EventSubscription> Subscribe(
            Checkpoint _,
            CancellationToken cancellationToken
            )
        {
            var settings = _options.SubscriptionSettings ?? new PersistentSubscriptionSettings(_options.ResolveLinkTos);
            var autoAck  = _options.AutoAck;

            PersistentSubscription sub;

            try {
                sub = await LocalSubscribe().Ignore();
            }
            catch (PersistentSubscriptionNotFoundException) {
                await _subscriptionClient.CreateAsync(
                    _options.Stream,
                    SubscriptionId,
                    settings,
                    _options.Credentials,
                    cancellationToken
                    ).Ignore();

                sub = await LocalSubscribe().Ignore();
            }

            return(new EventSubscription(SubscriptionId, new Stoppable(() => sub.Dispose())));

            void HandleDrop(PersistentSubscription __, SubscriptionDroppedReason reason, Exception?exception)
            => Dropped(EsdbMappings.AsDropReason(reason), exception);

            async Task HandleEvent(
                PersistentSubscription subscription,
                ResolvedEvent re,
                int?retryCount,
                CancellationToken ct
                )
            {
                var receivedEvent = AsReceivedEvent(re);

                try {
                    await Handler(receivedEvent, ct).Ignore();

                    if (!autoAck)
                    {
                        await subscription.Ack(re).Ignore();
                    }
                }
                catch (Exception e) {
                    await _handleEventProcessingFailure(EventStoreClient, subscription, re, e).Ignore();
                }
            }

            Task <PersistentSubscription> LocalSubscribe()
            => _subscriptionClient.SubscribeAsync(
                _options.Stream,
                SubscriptionId,
                HandleEvent,
                HandleDrop,
                _options.Credentials,
                _options.BufferSize,
                _options.AutoAck,
                cancellationToken
                );

            ReceivedEvent AsReceivedEvent(ResolvedEvent re)
            {
                var evt = DeserializeData(
                    re.Event.ContentType,
                    re.Event.EventType,
                    re.Event.Data,
                    re.OriginalStreamId,
                    re.Event.Position.CommitPosition
                    );

                return(new ReceivedEvent(
                           re.Event.EventId.ToString(),
                           re.Event.EventType,
                           re.Event.ContentType,
                           re.Event.Position.CommitPosition,
                           re.Event.Position.CommitPosition,
                           re.OriginalStreamId,
                           re.Event.EventNumber,
                           re.Event.Created,
                           evt
                           // re.Event.Metadata
                           ));
            }
        }
Exemplo n.º 4
0
        protected override async Task <EventSubscription> Subscribe(
            Checkpoint checkpoint,
            CancellationToken cancellationToken
            )
        {
            var filterOptions = new SubscriptionFilterOptions(
                _eventFilter,
                10,
                (_, p, ct) => StoreCheckpoint(new EventPosition(p.CommitPosition, DateTime.Now), ct)
                );

            var subTask = checkpoint.Position != null
                ? EventStoreClient.SubscribeToAllAsync(
                new Position(checkpoint.Position.Value, checkpoint.Position.Value),
                HandleEvent,
                false,
                HandleDrop,
                filterOptions,
                _options.ConfigureOperation,
                _options.Credentials,
                cancellationToken
                )
                : EventStoreClient.SubscribeToAllAsync(
                HandleEvent,
                false,
                HandleDrop,
                filterOptions,
                _options.ConfigureOperation,
                _options.Credentials,
                cancellationToken
                );

            var sub = await subTask.Ignore();

            return(new EventSubscription(SubscriptionId, new Stoppable(() => sub.Dispose())));

            Task HandleEvent(EventStore.Client.StreamSubscription _, ResolvedEvent re, CancellationToken ct)
            => Handler(AsReceivedEvent(re), ct);

            void HandleDrop(EventStore.Client.StreamSubscription _, SubscriptionDroppedReason reason, Exception?ex)
            => Dropped(EsdbMappings.AsDropReason(reason), ex);

            ReceivedEvent AsReceivedEvent(ResolvedEvent re)
            {
                var evt = DeserializeData(
                    re.Event.ContentType,
                    re.Event.EventType,
                    re.Event.Data,
                    re.Event.EventStreamId,
                    re.Event.EventNumber
                    );

                return(new ReceivedEvent(
                           re.Event.EventId.ToString(),
                           re.Event.EventType,
                           re.Event.ContentType,
                           re.Event.Position.CommitPosition,
                           re.Event.Position.CommitPosition,
                           re.OriginalStreamId,
                           re.Event.EventNumber,
                           re.Event.Created,
                           evt
                           // re.Event.Metadata
                           ));
            }
        }