protected override async Task <EventSubscription> Subscribe(
Checkpoint checkpoint,
CancellationToken cancellationToken)
{
var filterOptions = new SubscriptionFilterOptions(
EventTypeFilter.ExcludeSystemEvents(),
10,
(_, p, ct) =>
StoreCheckpoint(
new EventPosition(p.CommitPosition, DateTime.UtcNow),
ct));
var(_, position) = checkpoint;
var subscribeTask = position != null
? EventStoreClient.SubscribeToAllAsync(
new Position(
position.Value,
position.Value),
TransactionalHandler,
false,
HandleDrop,
filterOptions,
cancellationToken : cancellationToken)
: EventStoreClient.SubscribeToAllAsync(
TransactionalHandler,
false,
HandleDrop,
filterOptions,
cancellationToken: cancellationToken);
var sub = await subscribeTask.NoContext();
return(new EventSubscription(SubscriptionId,
new Stoppable(() => sub.Dispose())));
}
public async Task SubscribeAll_EventFilterSystem()
{
var typeEventFilter = new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents(),
checkpointInterval: 5, checkpointReached: SubscribeFilterReturn);
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : typeEventFilter);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var eventStoreClient = _serviceProvider.GetRequiredService <EventStoreClient>();
await eventStoreClient.SubscribeToAllAsync(
await GetStartPosition(),
HandleEvent,
filterOptions : new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
cancellationToken : stoppingToken
);
}
/// <summary>
/// Start the subscription to EventStoreDB
/// </summary>
/// <param name="cancellationToken"></param>
public async Task Start(CancellationToken cancellationToken)
{
var filter = new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents());
_subscription = await _client.SubscribeToAllAsync(Position.Start,
EventAppeared,
subscriptionDropped : SubscriptionDropped,
filterOptions : filter,
resolveLinkTos : true,
cancellationToken : cancellationToken);
}
private async Task Subscribe(CancellationToken cancellationToken)
{
if (Interlocked.CompareExchange(ref _subscribed, 1, 0) == 1)
{
return;
}
var registration = _stoppedRegistration;
if (registration != null)
{
await registration.Value.DisposeAsync();
}
Interlocked.Exchange(ref _subscription, await _eventStore.SubscribeToAllAsync(
Position.Start,
ProjectAsync,
subscriptionDropped: (_, reason, ex) => {
if (reason == SubscriptionDroppedReason.Disposed)
{
return;
}
Log.Error(ex, "Subscription dropped: {reason}", reason);
},
filterOptions: new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
userCredentials: new UserCredentials("admin", "changeit"),
cancellationToken: _stopped.Token));
_stoppedRegistration = _stopped.Token.Register(_subscription.Dispose);
Task ProjectAsync(StreamSubscription s, ResolvedEvent e, CancellationToken ct)
{
var type = _messageTypeMapper.Map(e.Event.EventType);
if (type == null)
{
return(Task.CompletedTask);
}
var message = JsonSerializer.Deserialize(
e.Event.Data.Span, type, TransactoSerializerOptions.Events);
return(_projector.ProjectAsync(_target, Envelope.Create(message, e.OriginalEvent.Position), ct));
}
}
protected override async ValueTask Subscribe(CancellationToken cancellationToken)
{
var filterOptions = new SubscriptionFilterOptions(
Options.EventFilter ?? EventTypeFilter.ExcludeSystemEvents(),
Options.CheckpointInterval,
async(_, p, ct) => {
// This doesn't allow to report tie time gap
LastProcessed = new EventPosition(p.CommitPosition, DateTime.Now);
await StoreCheckpoint(LastProcessed, ct).NoContext();
}
);
var(_, position) = await GetCheckpoint(cancellationToken).NoContext();
var fromAll = position == null ? FromAll.Start : FromAll.After(new Position(position.Value, position.Value));
Subscription = await EventStoreClient.SubscribeToAllAsync(
fromAll,
HandleEvent,
Options.ResolveLinkTos,
HandleDrop,
filterOptions,
Options.Credentials,
cancellationToken
).NoContext();
async Task HandleEvent(
global::EventStore.Client.StreamSubscription _,
ResolvedEvent re,
CancellationToken ct
)
=> await HandleInternal(CreateContext(re, ct)).NoContext();
void HandleDrop(
global::EventStore.Client.StreamSubscription _,
SubscriptionDroppedReason reason,
Exception?ex
)
=> Dropped(EsdbMappings.AsDropReason(reason), ex);
}
/// <summary>
/// Creates EventStoreDB catch-up subscription service for $all
/// </summary>
/// <param name="eventStoreClient"></param>
/// <param name="options"></param>
/// <param name="checkpointStore">Checkpoint store instance</param>
/// <param name="eventSerializer">Event serializer instance</param>
/// <param name="eventHandlers">Collection of event handlers</param>
/// <param name="loggerFactory">Optional: logger factory</param>
/// <param name="eventFilter">Optional: server-side event filter</param>
/// <param name="measure">Optional: gap measurement for metrics</param>
public AllStreamSubscription(
EventStoreClient eventStoreClient,
AllStreamSubscriptionOptions options,
ICheckpointStore checkpointStore,
IEnumerable <IEventHandler> eventHandlers,
IEventSerializer?eventSerializer = null,
ILoggerFactory?loggerFactory = null,
IEventFilter?eventFilter = null,
ISubscriptionGapMeasure?measure = null
) : base(
eventStoreClient,
options,
checkpointStore,
eventHandlers,
eventSerializer,
loggerFactory,
measure
)
{
_eventFilter = eventFilter ?? EventTypeFilter.ExcludeSystemEvents();
_options = options;
}
private async Task Subscribe(CancellationToken cancellationToken)
{
if (Interlocked.CompareExchange(ref _subscribed, 1, 0) == 1)
{
return;
}
var registration = _stoppedRegistration;
if (registration != null)
{
await registration.Value.DisposeAsync();
}
var projections = await ReadCheckpoints();
var projector = new CheckpointAwareProjector(_connectionFactory, _messageTypeMap, projections);
var checkpoint = projections.Select(x => x.checkpoint).Min();
Interlocked.Exchange(ref _subscription, await _eventStore.SubscribeToAllAsync(checkpoint,
projector.ProjectAsync,
subscriptionDropped: (_, reason, ex) => {
if (reason == SubscriptionDroppedReason.Disposed)
{
return;
}
if (Interlocked.Increment(ref _retryCount) == 5)
{
Log.Error(ex, "Subscription dropped: {reason}", reason);
return;
}
Log.Warning(ex, "Subscription dropped: {reason}; resubscribing...", reason);
Interlocked.Exchange(ref _subscribed, 0);
Task.Run(() => Subscribe(cancellationToken), cancellationToken);
},
filterOptions: new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
userCredentials: new UserCredentials("admin", "changeit"),
cancellationToken: _stopped.Token));
_stoppedRegistration = _stopped.Token.Register(_subscription.Dispose);
async ValueTask <(NpgsqlProjection projection, Position checkpoint)[]> ReadCheckpoints()
public async Task subscribe_to_all_filtered(int iteration)
{
var streamName = $"{_fixture.GetStreamName()}_{iteration}";
using var _ = await _fixture.Client.SubscribeToAllAsync((_, e, ct) => EventAppeared (e, streamName),
subscriptionDropped : SubscriptionDropped,
filterOptions : new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()));
await AppendEvents(streamName);
await _completed.Task.WithTimeout();
}
private async Task Subscribe(CancellationToken cancellationToken)
{
if (Interlocked.CompareExchange(ref _subscribed, 1, 0) == 1)
{
return;
}
var registration = _stoppedRegistration;
if (registration != null)
{
await registration.Value.DisposeAsync();
}
Interlocked.Exchange(ref _subscription, await Subscribe());
_stoppedRegistration = _stopped.Token.Register(_subscription.Dispose);
async Task <StreamSubscription> Subscribe()
{
await using var result = _eventStore.ReadStreamAsync(Direction.Backwards, _checkpointStreamName,
StreamPosition.End, cancellationToken: cancellationToken);
_checkpoint = await result.ReadState == ReadState.StreamNotFound
? Checkpoint.None
: await result.Select(e => new Checkpoint(e.Event.Data)).FirstOrDefaultAsync(cancellationToken);
return(await _eventStore.SubscribeToAllAsync(
_checkpoint.ToEventStorePosition(), HandleAsync, subscriptionDropped : (_, reason, _) => {
if (reason == SubscriptionDroppedReason.Disposed)
{
return;
}
//Log.Error(ex, "Subscription dropped: {reason}", reason);
},
filterOptions : new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
userCredentials : new UserCredentials("admin", "changeit"),
cancellationToken : _stopped.Token));
}
async Task HandleAsync(StreamSubscription s, ResolvedEvent e, CancellationToken ct)
{
if (!_messageTypeMapper.TryMap(e.Event.EventType, out var type))
{
return;
}
var message = JsonSerializer.Deserialize(e.Event.Data.Span, type, TransactoSerializerOptions.Events) !;
_checkpoint = await _dispatcher.Handle(message, ct);
if (_checkpoint == Checkpoint.None)
{
return;
}
await _eventStore.AppendToStreamAsync(_checkpointStreamName, StreamState.Any, new[] {
new EventData(Uuid.NewUuid(), "checkpoint", _checkpoint.Memory,
contentType: "application/octet-stream")
}, cancellationToken : ct);
}
}
public async Task max_count_is_respected()
{
var streamName = _fixture.GetStreamName();
const int count = 20;
const ulong maxCount = (ulong)count / 2;
await _fixture.Client.AppendToStreamAsync(streamName, AnyStreamRevision.NoStream,
_fixture.CreateTestEvents(count));
var events = await _fixture.Client.ReadAllAsync(Direction.Forwards, Position.Start, maxCount,
filterOptions : new FilterOptions(EventTypeFilter.ExcludeSystemEvents(40)),
userCredentials : TestCredentials.Root)
.Take(count)
.ToArrayAsync();
Assert.Equal(maxCount, (ulong)events.Length);
}
private async Task Subscribe(CancellationToken cancellationToken)
{
if (Interlocked.CompareExchange(ref _subscribed, 1, 0) == 1)
{
return;
}
var registration = _stoppedRegistration;
if (registration != null)
{
await registration.Value.DisposeAsync();
}
var projections = await GetProjectors();
var projector = new CheckpointAwareProjector(_streamStore, _messageTypeMap, projections);
var checkpoint = projections.Select(x => x.Checkpoint).Min();
Interlocked.Exchange(ref _subscription, await _eventStore.SubscribeToAllAsync(checkpoint,
projector.ProjectAsync,
subscriptionDropped: (_, reason, ex) => {
if (reason == SubscriptionDroppedReason.Disposed)
{
return;
}
if (Interlocked.Increment(ref _retryCount) == 5)
{
Log.Error(ex, "Subscription dropped: {reason}", reason);
return;
}
Log.Warning(ex, "Subscription dropped: {reason}; resubscribing...", reason);
Interlocked.Exchange(ref _subscribed, 0);
Task.Run(() => Subscribe(cancellationToken), cancellationToken);
},
filterOptions: new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
userCredentials: new UserCredentials("admin", "changeit"),
cancellationToken: _stopped.Token));
_stoppedRegistration = _stopped.Token.Register(_subscription.Dispose);
Task <CheckpointedProjector[]> GetProjectors() => Task.WhenAll(Array.ConvertAll(_projections,
async projection => new CheckpointedProjector(
new Projector <IStreamStore>(Resolve.WhenAssignableToHandlerMessageType(projection.Handlers)),
await projection.ReadCheckpoint(_streamStore, cancellationToken))));
}
