/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerConfig"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public void Init(IProviderConfiguration providerConfig, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerConfig == null)
{
throw new ArgumentNullException("providerConfig");
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException("providerName");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (svcProvider == null)
{
throw new ArgumentNullException("svcProvider");
}
logger = log;
serviceProvider = svcProvider;
adapterConfig = new EventHubStreamProviderConfig(providerName);
adapterConfig.PopulateFromProviderConfig(providerConfig);
hubSettings = adapterConfig.GetEventHubSettings(providerConfig, serviceProvider);
checkpointSettings = adapterConfig.GetCheckpointSettings(providerConfig, serviceProvider);
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
client = EventHubClient.CreateFromConnectionString(hubSettings.ConnectionString, hubSettings.Path);
bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(adapterConfig.CacheSizeMb, pool => new FixedSizeBuffer(1 << 20, pool));
}
/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerCfg"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public virtual void Init(IProviderConfiguration providerCfg, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerCfg == null)
{
throw new ArgumentNullException(nameof(providerCfg));
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
providerConfig = providerCfg;
serviceProvider = svcProvider;
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
adapterSettings = new EventHubStreamProviderSettings(providerName);
adapterSettings.PopulateFromProviderConfig(providerConfig);
hubSettings = adapterSettings.GetEventHubSettings(providerConfig, serviceProvider);
client = EventHubClient.CreateFromConnectionString(hubSettings.ConnectionString, hubSettings.Path);
if (CheckpointerFactory == null)
{
checkpointerSettings = adapterSettings.GetCheckpointerSettings(providerConfig, serviceProvider);
CheckpointerFactory = partition => EventHubCheckpointer.Create(checkpointerSettings, adapterSettings.StreamProviderName, partition);
}
if (CacheFactory == null)
{
var bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(adapterSettings.CacheSizeMb, () => new FixedSizeBuffer(1 << 20));
var timePurge = new TimePurgePredicate(adapterSettings.DataMinTimeInCache, adapterSettings.DataMaxAgeInCache);
CacheFactory = (partition, checkpointer, cacheLogger) => new EventHubQueueCache(checkpointer, bufferPool, timePurge, cacheLogger);
}
if (StreamFailureHandlerFactory == null)
{
//TODO: Add a queue specific default failure handler with reasonable error reporting.
StreamFailureHandlerFactory = partition => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
if (QueueMapperFactory == null)
{
QueueMapperFactory = partitions => new EventHubQueueMapper(partitionIds, adapterSettings.StreamProviderName);
}
if (ReceiverMonitorFactory == null)
{
ReceiverMonitorFactory = (hubPath, partition, receiverLogger) => new DefaultEventHubReceiverMonitor(hubPath, partition, receiverLogger.GetSubLogger("monitor", "-"));
}
logger = log.GetLogger($"EventHub.{hubSettings.Path}");
}
/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerCfg"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public virtual void Init(IProviderConfiguration providerCfg, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerCfg == null)
{
throw new ArgumentNullException(nameof(providerCfg));
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
providerConfig = providerCfg;
serviceProvider = svcProvider;
this.loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
this.SerializationManager = this.serviceProvider.GetRequiredService <SerializationManager>();
adapterSettings = new EventHubStreamProviderSettings(providerName);
adapterSettings.PopulateFromProviderConfig(providerConfig);
hubSettings = adapterSettings.GetEventHubSettings(providerConfig, serviceProvider);
this.telemetryProducer = serviceProvider.GetService <ITelemetryProducer>();
InitEventHubClient();
if (CheckpointerFactory == null)
{
checkpointerSettings = adapterSettings.GetCheckpointerSettings(providerConfig, serviceProvider);
CheckpointerFactory = partition => EventHubCheckpointer.Create(checkpointerSettings, adapterSettings.StreamProviderName, partition, this.loggerFactory);
}
if (CacheFactory == null)
{
CacheFactory = CreateCacheFactory(adapterSettings).CreateCache;
}
if (StreamFailureHandlerFactory == null)
{
//TODO: Add a queue specific default failure handler with reasonable error reporting.
StreamFailureHandlerFactory = partition => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
if (QueueMapperFactory == null)
{
QueueMapperFactory = partitions => new EventHubQueueMapper(partitions, adapterSettings.StreamProviderName);
}
if (ReceiverMonitorFactory == null)
{
ReceiverMonitorFactory = (dimensions, logger, telemetryProducer) => new DefaultEventHubReceiverMonitor(dimensions, telemetryProducer);
}
logger = log.GetLogger($"EventHub.{hubSettings.Path}");
}
/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerConfig"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public void Init(IProviderConfiguration providerConfig, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerConfig == null)
{
throw new ArgumentNullException("providerConfig");
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException("providerName");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (svcProvider == null)
{
throw new ArgumentNullException("svcProvider");
}
this.providerConfig = providerConfig;
logger = log;
serviceProvider = svcProvider;
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
adapterConfig = new EventHubStreamProviderConfig(providerName);
adapterConfig.PopulateFromProviderConfig(providerConfig);
hubSettings = adapterConfig.GetEventHubSettings(providerConfig, serviceProvider);
client = EventHubClient.CreateFromConnectionString(hubSettings.ConnectionString, hubSettings.Path);
if (CheckpointerFactory == null)
{
checkpointerSettings = adapterConfig.GetCheckpointerSettings(providerConfig, serviceProvider);
CheckpointerFactory = partition => EventHubCheckpointer.Create(checkpointerSettings, adapterConfig.StreamProviderName, partition);
}
if (CacheFactory == null)
{
var bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(adapterConfig.CacheSizeMb, pool => new FixedSizeBuffer(1 << 20, pool));
CacheFactory = (partition, checkpointer) => new EventHubQueueCache(checkpointer, bufferPool);
}
if (StreamFailureHandlerFactory == null)
{
//TODO: Add a queue specific default failure handler with reasonable error reporting.
StreamFailureHandlerFactory = partition => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
if (QueueMapperFactory == null)
{
QueueMapperFactory = partitions => new EventHubQueueMapper(partitionIds, adapterConfig.StreamProviderName);
}
}
public EventHubServiceBuilder(
IHandlerActivator handlerActivator,
IEventHubSettings settings,
ILogger logger,
IExceptionLogger exceptionLogger,
IHubEventErrorBus hubEventErrorBus,
IHubCommandErrorBus hubCommandErrorBus)
{
_handlerActivator = handlerActivator;
_settings = settings;
_logger = logger;
_exceptionLogger = exceptionLogger;
_hubEventErrorBus = hubEventErrorBus;
_hubCommandErrorBus = hubCommandErrorBus;
}
/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerConfig"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public void Init(IProviderConfiguration providerConfig, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerConfig == null)
{
throw new ArgumentNullException("providerConfig");
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException("providerName");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (svcProvider == null)
{
throw new ArgumentNullException("svcProvider");
}
logger = log;
serviceProvider = svcProvider;
adapterConfig = new EventHubStreamProviderConfig(providerName);
adapterConfig.PopulateFromProviderConfig(providerConfig);
// if no event hub settings type is provided, use EventHubSettings and get populate settings from providerConfig
if (adapterConfig.EventHubSettingsType == null)
{
adapterConfig.EventHubSettingsType = typeof(EventHubSettings);
}
hubSettings = serviceProvider.GetService(adapterConfig.EventHubSettingsType) as IEventHubSettings;
if (hubSettings == null)
{
throw new ArgumentOutOfRangeException("providerConfig", "EventHubSettingsType not valid.");
}
// if settings is an EventHubSettings class, populate settings from providerConfig
var settings = hubSettings as EventHubSettings;
if (settings != null)
{
settings.PopulateFromProviderConfig(providerConfig);
}
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
client = EventHubClient.CreateFromConnectionString(hubSettings.ConnectionString, hubSettings.Path);
bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(adapterConfig.CacheSizeMb, pool => new FixedSizeBuffer(1 << 20, pool));
}
public EventHubProcessor(IEventHubSettings settings,
IHandlerActivator handlerActivator,
IExceptionLogger exceptionLogger,
IHubEventErrorBus hubEventErrorBus,
IHubCommandErrorBus hubCommandErrorBus,
IDictionary <Type, Type> commandHandlers,
IDictionary <Type, ISet <Type> > eventHandlers,
ILogger logger)
{
_settings = settings;
_handlerActivator = handlerActivator;
_exceptionLogger = exceptionLogger;
_hubEventErrorBus = hubEventErrorBus;
_hubCommandErrorBus = hubCommandErrorBus;
_commandHandlers = commandHandlers;
_eventHandlers = eventHandlers;
_logger = logger;
}
public EventHubService(IHandlerActivator handlerActivator,
IExceptionLogger exceptionLogger,
IEventHubSettings settings,
IHubEventErrorBus hubEventErrorBus,
IHubCommandErrorBus hubCommandErrorBus,
ILogger logger)
{
_handlerActivator = handlerActivator;
_exceptionLogger = exceptionLogger;
_settings = settings;
_hubEventErrorBus = hubEventErrorBus;
_hubCommandErrorBus = hubCommandErrorBus;
_logger = logger;
foreach (var connection in _settings.AzureEventHubConnectionStrings)
{
_connectionStrings.Add(connection.Namespace, connection.ConnectionString);
}
}
/// <summary>
/// Factory initialization.
/// Provider config must contain the event hub settings type or the settings themselves.
/// EventHubSettingsType is recommended for consumers that do not want to include secure information in the cluster configuration.
/// </summary>
/// <param name="providerCfg"></param>
/// <param name="providerName"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public virtual void Init(IProviderConfiguration providerCfg, string providerName, Logger log, IServiceProvider svcProvider)
{
if (providerCfg == null)
{
throw new ArgumentNullException(nameof(providerCfg));
}
if (string.IsNullOrWhiteSpace(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
providerConfig = providerCfg;
serviceProvider = svcProvider;
receivers = new ConcurrentDictionary <QueueId, EventHubAdapterReceiver>();
this.SerializationManager = this.serviceProvider.GetRequiredService <SerializationManager>();
adapterSettings = new EventHubStreamProviderSettings(providerName);
adapterSettings.PopulateFromProviderConfig(providerConfig);
hubSettings = adapterSettings.GetEventHubSettings(providerConfig, serviceProvider);
#if NETSTANDARD
var connectionStringBuilder = new EventHubsConnectionStringBuilder(hubSettings.ConnectionString)
{
EntityPath = hubSettings.Path
};
client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
#else
client = EventHubClient.CreateFromConnectionString(hubSettings.ConnectionString, hubSettings.Path);
#endif
if (CheckpointerFactory == null)
{
checkpointerSettings = adapterSettings.GetCheckpointerSettings(providerConfig, serviceProvider);
CheckpointerFactory = partition => EventHubCheckpointer.Create(checkpointerSettings, adapterSettings.StreamProviderName, partition);
}
if (CacheFactory == null)
{
CacheFactory = CreateCacheFactory(adapterSettings).CreateCache;
}
if (StreamFailureHandlerFactory == null)
{
//TODO: Add a queue specific default failure handler with reasonable error reporting.
StreamFailureHandlerFactory = partition => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
if (QueueMapperFactory == null)
{
QueueMapperFactory = partitions => new EventHubQueueMapper(partitionIds, adapterSettings.StreamProviderName);
}
if (ReceiverMonitorFactory == null)
{
ReceiverMonitorFactory = (hubPath, partition, receiverLogger) => new DefaultEventHubReceiverMonitor(hubPath, partition, receiverLogger.GetSubLogger("monitor", "-"));
}
logger = log.GetLogger($"EventHub.{hubSettings.Path}");
}
