/// <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}"); }