/// <summary>
/// Initializes a new instance of the <see cref="PartitionPump"/> class.
/// </summary>
///
/// <param name="eventHubClient">The client used to interact with the Azure Event Hubs service.</param>
/// <param name="consumerGroup">The name of the consumer group this partition pump is associated with. Events are read in the context of this group.</param>
/// <param name="partitionContext">The context of the Event Hub partition this partition pump is associated with. Events will be read only from this partition.</param>
/// <param name="partitionProcessor">A partition processor used to process events and errors. Its implementation must be provided by the caller.</param>
/// <param name="options">The set of options to use for this partition pump.</param>
///
internal PartitionPump(EventHubClient eventHubClient,
string consumerGroup,
PartitionContext partitionContext,
BasePartitionProcessor partitionProcessor,
EventProcessorOptions options)
{
InnerClient = eventHubClient;
ConsumerGroup = consumerGroup;
Context = partitionContext;
PartitionProcessor = partitionProcessor;
Options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="PartitionPump"/> class.
/// </summary>
///
/// <param name="eventHubClient">The client used to interact with the Azure Event Hubs service.</param>
/// <param name="consumerGroup">The name of the consumer group this partition pump is associated with. Events are read in the context of this group.</param>
/// <param name="partitionId">The identifier of the Event Hub partition this partition pump is associated with. Events will be read only from this partition.</param>
/// <param name="partitionProcessor">A partition processor used to process events and errors. Its implementation must be provided by the caller.</param>
/// <param name="options">The set of options to use for this partition pump.</param>
///
internal PartitionPump(EventHubClient eventHubClient,
string consumerGroup,
string partitionId,
IPartitionProcessor partitionProcessor,
EventProcessorOptions options)
{
InnerClient = eventHubClient;
ConsumerGroup = consumerGroup;
PartitionId = partitionId;
PartitionProcessor = partitionProcessor;
Options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
///
/// <param name="consumerGroup">The name of the consumer group this event processor is associated with. Events are read in the context of this group.</param>
/// <param name="eventHubClient">The client used to interact with the Azure Event Hubs service.</param>
/// <param name="partitionProcessorFactory">Creates an instance of a class implementing the <see cref="IPartitionProcessor" /> interface.</param>
/// <param name="partitionManager">Interacts with the storage system, dealing with ownership and checkpoints.</param>
/// <param name="options">The set of options to use for this event processor.</param>
///
/// <remarks>
/// Ownership of the <paramref name="eventHubClient" /> is assumed to be responsibility of the caller; this
/// processor will delegate operations to it, but will not perform any clean-up tasks, such as closing or
/// disposing of the instance.
/// </remarks>
///
public EventProcessor(string consumerGroup,
EventHubClient eventHubClient,
Func <PartitionContext, CheckpointManager, IPartitionProcessor> partitionProcessorFactory,
PartitionManager partitionManager,
EventProcessorOptions options = default)
{
Guard.ArgumentNotNullOrEmpty(nameof(consumerGroup), consumerGroup);
Guard.ArgumentNotNull(nameof(eventHubClient), eventHubClient);
Guard.ArgumentNotNull(nameof(partitionProcessorFactory), partitionProcessorFactory);
Guard.ArgumentNotNull(nameof(partitionManager), partitionManager);
InnerClient = eventHubClient;
ConsumerGroup = consumerGroup;
PartitionProcessorFactory = partitionProcessorFactory;
Manager = partitionManager;
Options = options?.Clone() ?? new EventProcessorOptions();
Identifier = Guid.NewGuid().ToString();
PartitionPumps = new ConcurrentDictionary <string, PartitionPump>();
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor{T}"/> class.
/// </summary>
///
/// <param name="consumerGroup">The name of the consumer group this event processor is associated with. Events are read in the context of this group.</param>
/// <param name="eventHubClient">The client used to interact with the Azure Event Hubs service.</param>
/// <param name="partitionProcessorFactory">Creates a partition processor instance for the associated <see cref="PartitionContext" />.</param>
/// <param name="partitionManager">Interacts with the storage system with responsibility for creation of checkpoints and for ownership claim.</param>
/// <param name="options">The set of options to use for this event processor.</param>
///
/// <remarks>
/// Ownership of the <paramref name="eventHubClient" /> is assumed to be responsibility of the caller; this
/// processor will delegate operations to it, but will not perform any clean-up tasks, such as closing or
/// disposing of the instance.
/// </remarks>
///
public EventProcessor(string consumerGroup,
EventHubClient eventHubClient,
Func <PartitionContext, BasePartitionProcessor> partitionProcessorFactory,
PartitionManager partitionManager,
EventProcessorOptions options = default)
{
Argument.AssertNotNullOrEmpty(consumerGroup, nameof(consumerGroup));
Argument.AssertNotNull(eventHubClient, nameof(eventHubClient));
Argument.AssertNotNull(partitionProcessorFactory, nameof(partitionProcessorFactory));
Argument.AssertNotNull(partitionManager, nameof(partitionManager));
InnerClient = eventHubClient;
ConsumerGroup = consumerGroup;
PartitionProcessorFactory = partitionProcessorFactory;
Manager = partitionManager;
Options = options?.Clone() ?? new EventProcessorOptions();
Identifier = Guid.NewGuid().ToString();
PartitionPumps = new ConcurrentDictionary <string, PartitionPump>();
}
/// <summary>
/// Creates and starts a new partition pump associated with the specified partition. Partition pumps that are overwritten by the creation
/// of a new one are properly stopped.
/// </summary>
///
/// <param name="partitionId">The identifier of the Event Hub partition the partition pump will be associated with. Events will be read only from this partition.</param>
/// <param name="initialSequenceNumber">The sequence number of the event within a partition where the partition pump should begin reading events.</param>
///
/// <returns>A task to be resolved on when the operation has completed.</returns>
///
private async Task AddOrOverwritePartitionPumpAsync(string partitionId,
long?initialSequenceNumber)
{
// Remove and stop the existing partition pump if it exists. We are not specifying any close reason because partition
// pumps only are overwritten in case of failure. In these cases, the close reason is delegated to the pump as it may
// have more information about what caused the failure.
await RemovePartitionPumpIfItExistsAsync(partitionId).ConfigureAwait(false);
// Create and start the new partition pump and add it to the dictionary.
var partitionContext = new PartitionContext(InnerClient.FullyQualifiedNamespace, InnerClient.EventHubName, ConsumerGroup, partitionId, Identifier, Manager);
try
{
BasePartitionProcessor partitionProcessor = PartitionProcessorFactory(partitionContext);
EventProcessorOptions options = Options.Clone();
// Ovewrite the initial event position in case a checkpoint exists.
if (initialSequenceNumber.HasValue)
{
options.InitialEventPosition = EventPosition.FromSequenceNumber(initialSequenceNumber.Value);
}
var partitionPump = new PartitionPump(InnerClient, ConsumerGroup, partitionContext, partitionProcessor, options);
await partitionPump.StartAsync().ConfigureAwait(false);
PartitionPumps[partitionId] = partitionPump;
}
catch (Exception)
{
// If partition pump creation fails, we'll try again on the next time this method is called. This should happen
// on the next load balancing loop as long as this instance still owns the partition.
// TODO: delegate the exception handling to an Exception Callback.
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor{T}"/> class.
/// </summary>
///
/// <param name="consumerGroup">The name of the consumer group this event processor is associated with. Events are read in the context of this group.</param>
/// <param name="eventHubClient">The client used to interact with the Azure Event Hubs service.</param>
/// <param name="partitionManager">Interacts with the storage system with responsibility for creation of checkpoints and for ownership claim.</param>
/// <param name="options">The set of options to use for this event processor.</param>
///
/// <remarks>
/// Ownership of the <paramref name="eventHubClient" /> is assumed to be responsibility of the caller; this
/// processor will delegate operations to it, but will not perform any clean-up tasks, such as closing or
/// disposing of the instance.
/// </remarks>
///
public EventProcessor(string consumerGroup,
EventHubClient eventHubClient,
PartitionManager partitionManager,
EventProcessorOptions options = default) : this(consumerGroup, eventHubClient, partitionContext => new T(), partitionManager, options)
{
}