public EventReceiver(IEventProcessorFactory processorFactory, string eventHubName, string consumerGroupName,
string eventHubConnectionString, string checkpointConnectionString)
{
_processorFactory = processorFactory;
_host = new EventProcessorHost(Environment.MachineName, eventHubName, consumerGroupName,
eventHubConnectionString, checkpointConnectionString);
}
/// <summary>
/// This registers <see cref="IEventProcessorFactory"/> implementation with the host which is used to create an instance of
/// <see cref="IEventProcessor"/> when it takes ownership of a partition. This also starts the host and causes it to start participating
/// in the partition distribution process.
/// </summary>
/// <param name="factory">Instance of <see cref="IEventProcessorFactory"/> implementation.</param>
/// <returns>A task to indicate EventProcessorHost instance is started.</returns>
public Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory)
{
var epo = EventProcessorOptions.DefaultOptions;
epo.ReceiveTimeout = TimeSpan.MinValue;
return(RegisterEventProcessorFactoryAsync(factory, epo));
}
public AgentTest()
{
var blobStorageConfigMock = new Mock <IBlobStorageConfig>();
this.logMock = new Mock <ILogger>();
this.deviceGroupsWriterMock = new Mock <IDeviceGroupsWriter>();
this.deviceGroupsClientMock = new Mock <IDeviceGroupsClient>();
this.eventProcessorHostWrapperMock = new Mock <IEventProcessorHostWrapper>();
var servicesConfigMock = new Mock <IServicesConfig>();
servicesConfigMock.Setup(x => x.EventHubCheckpointTimeMs).Returns(60000);
this.eventHubStatusMock = new Mock <IEventHubStatus>();
this.eventProcessorFactory = new DeviceEventProcessorFactory(this.eventHubStatusMock.Object, servicesConfigMock.Object, this.logMock.Object);
this.threadMock = new Mock <IThreadWrapper>();
this.deviceGroupsAgent = new Agent(
this.deviceGroupsWriterMock.Object,
this.deviceGroupsClientMock.Object,
this.eventProcessorHostWrapperMock.Object,
this.eventProcessorFactory,
this.eventHubStatusMock.Object,
servicesConfigMock.Object,
blobStorageConfigMock.Object,
this.logMock.Object,
this.threadMock.Object);
}
public ConfigurationBuilder(Configuration copyFrom)
{
_allAttributesPrivate = copyFrom.AllAttributesPrivate;
_baseUri = copyFrom.BaseUri;
_diagnosticOptOut = copyFrom.DiagnosticOptOut;
_diagnosticRecordingInterval = copyFrom.DiagnosticRecordingInterval;
_eventCapacity = copyFrom.EventCapacity;
_eventFlushInterval = copyFrom.EventFlushInterval;
_eventProcessorFactory = copyFrom.EventProcessorFactory;
#pragma warning disable 618
_eventSamplingInterval = copyFrom.EventSamplingInterval;
#pragma warning restore 618
_eventsUri = copyFrom.EventsUri;
_featureStore = copyFrom.FeatureStore;
_featureStoreFactory = copyFrom.FeatureStoreFactory;
_httpClientHandler = copyFrom.HttpClientHandler;
_httpClientTimeout = copyFrom.HttpClientTimeout;
_inlineUsersInEvents = copyFrom.InlineUsersInEvents;
_isStreamingEnabled = copyFrom.IsStreamingEnabled;
_offline = copyFrom.Offline;
_pollingInterval = copyFrom.PollingInterval;
_privateAttributeNames = copyFrom.PrivateAttributeNames is null ? null :
new HashSet <string>(copyFrom.PrivateAttributeNames);
_readTimeout = copyFrom.ReadTimeout;
_reconnectTime = copyFrom.ReconnectTime;
_sdkKey = copyFrom.SdkKey;
_startWaitTime = copyFrom.StartWaitTime;
_streamUri = copyFrom.StreamUri;
_updateProcessorFactory = copyFrom.UpdateProcessorFactory;
_useLdd = copyFrom.UseLdd;
_userKeysCapacity = copyFrom.UserKeysCapacity;
_userKeysFlushInterval = copyFrom.UserKeysFlushInterval;
_wrapperName = copyFrom.WrapperName;
_wrapperVersion = copyFrom.WrapperVersion;
}
public async Task <IEventProcessorFactory> UnregisterEventMessageConsumerAsync(string name)
{
ConsumerConfigurationsOptions consumerConfiguration = GetConsumerConfiguration(name);
List <EventProcessorHost> eventProcessorHostListRegistedList = EventProcessorHostList.Where(s => s.EventHubPath == consumerConfiguration.EventHubName).ToList();
IEventProcessorFactory returns = null;
if (eventProcessorHostListRegistedList != null && eventProcessorHostListRegistedList.Any())
{
foreach (var eventProcessorHostListRegisted in eventProcessorHostListRegistedList)
{
try
{
await eventProcessorHostListRegisted.UnregisterEventProcessorAsync();
EventProcessorHostList.Remove(eventProcessorHostListRegisted);
returns = EventProcessorFactoryList[name];
EventProcessorFactoryList.Remove(name);
}
catch (Exception ex)
{
}
}
}
return(returns);
}
public Processor(int eventBatchMaximumCount, string consumerGroup, string connectionString, string eventHubName, EventProcessorOptions options, IEventProcessorFactory processorFactory, bool invokeProcessorAfterRecieveTimeout, Action <ExceptionReceivedEventArgs> exceptionHandler, BlobsCheckpointStore checkpointStore) : base(eventBatchMaximumCount, consumerGroup, connectionString, eventHubName, options)
{
ProcessorFactory = processorFactory;
InvokeProcessorAfterRecieveTimeout = invokeProcessorAfterRecieveTimeout;
ExceptionHandler = exceptionHandler;
LeaseInfos = new ConcurrentDictionary <string, LeaseInfo>();
CheckpointStore = checkpointStore;
}
public async Task StartProcessingAsync(
IEventProcessorFactory processorFactory,
BlobsCheckpointStore checkpointStore,
CancellationToken cancellationToken)
{
_processorFactory = processorFactory;
_checkpointStore = checkpointStore;
await StartProcessingAsync(cancellationToken).ConfigureAwait(false);
}
public EventReceiver(IEventHubBuilder builder, string eventHubName, string consumerName)
{
_builder = builder;
_eventHubName = eventHubName;
_consumerName = consumerName;
_callback = new EventCallback(EventReceived);
_eventProcessorHost = _builder.CreateEventProcessorHost(_eventHubName, _consumerName).Result;
_eventProcessorFactory = new AzureEventProcessorFactory(Callback);
}
public IotHubListener(
IEventProcessorFactory iotHubEventProcessorFactory,
IEventProcessorHostConfig eventProcessorHostConfig,
IOptions <EventProcessorOptions> eventProcessorOptions)
{
this.iotHubEventProcessorFactory = iotHubEventProcessorFactory;
this.eventProcessorHostConfig = eventProcessorHostConfig;
this.eventProcessorOptions = eventProcessorOptions?.Value;
}
public EventHubProcessorHost(IEventProcessorFactory eventProcessorFactory, string serviceBusConnectionString,
string storageConnectionString, string eventHubName, ILogger logger)
{
_eventProcessorFactory = eventProcessorFactory;
_serviceBusConnectionString = serviceBusConnectionString;
_storageConnectionString = storageConnectionString;
_eventHubName = eventHubName;
_logger = logger;
}
public async Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory, int maxBatchSize, bool invokeProcessorAfterReceiveTimeout, EventProcessorOptions options)
{
if (CurrentProcessor != null)
{
throw new InvalidOperationException("Processor has already been started");
}
CurrentProcessor = new Processor(maxBatchSize, ConsumerGroupName, EventHubConnectionString, LegacyCheckpointStorageBlobPrefix, EventHubPath, options, factory, invokeProcessorAfterReceiveTimeout, ExceptionHandler, new BlobContainerClient(StorageConnectionString, LeaseContainerName));
await CurrentProcessor.StartProcessingAsync().ConfigureAwait(false);
}
public Agent(ILogger logger,
IServicesConfig servicesConfig,
IEventProcessorHostWrapper eventProcessorHostWrapper,
IEventProcessorFactory actionsEventProcessorFactory)
{
this.logger = logger;
this.servicesConfig = servicesConfig;
this.actionsEventProcessorFactory = actionsEventProcessorFactory;
this.eventProcessorHostWrapper = eventProcessorHostWrapper;
}
/// <summary>
/// Create host wrapper
/// </summary>
/// <param name="factory"></param>
/// <param name="config"></param>
/// <param name="logger"></param>
/// <param name="checkpoint"></param>
/// <param name="lease"></param>
public EventProcessorHost(IEventProcessorFactory factory,
IEventProcessorConfig config, ICheckpointManager checkpoint,
ILeaseManager lease, ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_config = config ?? throw new ArgumentNullException(nameof(config));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_lease = lease;
_checkpoint = checkpoint;
_lock = new SemaphoreSlim(1);
}
public EventProcessorWrapper(
IEventProcessorFactory eventProcessorFactory,
EventProcessorHostControllerSettings settings)
{
_eventProcessorFactory = eventProcessorFactory;
_processor = new EventProcessorHost(
settings.EventHubName,
settings.ConsumerGroupName,
settings.EventHubConnectionString,
settings.StorageConnectionString,
settings.LeaseContainerName);
}
public static async Task <EventProcessorHost> AttachProcessorForHub(
string processorName,
string serviceBusConnectionString,
string offsetStorageConnectionString,
string eventHubName,
IEventProcessorFactory processorFactory)
{
var eventProcessorHost = new EventProcessorHost(processorName, eventHubName, EventHubConsumerGroup.DefaultGroupName, serviceBusConnectionString, offsetStorageConnectionString);
await eventProcessorHost.RegisterEventProcessorFactoryAsync(processorFactory);
return(eventProcessorHost);
}
public EventSubscriber(IServiceProvider serviceProvider, string providerName)
{
this.providerName = providerName;
this._serviceProvider = serviceProvider;
this._logger = this._serviceProvider.GetRequiredService <ILogger <EventSubscriber> >();
this._options = serviceProvider.GetRequiredService <IOptionsSnapshot <RabbitOptions> >().Get(providerName);
this._eventProcessorFactory = serviceProvider.GetRequiredService <IEventProcessorFactory>();
this._serializer = this._serviceProvider.GetRequiredServiceByName <ISerializer>(_options.SerializationType);
var _channelFactory = serviceProvider.GetRequiredServiceByName <IRabbitChannelFactory>(this.providerName);
this._monitorTimer = new Timer(state => { MonitorConsumer().Wait(); }, null, TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10));
}
internal ConfigurationBuilder(Configuration copyFrom)
{
_dataSourceFactory = copyFrom.DataSourceFactory;
_dataStoreFactory = copyFrom.DataStoreFactory;
_diagnosticOptOut = copyFrom.DiagnosticOptOut;
_eventProcessorFactory = copyFrom.EventProcessorFactory;
_httpConfigurationFactory = copyFrom.HttpConfigurationFactory;
_loggingConfigurationFactory = copyFrom.LoggingConfigurationFactory;
_offline = copyFrom.Offline;
_sdkKey = copyFrom.SdkKey;
_startWaitTime = copyFrom.StartWaitTime;
}
public Agent(
ILogger logger,
IConfig config,
IEventProcessorFactory factory,
IThroughputCounter throughtCounter,
IMessages messages)
{
this.config = config;
this.logger = logger;
this.processorFactory = factory;
this.throughtCounter = throughtCounter;
this.messages = messages;
}
public MessageProcessorService(ITelemetryInsightsLogger logger, IEventProcessorFactory factory, EventProcessorHost host)
{
_logger = logger;
_factory = factory;
_host = host;
_options = new EventProcessorOptions
{
MaxBatchSize = 200,
PrefetchCount = 500,
ReceiveTimeout = TimeSpan.FromMinutes(2),
};
}
internal ConfigurationBuilder(Configuration copyFrom)
{
_bigSegmentsConfigurationFactory = copyFrom.BigSegmentsConfigurationFactory;
_dataSourceFactory = copyFrom.DataSourceFactory;
_dataStoreFactory = copyFrom.DataStoreFactory;
_diagnosticOptOut = copyFrom.DiagnosticOptOut;
_eventProcessorFactory = copyFrom.EventProcessorFactory;
_httpConfigurationFactory = copyFrom.HttpConfigurationFactory;
_loggingConfigurationFactory = copyFrom.LoggingConfigurationFactory;
_offline = copyFrom.Offline;
_sdkKey = copyFrom.SdkKey;
_serviceEndpointsBuilder = new ServiceEndpointsBuilder(copyFrom.ServiceEndpoints);
_startWaitTime = copyFrom.StartWaitTime;
}
public static async Task <EventProcessorHost> AttachProcessorForHub(
string processorName,
string eventHubConnection,
string storageConnection,
string eventHubName,
string consumerGroup,
IEventProcessorFactory factory)
{
var eventProcessorHost = new EventProcessorHost(processorName, eventHubName, consumerGroup,
eventHubConnection, storageConnection);
await eventProcessorHost.RegisterEventProcessorFactoryAsync(factory);
return(eventProcessorHost);
}
/// <summary>
/// This registers <see cref="IEventProcessorFactory"/> implementation with the host which is used to create an instance of
/// <see cref="IEventProcessor"/> when it takes ownership of a partition. This also starts the host and causes it to start participating
/// in the partition distribution process.
/// </summary>
/// <param name="factory">Instance of <see cref="IEventProcessorFactory"/> implementation.</param>
/// <param name="processorOptions"><see cref="EventProcessorOptions"/> to control various aspects of message pump created when ownership
/// is acquired for a particular partition of EventHub.</param>
/// <returns>A task to indicate EventProcessorHost instance is started.</returns>
public async Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory, EventProcessorOptions processorOptions)
{
if (factory == null || processorOptions == null)
{
throw new ArgumentNullException(factory == null ? nameof(factory) : nameof(processorOptions));
}
// Initialize partition manager options with default values if not already set by the client.
if (this.PartitionManagerOptions == null)
{
// Assign partition manager with default options.
this.PartitionManagerOptions = new PartitionManagerOptions();
}
ProcessorEventSource.Log.EventProcessorHostOpenStart(this.HostName, factory.GetType().ToString());
try
{
// Override operation timeout by receive timeout?
if (processorOptions.ReceiveTimeout > TimeSpan.MinValue)
{
this.OperationTimeout = processorOptions.ReceiveTimeout;
if (this.eventHubConnectionString != null)
{
var cbs = new EventHubsConnectionStringBuilder(this.eventHubConnectionString)
{
OperationTimeout = processorOptions.ReceiveTimeout
};
this.eventHubConnectionString = cbs.ToString();
}
}
// Initialize lease manager if this is an AzureStorageCheckpointLeaseManager
(this.LeaseManager as AzureStorageCheckpointLeaseManager)?.Initialize(this);
this.ProcessorFactory = factory;
this.EventProcessorOptions = processorOptions;
await this.PartitionManager.StartAsync().ConfigureAwait(false);
}
catch (Exception e)
{
ProcessorEventSource.Log.EventProcessorHostOpenError(this.HostName, e.ToString());
throw;
}
finally
{
ProcessorEventSource.Log.EventProcessorHostOpenStop(this.HostName);
}
}
internal ConfigurationBuilder(Configuration copyFrom)
{
_autoAliasingOptOut = copyFrom.AutoAliasingOptOut;
_dataSourceFactory = copyFrom.DataSourceFactory;
_diagnosticOptOut = copyFrom.DiagnosticOptOut;
_enableBackgroundUpdating = copyFrom.EnableBackgroundUpdating;
_evaluationReasons = copyFrom.EvaluationReasons;
_eventProcessorFactory = copyFrom.EventProcessorFactory;
_httpConfigurationBuilder = copyFrom.HttpConfigurationBuilder;
_loggingConfigurationBuilder = copyFrom.LoggingConfigurationBuilder;
_mobileKey = copyFrom.MobileKey;
_offline = copyFrom.Offline;
_persistenceConfigurationBuilder = copyFrom.PersistenceConfigurationBuilder;
_serviceEndpointsBuilder = new ServiceEndpointsBuilder(copyFrom.ServiceEndpoints);
}
public async Task <bool> RegisterEventMessageConsumerAsync(string name, IEventProcessorFactory eventProcessorFactory)
{
ConsumerConfigurationsOptions consumerConfiguration = GetConsumerConfiguration(name);
if (EventProcessorHostList != null && EventProcessorHostList.Any(s => s.EventHubPath == consumerConfiguration.EventHubName))
{
return(false);
}
eventProcessorHost = new EventProcessorHost(
consumerConfiguration.EventHubName,
!string.IsNullOrWhiteSpace(consumerConfiguration.ConsumerGroupName) ? consumerConfiguration.ConsumerGroupName : PartitionReceiver.DefaultConsumerGroupName,
consumerConfiguration.ConnectionString,
consumerConfiguration.StorageConnectionString,
consumerConfiguration.StorageContainerName)
{
PartitionManagerOptions = new PartitionManagerOptions
{
RenewInterval = TimeSpan.FromSeconds(consumerConfiguration.RenewIntervalInSeconds),
LeaseDuration = TimeSpan.FromSeconds(consumerConfiguration.LeaseDurationInSeconds)
}
};
var eventProcessorOptions = new EventProcessorOptions()
{
MaxBatchSize = consumerConfiguration.NumberOfEventsPerRequest,
ReceiveTimeout = TimeSpan.FromSeconds(consumerConfiguration.ReceiveTimeoutInSeconds)
};
DateTime offsetStartDateTime;
if (!string.IsNullOrEmpty(consumerConfiguration.OffsetStartDateTime) && DateTime.TryParse(consumerConfiguration.OffsetStartDateTime, out offsetStartDateTime))
{
eventProcessorOptions.InitialOffsetProvider = (partitionId) => EventPosition.FromEnqueuedTime(offsetStartDateTime);
}
else
{
eventProcessorOptions.InitialOffsetProvider = (partitionId) => EventPosition.FromStart();
}
await eventProcessorHost.RegisterEventProcessorFactoryAsync(eventProcessorFactory, eventProcessorOptions);
EventProcessorHostList.Add(eventProcessorHost);
EventProcessorFactoryList.Add(name, eventProcessorFactory);
return(true);
}
public async Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory, int maxBatchSize, bool invokeProcessorAfterReceiveTimeout, BlobsCheckpointStore checkpointStore, EventProcessorOptions options)
{
if (CurrentProcessor != null)
{
throw new InvalidOperationException("Processor has already been started");
}
CurrentProcessor = new Processor(maxBatchSize,
ConsumerGroupName,
EventHubConnectionString,
EventHubName,
options,
factory,
invokeProcessorAfterReceiveTimeout,
ExceptionHandler,
checkpointStore
);
await CurrentProcessor.StartProcessingAsync().ConfigureAwait(false);
}
public Agent(
IDeviceGroupsWriter deviceGroupsWriter,
IDeviceGroupsClient deviceGroupsClient,
IEventProcessorHostWrapper eventProcessorHostWrapper,
IEventProcessorFactory deviceEventProcessorFactory,
IEventHubStatus eventHubStatus,
IServicesConfig servicesConfig,
IBlobStorageConfig blobStorageConfig,
ILogger logger,
IThreadWrapper thread)
{
this.log = logger;
this.deviceGroupsWriter = deviceGroupsWriter;
this.deviceGroupsClient = deviceGroupsClient;
this.eventProcessorHostWrapper = eventProcessorHostWrapper;
this.deviceEventProcessorFactory = deviceEventProcessorFactory;
this.eventHubStatus = eventHubStatus;
this.servicesConfig = servicesConfig;
this.blobStorageConfig = blobStorageConfig;
this.deviceGroupDefinitionDictionary = new Dictionary <string, string>();
this.thread = thread;
}
/// <summary>
/// This registers <see cref="IEventProcessorFactory"/> implementation with the host which is used to create an instance of
/// <see cref="IEventProcessor"/> when it takes ownership of a partition. This also starts the host and causes it to start participating
/// in the partition distribution process.
/// </summary>
/// <param name="factory">Instance of <see cref="IEventProcessorFactory"/> implementation.</param>
/// <param name="processorOptions"><see cref="EventProcessorOptions"/> to control various aspects of message pump created when ownership
/// is acquired for a particular partition of EventHub.</param>
/// <returns>A task to indicate EventProcessorHost instance is started.</returns>
public async Task RegisterEventProcessorFactoryAsync(IEventProcessorFactory factory, EventProcessorOptions processorOptions)
{
if (factory == null || processorOptions == null)
{
throw new ArgumentNullException(factory == null ? nameof(factory) : nameof(processorOptions));
}
ProcessorEventSource.Log.EventProcessorHostOpenStart(this.Id, factory.GetType().ToString());
try
{
// Override operation timeout by receive timeout?
if (processorOptions.ReceiveTimeout > TimeSpan.MinValue)
{
var cbs = new EventHubsConnectionStringBuilder(this.EventHubConnectionString)
{
OperationTimeout = processorOptions.ReceiveTimeout
};
this.EventHubConnectionString = cbs.ToString();
}
if (this.initializeLeaseManager)
{
((AzureStorageCheckpointLeaseManager)this.LeaseManager).Initialize(this);
}
this.ProcessorFactory = factory;
this.EventProcessorOptions = processorOptions;
await this.PartitionManager.StartAsync().ConfigureAwait(false);
}
catch (Exception e)
{
ProcessorEventSource.Log.EventProcessorHostOpenError(this.Id, e.ToString());
throw;
}
finally
{
ProcessorEventSource.Log.EventProcessorHostOpenStop(this.Id);
}
}
public LdClient(Configuration config, IEventProcessor eventProcessor)
{
Log.InfoFormat("Starting LaunchDarkly Client {0}",
ServerSideClientEnvironment.Instance.Version);
_configuration = config;
ServerDiagnosticStore diagnosticStore = null;
if (!_configuration.DiagnosticOptOut)
{
diagnosticStore = new ServerDiagnosticStore(_configuration);
}
if (eventProcessor == null)
{
IEventProcessorFactory eventProcessorFactory = _configuration.EventProcessorFactory ?? Components.DefaultEventProcessor;
if (eventProcessorFactory is IEventProcessorFactoryWithDiagnostics epfwd)
{
_eventProcessor = epfwd.CreateEventProcessor(_configuration, diagnosticStore);
}
else
{
_eventProcessor = eventProcessorFactory.CreateEventProcessor(_configuration);
}
_shouldDisposeEventProcessor = true;
}
else
{
_eventProcessor = eventProcessor;
// The following line is for backward compatibility with the obsolete mechanism by which the
// caller could pass in an IStoreEvents implementation instance that we did not create. We
// were not disposing of that instance when the client was closed, so we should continue not
// doing so until the next major version eliminates that mechanism. We will always dispose
// of instances that we created ourselves from a factory.
_shouldDisposeEventProcessor = false;
}
IFeatureStore store;
if (_configuration.FeatureStore == null)
{
store = (_configuration.FeatureStoreFactory ??
Components.InMemoryFeatureStore).CreateFeatureStore();
_shouldDisposeFeatureStore = true;
}
else
{
store = _configuration.FeatureStore;
_shouldDisposeFeatureStore = false; // see previous comment
}
_featureStore = new FeatureStoreClientWrapper(store);
IUpdateProcessorFactory updateProcessorFactory = _configuration.UpdateProcessorFactory ?? Components.DefaultUpdateProcessor;
if (updateProcessorFactory is IUpdateProcessorFactoryWithDiagnostics upfwd)
{
_updateProcessor = upfwd.CreateUpdateProcessor(_configuration, _featureStore, diagnosticStore);
}
else
{
_updateProcessor = updateProcessorFactory.CreateUpdateProcessor(_configuration, _featureStore);
}
var initTask = _updateProcessor.Start();
if (!(_updateProcessor is NullUpdateProcessor))
{
Log.InfoFormat("Waiting up to {0} milliseconds for LaunchDarkly client to start..",
_configuration.StartWaitTime.TotalMilliseconds);
}
try
{
var unused = initTask.Wait(_configuration.StartWaitTime);
}
catch (AggregateException)
{
// StreamProcessor may throw an exception if initialization fails, because we want that behavior
// in the Xamarin client. However, for backward compatibility we do not want to throw exceptions
// from the LdClient constructor in the .NET client, so we'll just swallow this.
}
}
/// <summary>
/// Create host wrapper
/// </summary>
/// <param name="factory"></param>
/// <param name="hub"></param>
/// <param name="config"></param>
/// <param name="logger"></param>
public EventProcessorHost(IEventProcessorFactory factory, IEventHubConsumerConfig hub,
IEventProcessorConfig config, ILogger logger) :
this(factory, hub, config, null, null, logger)
{
}
public virtual async Task ProcessEventsAsync(PartitionContext context, IEnumerable <EventData> messages)
{
var eventDataList = new List <EventData>();
EventData lastEventData = null;
if (ConsumerConfiguration.ConsumeDelayInSeconds == null)
{
lastEventData = messages.LastOrDefault();
eventDataList = messages.ToList();
}
else
{
foreach (var eventData in messages)
{
if (ConsumerConfiguration.ConsumeDelayInSeconds != null && eventData.SystemProperties.EnqueuedTimeUtc <= DateTime.UtcNow.AddSeconds(ConsumerConfiguration.ConsumeDelayInSeconds.Value * (-1)))
{
lastEventData = eventData;
eventDataList.Add(eventData);
}
else
{
break;
}
}
}
if (lastEventData != null)
{
try
{
bool sucess = await ProcessEventDataList(context, eventDataList);
if (sucess)
{
await context.CheckpointAsync(lastEventData);
}
else if (!sucess && !string.IsNullOrWhiteSpace(ConsumerConfiguration.ProducerName))
{
var sendToShuntList = new List <EventData>();
var sendToRetryList = new List <EventData>();
IEventHubProducerService eventHubProducerService = ServiceProvider.GetService <IEventHubProducerService>();
foreach (var eventData in eventDataList)
{
if (eventData.HasIsOkProperty())
{
eventData.RemoveSendToShuntProperty().RemoveIsOkProperty().RemoveRetryProperty();
continue;
}
int incrementedRetryProperty = eventData.IncrementRetryProperty();
if (!string.IsNullOrWhiteSpace(ConsumerConfiguration.Shunt?.ProducerName) &&
(eventData.HasSendToShuntProperty() ||
(ConsumerConfiguration.Shunt.MaxRetry > 0 && incrementedRetryProperty > ConsumerConfiguration.Shunt.MaxRetry))
)
{
eventData.RemoveSendToShuntProperty().RemoveIsOkProperty().RemoveRetryProperty();
sendToShuntList.Add(eventData);
}
else
{
sendToRetryList.Add(eventData);
}
}
if (sendToShuntList.Any())
{
await eventHubProducerService.SendEventDataAsync(ConsumerConfiguration.Shunt.ProducerName, sendToShuntList);
}
if (sendToRetryList.Any())
{
await eventHubProducerService.SendEventDataAsync(ConsumerConfiguration.ProducerName, sendToRetryList);
}
await context.CheckpointAsync(lastEventData);
}
}
catch (Exception ex)
{
IEventProcessorFactory eventProcessorFactory = null;
try
{
await Task.Run(() =>
new ExecuteAsync(1, 1000, async() =>
{
IEventHubConsumerService eventHubConsumerService = ServiceProvider.GetService <IEventHubConsumerService>();
eventProcessorFactory = await eventHubConsumerService.UnregisterEventMessageConsumerAsync(ConsumerConfiguration.Name);
Thread.Sleep(10000);
await eventHubConsumerService.RegisterEventMessageConsumerAsync(ConsumerConfiguration.Name, eventProcessorFactory);
}).Do(true));
}
catch (Exception ex2)
{
if (ServiceProvider != null)
{
IEventHubConsumerService eventHubConsumerService = ServiceProvider.GetService <IEventHubConsumerService>();
if (eventProcessorFactory != null)
{
await eventHubConsumerService.RegisterEventMessageConsumerAsync(ConsumerConfiguration.Name, eventProcessorFactory);
}
}
}
}
}
}
/// <summary>
/// Sets the implementation of <see cref="IEventProcessor"/> to be used for processing analytics events,
/// using a factory object. The default is <see cref="Components.DefaultEventProcessor"/>, but
/// you may choose to use a custom implementation (for instance, a test fixture).
/// </summary>
/// <param name="configuration">the configuration</param>
/// <param name="factory">the factory object</param>
/// <returns>the same <c>Configuration</c> instance</returns>
public static Configuration WithEventProcessorFactory(this Configuration configuration, IEventProcessorFactory factory)
{
configuration.EventProcessorFactory = factory;
return(configuration);
}
public SimpleEventHubHost(ICreateClients clientFactory) : base(clientFactory)
{
_processorFactory = new SimpleProcessorFactory();
}
public DeliveryWebService(IProfileService profileService, IEventProcessorFactory eventProcessorFactory, IMappingEngine mappingEngine)
{
_profileService = profileService;
_eventProcessorFactory = eventProcessorFactory;
_mappingEngine = mappingEngine;
}
