/// <summary>
/// Creates EventStoreDB catch-up subscription service for a given stream
/// </summary>
/// <param name="client"></param>
/// <param name="checkpointStore">Checkpoint store instance</param>
/// <param name="options">Subscription options</param>
/// <param name="consumePipe"></param>
public StreamSubscription(
EventStoreClient client,
StreamSubscriptionOptions options,
ICheckpointStore checkpointStore,
ConsumePipe consumePipe
) : base(client, options, checkpointStore, consumePipe)
=> Ensure.NotEmptyString(options.StreamName);
/// <summary>
/// Creates RabbitMQ subscription service instance
/// </summary>
/// <param name="connectionFactory"></param>
/// <param name="options"></param>
/// <param name="consumePipe"></param>
public RabbitMqSubscription(
ConnectionFactory connectionFactory,
IOptions <RabbitMqSubscriptionOptions> options,
ConsumePipe consumePipe
) : this(connectionFactory, options.Value, consumePipe)
{
}
public AllPersistentSubscription(
EventStoreClient eventStoreClient,
AllPersistentSubscriptionOptions options,
ConsumePipe consumePipe
) : base(eventStoreClient, options, consumePipe)
{
}
public StreamPersistentSubscription(
EventStoreClient eventStoreClient,
StreamPersistentSubscriptionOptions options,
ConsumePipe consumePipe
) : base(eventStoreClient, options, consumePipe)
{
Ensure.NotEmptyString(options.StreamName);
}
/// <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="consumePipe"></param>
public AllStreamSubscription(
EventStoreClient eventStoreClient,
AllStreamSubscriptionOptions options,
ICheckpointStore checkpointStore,
ConsumePipe consumePipe
) : base(eventStoreClient, options, checkpointStore, consumePipe)
{
}
public static IEventHandler[]? GetHandlers(this ConsumePipe pipe)
{
var filters = pipe.GetPrivateMember <LinkedList <Filter> >("_filters");
var consumeFilter = filters !.Last().FilterInstance;
var consumer = consumeFilter.GetPrivateMember("_consumer") !;
var handlers = consumer.GetPrivateMember <IEventHandler[]>("_eventHandlers");
return(handlers);
}
protected EventStoreCatchUpSubscriptionBase(
EventStoreClient eventStoreClient,
T options,
ICheckpointStore checkpointStore,
ConsumePipe consumePipe
) : base(eventStoreClient, options, ConfigurePipe(consumePipe, options))
{
CheckpointStore = Ensure.NotNull(checkpointStore);
CheckpointCommitHandler = new CheckpointCommitHandler(options.SubscriptionId, checkpointStore, 10);
}
/// <summary>
/// Creates RabbitMQ subscription service instance
/// </summary>
/// <param name="connectionFactory">RabbitMQ connection factory</param>
/// <param name="exchange">Exchange to consume events from, the queue will get bound to this exchange</param>
/// <param name="subscriptionId">Subscription ID</param>
/// <param name="consumePipe"></param>
/// <param name="eventSerializer">Event serializer instance</param>
public RabbitMqSubscription(
ConnectionFactory connectionFactory,
string exchange,
string subscriptionId,
ConsumePipe consumePipe,
IEventSerializer?eventSerializer = null
) : this(
connectionFactory,
new RabbitMqSubscriptionOptions
{
Exchange = exchange, SubscriptionId = subscriptionId, EventSerializer = eventSerializer
},
consumePipe
)
{
}
/// <summary>
/// Creates EventStoreDB persistent subscription service for a given stream
/// </summary>
/// <param name="eventStoreClient">EventStoreDB gRPC client instance</param>
/// <param name="subscriptionId">Subscription ID</param>
/// <param name="consumerPipe"></param>
/// <param name="eventSerializer">Event serializer instance</param>
/// <param name="metaSerializer"></param>
public AllPersistentSubscription(
EventStoreClient eventStoreClient,
string subscriptionId,
ConsumePipe consumerPipe,
IEventSerializer?eventSerializer = null,
IMetadataSerializer?metaSerializer = null
) : this(
eventStoreClient,
new AllPersistentSubscriptionOptions {
SubscriptionId = subscriptionId,
EventSerializer = eventSerializer,
MetadataSerializer = metaSerializer
},
consumerPipe
)
{
}
/// <summary>
/// Creates a Google PubSub subscription service
/// </summary>
/// <param name="projectId">GCP project ID</param>
/// <param name="topicId"></param>
/// <param name="subscriptionId">Google PubSub subscription ID (within the project), which must already exist</param>
/// <param name="consumePipe"></param>
/// <param name="eventSerializer">Event serializer instance</param>
public GooglePubSubSubscription(
string projectId,
string topicId,
string subscriptionId,
ConsumePipe consumePipe,
IEventSerializer?eventSerializer = null
) : this(
new PubSubSubscriptionOptions {
SubscriptionId = subscriptionId,
ProjectId = projectId,
TopicId = topicId,
EventSerializer = eventSerializer
},
consumePipe
)
{
}
/// <summary>
/// Creates a Google PubSub subscription service
/// </summary>
/// <param name="options">Subscription options <see cref="PubSubSubscriptionOptions"/></param>
/// <param name="consumePipe"></param>
public GooglePubSubSubscription(PubSubSubscriptionOptions options, ConsumePipe consumePipe)
: base(options, consumePipe)
{
_failureHandler = Ensure.NotNull(options).FailureHandler ?? DefaultEventProcessingErrorHandler;
_subscriptionName = SubscriptionName.FromProjectSubscription(
Ensure.NotEmptyString(options.ProjectId),
Ensure.NotEmptyString(options.SubscriptionId)
);
_topicName = TopicName.FromProjectTopic(options.ProjectId, Ensure.NotEmptyString(options.TopicId));
if (options.FailureHandler != null && !options.ThrowOnError)
{
Log.ThrowOnErrorIncompatible(SubscriptionId);
}
}
/// <summary>
/// Creates EventStoreDB catch-up subscription service for $all
/// </summary>
/// <param name="eventStoreClient">EventStoreDB gRPC client instance</param>
/// <param name="subscriptionId">Subscription ID</param>
/// <param name="checkpointStore">Checkpoint store instance</param>
/// <param name="consumePipe"></param>
/// <param name="eventSerializer">Event serializer instance</param>
/// <param name="metaSerializer"></param>
/// <param name="eventFilter">Optional: server-side event filter</param>
public AllStreamSubscription(
EventStoreClient eventStoreClient,
string subscriptionId,
ICheckpointStore checkpointStore,
ConsumePipe consumePipe,
IEventSerializer?eventSerializer = null,
IMetadataSerializer?metaSerializer = null,
IEventFilter?eventFilter = null
) : this(
eventStoreClient,
new AllStreamSubscriptionOptions {
SubscriptionId = subscriptionId,
EventSerializer = eventSerializer,
MetadataSerializer = metaSerializer,
EventFilter = eventFilter
},
checkpointStore,
consumePipe
)
{
}
/// <summary>
/// Creates RabbitMQ subscription service instance
/// </summary>
/// <param name="connectionFactory"></param>
/// <param name="options"></param>
/// <param name="consumePipe"></param>
public RabbitMqSubscription(
ConnectionFactory connectionFactory,
RabbitMqSubscriptionOptions options,
ConsumePipe consumePipe
)
: base(
Ensure.NotNull(options),
consumePipe.AddFilterFirst(new ConcurrentFilter(options.ConcurrencyLimit, options.ConcurrencyLimit * 10))
)
{
_failureHandler = options.FailureHandler ?? DefaultEventFailureHandler;
_connection = Ensure.NotNull(connectionFactory).CreateConnection();
_channel = _connection.CreateModel();
var prefetch = Options.PrefetchCount > 0 ? Options.PrefetchCount : Options.ConcurrencyLimit * 2;
_channel.BasicQos(0, (ushort)prefetch, false);
if (options.FailureHandler != null && !options.ThrowOnError)
{
Log.ThrowOnErrorIncompatible(SubscriptionId);
}
}
/// <summary>
/// Creates EventStoreDB catch-up subscription service for a given stream
/// </summary>
/// <param name="eventStoreClient">EventStoreDB gRPC client instance</param>
/// <param name="streamName">Name of the stream to receive events from</param>
/// <param name="subscriptionId">Subscription ID</param>
/// <param name="checkpointStore">Checkpoint store instance</param>
/// <param name="consumerPipe"></param>
/// <param name="eventSerializer">Event serializer instance</param>
/// <param name="metaSerializer"></param>
/// <param name="throwOnError"></param>
public StreamSubscription(
EventStoreClient eventStoreClient,
StreamName streamName,
string subscriptionId,
ICheckpointStore checkpointStore,
ConsumePipe consumerPipe,
IEventSerializer?eventSerializer = null,
IMetadataSerializer?metaSerializer = null,
bool throwOnError = false
) : this(
eventStoreClient,
new StreamSubscriptionOptions {
StreamName = streamName,
SubscriptionId = subscriptionId,
ThrowOnError = throwOnError,
EventSerializer = eventSerializer,
MetadataSerializer = metaSerializer
},
checkpointStore,
consumerPipe
)
{
}
public TestSub(TestOptions options, ConsumePipe consumePipe) : base(options, consumePipe) { }
protected EventStoreSubscriptionBase(EventStoreClient eventStoreClient, T options, ConsumePipe consumePipe)
: base(options, consumePipe)
{
EventStoreClient = Ensure.NotNull(eventStoreClient);
_metaSerializer = Options.MetadataSerializer ?? DefaultMetadataSerializer.Instance;
}
public static ConsumePipe AddDefaultConsumer(this ConsumePipe consumePipe, params IEventHandler[] handlers) => consumePipe.AddFilterLast(new ConsumerFilter(new DefaultConsumer(handlers)));
// It's not ideal, but for now if there's any filter added on top of the default one, // we won't add the concurrent filter, so it won't clash with any custom setup static ConsumePipe ConfigurePipe(ConsumePipe pipe, CatchUpSubscriptionOptions options) => pipe.RegisteredFilters.All(x => x is not ConcurrentFilter)
protected PersistentSubscriptionBase(EventStoreClient eventStoreClient, T options, ConsumePipe consumePipe)
: base(eventStoreClient, options, consumePipe)
{
var settings = eventStoreClient.GetSettings().Copy();
var opSettings = settings.OperationOptions.Clone();
settings.OperationOptions = opSettings;
SubscriptionClient = new EventStorePersistentSubscriptionsClient(settings);
_handleEventProcessingFailure = options.FailureHandler ?? DefaultEventProcessingFailureHandler;
if (options.FailureHandler != null && !options.ThrowOnError)
{
Log.ThrowOnErrorIncompatible(SubscriptionId);
}
}
