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 <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())));
}
/// <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 static async Task SubscribeToFiltered(EventStoreClient client)
{
#region stream-prefix-filtered-subscription
var prefixStreamFilter = new SubscriptionFilterOptions(StreamFilter.Prefix("test-", "other-"));
await client.SubscribeToAllAsync(
EventAppeared,
filterOptions : prefixStreamFilter);
#endregion stream-prefix-filtered-subscription
#region stream-regex-filtered-subscription
var regexStreamFilter = StreamFilter.RegularExpression(@"/invoice-\d\d\d/g");
#endregion stream-regex-filtered-subscription
}
private static async Task EventTypeRegex(EventStoreClient client)
{
#region event-type-regex
var filter = new SubscriptionFilterOptions(
EventTypeFilter.RegularExpression("^user|^company"));
#endregion event-type-regex
await client.SubscribeToAllAsync(Position.Start,
(s, e, c) => {
Console.WriteLine(
$"{e.Event.EventType} @ {e.Event.Position.PreparePosition}");
return(Task.CompletedTask);
},
filterOptions : filter
);
}
private static async Task EventTypePrefix(EventStoreClient client)
{
#region event-type-prefix
var filter = new SubscriptionFilterOptions(
EventTypeFilter.Prefix("customer-"));
#endregion event-type-prefix
await client.SubscribeToAllAsync(Position.Start,
(s, e, c) => {
Console.WriteLine(
$"{e.Event.EventType} @ {e.Event.Position.PreparePosition}");
return(Task.CompletedTask);
},
filterOptions : filter
);
}
private static async Task StreamRegex(EventStoreClient client)
{
#region stream-regex
var filter = new SubscriptionFilterOptions(
StreamFilter.RegularExpression("^account|^savings"));
#endregion stream-regex
await client.SubscribeToAllAsync(Position.Start,
(s, e, c) => {
Console.WriteLine(
$"{e.Event.EventType} @ {e.Event.Position.PreparePosition}");
return(Task.CompletedTask);
},
filterOptions : filter
);
}
private static async Task CheckpointCallback(EventStoreClient client)
{
#region checkpoint
var filter = new SubscriptionFilterOptions(
EventTypeFilter.ExcludeSystemEvents(),
checkpointReached: (s, p, c) =>
{
Console.WriteLine($"checkpoint taken at {p.PreparePosition}");
return(Task.CompletedTask);
});
#endregion checkpoint
await client.SubscribeToAllAsync(Position.Start,
(s, e, c) => {
Console.WriteLine(
$"{e.Event.EventType} @ {e.Event.Position.PreparePosition}");
return(Task.CompletedTask);
},
filterOptions : filter
);
}
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);
}
public async Task SubscribeAll_EventFilterExpression()
{
var prefixEventFilter = new SubscriptionFilterOptions(EventTypeFilter.RegularExpression("^test"));
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : prefixEventFilter);
}
public async Task SubscribeAll_EventFilterPrefix()
{
var prefixEventFilter = new SubscriptionFilterOptions(EventTypeFilter.Prefix("test-"));
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : prefixEventFilter);
}
public async Task SubscribeAll_StreamFilterExpression()
{
var prefixStreamFilter = new SubscriptionFilterOptions(StreamFilter.RegularExpression("^test|^other"));
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : prefixStreamFilter);
}
public async Task SubscribeAll_StreamFilterPrefix()
{
var prefixStreamFilter = new SubscriptionFilterOptions(StreamFilter.Prefix("test-", "other-"));
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : prefixStreamFilter);
}
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
));
}
}
