protected override async Task StartAsync() { InfoLogging("StartAsync called"); try { if (_host == null) _host = _clientFactory.CreateEventProcessorHost(EventHubPath, BaseHostName, ConsumerGroupName); await _host .RegisterEventProcessorFactoryAsync(ProcessorFactory, CreateEventProcessorOptions()) .ConfigureAwait(false); while (!Token.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false); } } catch (Exception exception) { ErrorLogging("An error happened with the EventProcessorHost", exception); } if (_host != null) { InfoLogging("Unregistering Event Processor"); await _host.UnregisterEventProcessorAsync().ConfigureAwait(false); } InfoLogging("StartAsync completes"); }
public async void ReadUsingEventHubProcessor() { string serviceBusNamespace = "iotmc-ns"; string eventHubName = "iotmc"; string eventHubSASKeyName = "Device01"; string eventHubSASKey = "<< Add your SAS here >>"; string storageAccountName = "iotmc"; string storageAccountKey = "<< add your Storage Account key here >>"; string storageConnectionString = String.Format(@"DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventHubConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey( ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty), eventHubSASKeyName, eventHubSASKey); EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName); EventHubConsumerGroup eventHubConsumerGroup = eventHubClient.GetDefaultConsumerGroup(); EventProcessorHost eventProcessorHost = new EventProcessorHost("MSTechDemoWorker", eventHubClient.Path, eventHubConsumerGroup.GroupName, eventHubConnectionString, storageConnectionString); //await eventProcessorHost.RegisterEventProcessorAsync<EventHubEventProcessor>(); //Ignore older messages even if they are still in the event hub store Task t = eventProcessorHost.RegisterEventProcessorAsync<EventHubEventProcessor>(new EventProcessorOptions() { InitialOffsetProvider = (partitionId) => { return DateTime.UtcNow.AddHours(-1); } }); t.Wait(); }
public EventReceiver(IEventProcessorFactory processorFactory, string eventHubName, string consumerGroupName, string eventHubConnectionString, string checkpointConnectionString) { _processorFactory = processorFactory; _host = new EventProcessorHost(Environment.MachineName, eventHubName, consumerGroupName, eventHubConnectionString, checkpointConnectionString); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; Trace.TraceInformation("Alarms has been started"); var eventHubName = RoleEnvironment.GetConfigurationSettingValue("EventHubName"); var serviceBusConnectionString = RoleEnvironment.GetConfigurationSettingValue("Azure.ServiceBus.ConnectionString"); var storageConnectionString = RoleEnvironment.GetConfigurationSettingValue("Azure.Storage.ConnectionString"); var builder = new ServiceBusConnectionStringBuilder(serviceBusConnectionString); builder.TransportType = TransportType.Amqp; var eventHubReceiveClient = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); var eventHubConsumerGroup = eventHubReceiveClient.GetDefaultConsumerGroup(); var eventProcessorHost = new EventProcessorHost( "AlarmsWorker", eventHubName, eventHubConsumerGroup.GroupName, builder.ToString(), storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync<MessageProcessor>(); return base.OnStart(); }
private async static void Run(TypeContainer tc) { string eventHubConfigFile = _settings.EventHubConfigFile; var eventHubConfig = ConfigUtility.ReadConfig<Dictionary<string, string>>(eventHubConfigFile); string eventHubName = eventHubConfig["EventHubName"]; string eventHubConnectionString = eventHubConfig["EventHubConnectionString"]; string azureStorageConnectionString = eventHubConfig["AzureStorageConnectionString"]; string eventProcessorHostName = "IoTEventHubTSDBWriter"; try { EventProcessorHost host = new EventProcessorHost( eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, azureStorageConnectionString, eventHubName.ToLowerInvariant()); IEventProcessorFactory factory = new TsdbEventProcessorFactory(); IInitializer factoryInitializer = factory as IInitializer; factoryInitializer.Initialize(_settings); var options = new EventProcessorOptions(); options.ExceptionReceived += Options_ExceptionReceived; await host.RegisterEventProcessorFactoryAsync(factory, options); } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. bool result = base.OnStart(); Trace.TraceInformation("KAIT.PushNotificationService has been started"); string storage = "DefaultEndpointsProtocol=https;AccountName=inceptionasamonitoring;AccountKey=Lwtx59G+gypbFHrk0+DT8ggdk045CQBp/qXrlUlclVqOhTyIIo7u72DnnEhWzu6bgPtnJ948Ad4M2/gSWx7osw=="; string serviceBus = "Endpoint=sb://inceptioningess-ns.servicebus.windows.net/;SharedAccessKeyName=ListenPolicy;SharedAccessKey=jMkbgtpkPb9pwVTKLoIKhuKAgN6Q6BHHpf00kPQ2AxU="; string eventHubName = "interactionsnotifications"; EventHubClient client = EventHubClient.CreateFromConnectionString(serviceBus, eventHubName); Trace.TraceInformation("Consumer group is: " + client.GetDefaultConsumerGroup().GroupName); _host = new EventProcessorHost("singleworker", eventHubName, client.GetDefaultConsumerGroup().GroupName, serviceBus, storage); Trace.TraceInformation("Created event processor host..."); return result; }
static void Main(string[] args) { string eventHubConnectionString = Environment.GetEnvironmentVariable("APIMEVENTS-EVENTHUB-CONNECTIONSTRING", EnvironmentVariableTarget.Process); string eventHubName = Environment.GetEnvironmentVariable("APIMEVENTS-EVENTHUB-NAME", EnvironmentVariableTarget.Process); string storageAccountName = Environment.GetEnvironmentVariable("APIMEVENTS-STORAGEACCOUNT-NAME", EnvironmentVariableTarget.Process); string storageAccountKey = Environment.GetEnvironmentVariable("APIMEVENTS-STORAGEACCOUNT-KEY", EnvironmentVariableTarget.Process); string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventProcessorHostName = Guid.NewGuid().ToString(); var eventProcessorHost = new EventProcessorHost( eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); var logger = new ConsoleLogger(LogLevel.Debug); logger.LogDebug("Registering EventProcessor..."); var httpMessageProcessor = new RunscopeHttpMessageProcessor(new HttpClient(), logger); eventProcessorHost.RegisterEventProcessorFactoryAsync( new ApimHttpEventProcessorFactory(httpMessageProcessor, logger)); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }
public override void Run() { Trace.TraceInformation("WorkerRole1 is running"); NewRelic.Api.Agent.NewRelic.SetTransactionName("Worker", "Run"); var watch = Stopwatch.StartNew(); // Start listening for actuation events from actuatorHub. string eventHubConnectionString = "Endpoint=sb://azureiothub.servicebus.windows.net/;SharedAccessKeyName=ReceiveRule;SharedAccessKey=6lIJjmHJRKkrEPPIPS45Su2GP2oQ2TjwvAzf2hPYr/Q="; string eventHubName = "actuatorhub"; string storageAccountName = "azureiotstorage"; string storageAccountKey = "OE8ELPPu30uc1BVRW21WH3Sb6aoTkRNbP4vmYX0eLAukYNS9prF13laVUJHQkx0hVrIeDt88a5TAwQflEcTqNg=="; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventProcessorHostName = Guid.NewGuid().ToString(); eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); Trace.WriteLine("Registering EventProcessor..."); eventProcessorHost.RegisterEventProcessorAsync<EventProcessor>().Wait(); NewRelic.Api.Agent.NewRelic.RecordResponseTimeMetric("Run", watch.ElapsedMilliseconds); try { this.RunAsync(this.cancellationTokenSource.Token).Wait(); } finally { this.runCompleteEvent.Set(); } }
//Event Hubsの使用 //https://azure.microsoft.com/ja-jp/documentation/articles/event-hubs-csharp-ephcs-getstarted/ static void Main(string[] args) { Properties.Settings settings = new Properties.Settings(); //string eventHubConnectionString = "{Event Hub connection string}"; //string eventHubName = "{Event Hub name}"; string eventHubName = settings.EventHubName; string eventHubConnectionString = settings.EventHubConnectionString; //string storageAccountName = "{storage account name}"; //string storageAccountKey = "{storage account key}"; string storageAccountName = settings.StorageAccountName; string storageAccountKey = settings.StorageAccountKey; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); Console.WriteLine("Registering EventProcessor..."); var options = new EventProcessorOptions(); options.ExceptionReceived += (sender, e) => { Console.WriteLine(e.Exception); }; eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>(options).Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. bool result = base.OnStart(); Trace.TraceInformation("EventsForwarding OnStart()...\n"); connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; eventHubName = ConfigurationManager.AppSettings["Microsoft.ServiceBus.EventHubName"]; string storageAccountName = ConfigurationManager.AppSettings["AzureStorage.AccountName"]; string storageAccountKey = ConfigurationManager.AppSettings["AzureStorage.Key"]; string storageAccountString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string iotHubConnectionString = ConfigurationManager.AppSettings["AzureIoTHub.ConnectionString"]; iotHubServiceClient = ServiceClient.CreateFromConnectionString(iotHubConnectionString); eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName); var defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup(); string eventProcessorHostName = "SensorEventProcessor"; EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, defaultConsumerGroup.GroupName, connectionString, storageAccountString); eventProcessorHost.RegisterEventProcessorAsync<SensorEventProcessor>().Wait(); Trace.TraceInformation("Receiving events...\n"); return result; }
public static async Task<ColdStorageCoordinator> CreateAsync(string hostName, Configuration configuration) { ColdStorageEventSource.Log.InitializingEventHubListener(configuration.EventHubName, configuration.ConsumerGroupName); var storageAccount = CloudStorageAccount.Parse(configuration.BlobWriterStorageAccount); Func<string, IBlobWriter> blobWriterFactory = partitionId => new RollingBlobWriter.RollingBlobWriter(new PartitionAndDateNamingStrategy(partitionId, configuration.BlobPrefix), storageAccount, configuration.ContainerName, configuration.RollSizeForBlobWriterMb); var ns = NamespaceManager.CreateFromConnectionString(configuration.EventHubConnectionString); try { await ns.GetConsumerGroupAsync(configuration.EventHubName, configuration.ConsumerGroupName); } catch (Exception e) { ColdStorageEventSource.Log.InvalidEventHubConsumerGroupName(e, configuration.EventHubName, configuration.ConsumerGroupName); throw; } ColdStorageEventSource.Log.ConsumerGroupFound(configuration.EventHubName, configuration.ConsumerGroupName); var eventHubId = ConfigurationHelper.GetEventHubName(ns.Address, configuration.EventHubName); var factory = new ColdStorageEventProcessorFactory( blobWriterFactory, configuration.CircuitBreakerWarningLevel, configuration.CircuitBreakerTripLevel, configuration.CircuitBreakerStallInterval, configuration.CircuitBreakerLogCooldownInterval, eventHubId ); var options = new EventProcessorOptions() { MaxBatchSize = configuration.MaxBatchSize, PrefetchCount = configuration.PreFetchCount, ReceiveTimeOut = configuration.ReceiveTimeout, InvokeProcessorAfterReceiveTimeout = true }; options.ExceptionReceived += (s, e) => ColdStorageEventSource.Log.ErrorProcessingMessage(e.Exception, e.Action); var host = new EventProcessorHost( hostName, consumerGroupName: configuration.ConsumerGroupName, eventHubPath: configuration.EventHubName, eventHubConnectionString: configuration.EventHubConnectionString, storageConnectionString: configuration.CheckpointStorageAccount); await host.RegisterEventProcessorFactoryAsync(factory, options); return new ColdStorageCoordinator(host); }
public async Task TearDownAsync() { if (_host != null) { await _host.UnregisterEventProcessorAsync(); _host = null; } }
public void Start() { string eventProcessorHostName = Guid.NewGuid().ToString(); eventProcessorHost = new EventProcessorHost(eventProcessorHostName, Config.EVENT_HUB_NAME, EventHubConsumerGroup.DefaultGroupName, Config.EVENT_HUB_CONNECTION_STRING, Config.GetStorageConnectionString()); SimpleEventProcessor.Clients = this.Clients; SimpleEventProcessor.Host = eventProcessorHost; eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>(); }
public void MessageProcessingWithPartitionDistribution() { EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, this.eventHubName); // Get the default Consumer Group defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup(); string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state eventProcessorHost = new EventProcessorHost("singleworker", eventHubClient.Path, defaultConsumerGroup.GroupName, this.eventHubConnectionString, blobConnectionString); eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>().Wait(); }
public void RegisterEventProcessor(string blobConnectionString, string hostName) { EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, this.eventHubName); Trace.TraceInformation("register string :" + eventHubConnectionString+ blobConnectionString); //Use custom consumer group eventProcessorHost = new EventProcessorHost(hostName, eventHubClient.Path, EventHubConsumerGroup.DefaultGroupName, this.eventHubConnectionString, blobConnectionString); Trace.TraceInformation("Registering event processor"); eventProcessorHost.RegisterEventProcessorAsync<EventProcessor>().Wait(); }
public async void ProcessEvents() { eventHubName = "azureguidanceevnthub"; connectionString = GetServiceBusConnectionString(); NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString); eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName); defaultConsumerGroup = eventHubClient.GetDefaultConsumerGroup(); string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state eventProcessorHost = new EventProcessorHost("AzureGuidanceReceiver", eventHubClient.Path, defaultConsumerGroup.GroupName, connectionString, blobConnectionString); await eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>(); }
public override bool OnStart() { WorkerHelper.InitContext(); _host = WorkerHelper.GetEventProcessorHostByKey(ConstLib.KEY_SYS); // 设置最大并发连接数 ServicePointManager.DefaultConnectionLimit = 12; // 有关处理配置更改的信息, // 请参见 http://go.microsoft.com/fwlink/?LinkId=166357 上的 MSDN 主题。 bool result = base.OnStart(); //Trace.TraceInformation("HubWorker has been started"); return result; }
public static async Task<WarmStorageCoordinator> CreateAsync(string hostName, Configuration configuration) { WarmStorageEventSource.Log.InitializingEventHubListener(configuration.EventHubName, configuration.ConsumerGroupName); Func<string, IElasticSearchWriter> elasticSearchWriterFactory = partitionId => new ElasticSearchWriter.ElasticSearchWriter( configuration.ElasticSearchUrl, configuration.ElasticSearchIndexPrefix, configuration.ElasticSearchIndexType, configuration.RetryCount ); var ns = NamespaceManager.CreateFromConnectionString(configuration.EventHubConnectionString); try { await ns.GetConsumerGroupAsync(configuration.EventHubName, configuration.ConsumerGroupName); } catch (Exception e) { WarmStorageEventSource.Log.InvalidEventHubConsumerGroupName(e, configuration.EventHubName, configuration.ConsumerGroupName); throw; } WarmStorageEventSource.Log.ConsumerGroupFound(configuration.EventHubName, configuration.ConsumerGroupName); var eventHubId = ConfigurationHelper.GetEventHubName(ns.Address, configuration.EventHubName); var buildingLookupService = new BuildingLookupService(); await buildingLookupService.InitializeAsync(); var factory = new WarmStorageEventProcessorFactory(elasticSearchWriterFactory, eventHubId, buildingLookupService); var options = new EventProcessorOptions() { MaxBatchSize = configuration.MaxBatchSize, PrefetchCount = configuration.PreFetchCount, ReceiveTimeOut = configuration.ReceiveTimeout }; options.ExceptionReceived += (s, e) => WarmStorageEventSource.Log.ErrorProcessingMessage(e.Exception, e.Action); var host = new EventProcessorHost( hostName, consumerGroupName: configuration.ConsumerGroupName, eventHubPath: configuration.EventHubName, eventHubConnectionString: configuration.EventHubConnectionString, storageConnectionString: configuration.CheckpointStorageAccount); await host.RegisterEventProcessorFactoryAsync(factory, options); return new WarmStorageCoordinator(host); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); string eventHubConnectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; string eventHubName = ConfigurationManager.AppSettings["EventHubName"]; string storageConnectionString = ConfigurationManager.AppSettings["Microsoft.WindowsAzure.Storage.ConnectionString"]; string eventProcessorHostName = Guid.NewGuid().ToString(); eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync<FEZSpiderEventHubProcessor>(); }
/// <summary> /// Add a connection for listening on events from an event hub. /// </summary> /// <param name="eventHubName">Name of the event hub</param> /// <param name="listener">initialized listener object</param> /// <remarks>The EventProcessorHost type is from the ServiceBus SDK. /// Allow callers to bind to EventHubConfiguration without needing to have a direct assembly reference to the ServiceBus SDK. /// The compiler needs to resolve all types in all overloads, so give methods that use the ServiceBus SDK types unique non-overloaded names /// to avoid eager compiler resolution. /// </remarks> public void AddEventProcessorHost(string eventHubName, EventProcessorHost listener) { if (eventHubName == null) { throw new ArgumentNullException("eventHubName"); } if (listener == null) { throw new ArgumentNullException("listener"); } _listeners[eventHubName] = listener; }
/// <summary> /// This is the main entry point for your service instance. /// </summary> /// <param name="cancelServiceInstance">Canceled when Service Fabric terminates this instance.</param> protected override async Task RunAsync(CancellationToken cancelServiceInstance) { string eventHubName = "hub-1"; string eventHubConnectionString = "[Event Hub connection string 1]"; string storageConnectionString = "[Storage account connection string]"; eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName); string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); await eventProcessorHost.RegisterEventProcessorAsync <NumberConverter>(); }
static void Main(string[] args) { string eventHubConnectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; string eventHubName = ConfigurationManager.AppSettings["EventHubName"]; string storageConnectionString = ConfigurationManager.AppSettings["Microsoft.WindowsAzure.Storage.ConnectionString"]; string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync<Pi2EventHubProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); }
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), }; }
public static async Task <EventProcessorHost> AttachProcessorForHub( string processorName, string serviceBusConnectionString, string offsetStorageConnectionString, string eventHubName, string consumerGroupName, IEventProcessorFactory processorFactory) { var eventProcessorHost = new EventProcessorHost(eventHubName, consumerGroupName, serviceBusConnectionString, offsetStorageConnectionString, processorName); await eventProcessorHost.RegisterEventProcessorFactoryAsync(processorFactory); return(eventProcessorHost); }
public async Task <bool> RegisterEventMessageConsumerAsync <TEventProcessor>(string name) where TEventProcessor : EventProcessorDefault { 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(); } EventProcessorFactory <TEventProcessor> eventProcessorFactory = new EventProcessorFactory <TEventProcessor>(consumerConfiguration, ServiceProvider, Configuration); await eventProcessorHost.RegisterEventProcessorFactoryAsync(eventProcessorFactory, eventProcessorOptions); EventProcessorHostList.Add(eventProcessorHost); EventProcessorFactoryList.Add(name, eventProcessorFactory); return(true); }
private async Task ConnectToIotHubAsync(CancellationToken ct) { EventProcessorHost eventProcessorHost; // Get configuration settings string iotHubTelemetryConsumerGroup = ConfigurationProvider.GetConfigurationSettingValue("IotHubTelemetryConsumerGroup"); string iotHubEventHubName = ConfigurationProvider.GetConfigurationSettingValue("IotHubEventHubName"); string iotHubEventHubEndpointIotHubOwnerConnectionString = ConfigurationProvider.GetConfigurationSettingValue("IotHubEventHubEndpointIotHubOwnerConnectionString"); string solutionStorageAccountConnectionString = ConfigurationProvider.GetConfigurationSettingValue("SolutionStorageAccountConnectionString"); // Initialize EventProcessorHost. Trace.TraceInformation("Creating EventProcessorHost for IoTHub: {0}, ConsumerGroup: {1}, ConnectionString: {2}, StorageConnectionString: {3}", iotHubEventHubName, iotHubTelemetryConsumerGroup, iotHubEventHubEndpointIotHubOwnerConnectionString, solutionStorageAccountConnectionString); string StorageContainerName = "telemetrycheckpoints"; eventProcessorHost = new EventProcessorHost( iotHubEventHubName, iotHubTelemetryConsumerGroup, iotHubEventHubEndpointIotHubOwnerConnectionString, solutionStorageAccountConnectionString, StorageContainerName); // Registers the Event Processor Host and starts receiving messages. EventProcessorOptions options = new EventProcessorOptions(); options.InitialOffsetProvider = ((partitionId) => DateTime.UtcNow); options.SetExceptionHandler(EventProcessorHostExceptionHandler); try { await eventProcessorHost.RegisterEventProcessorAsync <MessageProcessor>(options); Trace.TraceInformation($"EventProcessor successfully registered"); } catch (Exception e) { Trace.TraceInformation($"Exception during register EventProcessorHost '{e.Message}'"); } // Wait till shutdown. while (true) { if (ct.IsCancellationRequested) { Trace.TraceInformation($"Application is shutting down. Unregistering EventProcessorHost..."); await eventProcessorHost.UnregisterEventProcessorAsync(); return; } await Task.Delay(1000); } }
private async Task StartInternalAsync(OnlineTrainerSettingsInternal settings, OnlineTrainerState state = null, byte[] model = null) { this.LastStartDateTimeUtc = DateTime.UtcNow; this.perfCounters = new PerformanceCounters(settings.Metadata.ApplicationID); // setup trainer this.trainer = new Learner(settings, this.DelayedExampleCallback, this.perfCounters); if (settings.ForceFreshStart || model != null) { this.trainer.FreshStart(state, model); } else { await this.trainer.FindAndResumeFromState(); } // setup factory this.trainProcessorFactory = new TrainEventProcessorFactory(settings, this.trainer, this.perfCounters); // setup host var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(settings.JoinedEventHubConnectionString); var joinedEventhubName = serviceBusConnectionStringBuilder.EntityPath; serviceBusConnectionStringBuilder.EntityPath = string.Empty; this.eventProcessorHost = new EventProcessorHost(settings.Metadata.ApplicationID, joinedEventhubName, EventHubConsumerGroup.DefaultGroupName, serviceBusConnectionStringBuilder.ToString(), settings.StorageConnectionString); // used by this.InitialOffsetProvider if no checkpointed state is found this.eventHubStartDateTimeUtc = settings.EventHubStartDateTimeUtc; await this.eventProcessorHost.RegisterEventProcessorFactoryAsync( this.trainProcessorFactory, new EventProcessorOptions { InitialOffsetProvider = this.InitialOffsetProvider }); // don't perform too often this.perfUpdater = new SafeTimer( TimeSpan.FromMilliseconds(500), this.UpdatePerformanceCounters); this.telemetry.TrackTrace( "OnlineTrainer started", SeverityLevel.Information, new Dictionary <string, string> { { "CheckpointPolicy", settings.CheckpointPolicy.ToString() }, { "VowpalWabbit", settings.Metadata.TrainArguments }, { "ExampleTracing", settings.EnableExampleTracing.ToString() } }); }
public void Bus_PublishAsync_EventHub_Nominal() { var id = Guid.NewGuid(); bool testOk = false; var message = new TestMessage() { SomeData = id.ToString() }; var serializer = new JSONSerializer(); var publisher = new AzureEventHubPublishTransport(serializer); IBus bus = new Bus(serializer, new AzureStorageQueueSendTransport(serializer), publisher); bus.Context = new AFBusMessageContext(); bus.PublishAsync(message, TOPICNAME).Wait(); var eventProcessorHost = new EventProcessorHost(TOPICNAME, PartitionReceiver.DefaultConsumerGroupName, SettingsUtil.GetSettings <string>(SETTINGS.AZURE_EVENTHUB), SettingsUtil.GetSettings <string>(SETTINGS.AZURE_STORAGE), "eventhubcontainer"); // Registers the Event Processor Host and starts receiving messages var readingTask = eventProcessorHost.RegisterEventProcessorFactoryAsync(new AzureStreamProcessorFactory(stringMessage => { var finalMessageEnvelope = JsonConvert.DeserializeObject <AFBusMessageEnvelope>(stringMessage, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Objects, TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple }); var finalMessage = JsonConvert.DeserializeObject <TestMessage>(finalMessageEnvelope.Body, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Objects, TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple }); testOk = testOk || (id.ToString() == finalMessage.SomeData); })); Task.Delay(5000).Wait(); // Disposes of the Event Processor Host eventProcessorHost.UnregisterEventProcessorAsync().Wait(); Assert.IsTrue(testOk); }
public Task InitializeEventProcessor(string connectionString, string eventHubName, string storageConnectionString, string path, string cGroup = null, string vin = null, string activityId = null) { Filter.BlockingCollection = new BlockingCollection<string>(int.MaxValue); Filter.EventDataCollection = new BlockingCollection<EventData>(int.MaxValue); Filter.Path = path; Filter.Vin = vin; Filter.ActivityId = activityId; this.eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName); this.consumerGroup = string.IsNullOrWhiteSpace(cGroup) ? eventHubClient.GetDefaultConsumerGroup() : eventHubClient.GetConsumerGroup(cGroup); this.eventProcessorHost = new EventProcessorHost("EventHubReader", eventHubClient.Path, this.consumerGroup.GroupName, connectionString, storageConnectionString); return this.eventProcessorHost.RegisterEventProcessorAsync<EventProcessor>(); }
public static async Task<WarmStorageCoordinator> CreateAsync(string hostName, Configuration configuration) { WarmStorageEventSource.Log.InitializingEventHubListener(configuration.EventHubName, configuration.ConsumerGroupName); Func<string, IElasticSearchWriter> elasticSearchWriterFactory = partitionId => new ElasticSearchWriter.ElasticSearchWriter( configuration.ElasticSearchUrl, configuration.ElasticSearchIndexPrefix, configuration.ElasticSearchIndexType, configuration.RetryCount ); var ns = NamespaceManager.CreateFromConnectionString(configuration.EventHubConnectionString); try { await ns.GetConsumerGroupAsync(configuration.EventHubName, configuration.ConsumerGroupName); } catch (Exception e) { WarmStorageEventSource.Log.InvalidEventHubConsumerGroupName(e, configuration.EventHubName, configuration.ConsumerGroupName); throw; } WarmStorageEventSource.Log.ConsumerGroupFound(configuration.EventHubName, configuration.ConsumerGroupName); var eventHubId = ConfigurationHelper.GetEventHubName(ns.Address, configuration.EventHubName); var factory = new WarmStorageEventProcessorFactory(elasticSearchWriterFactory, eventHubId); var options = new EventProcessorOptions() { MaxBatchSize = configuration.MaxBatchSize, PrefetchCount = configuration.PreFetchCount, ReceiveTimeOut = configuration.ReceiveTimeout }; options.ExceptionReceived += (s, e) => WarmStorageEventSource.Log.ErrorProcessingMessage(e.Exception, e.Action); var host = new EventProcessorHost( hostName, consumerGroupName: configuration.ConsumerGroupName, eventHubPath: configuration.EventHubName, eventHubConnectionString: configuration.EventHubConnectionString, storageConnectionString: configuration.CheckpointStorageAccount); await host.RegisterEventProcessorFactoryAsync(factory, options); return new WarmStorageCoordinator(host); }
public void MessageProcessingWithPartitionDistribution() { EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, this.eventHubName); // Get the default Consumer Group defaultConsumerGroup = eventHubClient.GetConsumerGroup(this.consumerGroup); string blobConnectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; // Required for checkpoint/state eventProcessorHost = new EventProcessorHost("singleworker", eventHubClient.Path, defaultConsumerGroup.GroupName, this.eventHubConnectionString, blobConnectionString); eventProcessorHost.RegisterEventProcessorAsync <MetricsEventProcessor>().Wait(); }
static void Main(string[] args) { var ehConnectionString = CloudConfigurationManager.GetSetting("ehConnectionString"); var ehName = CloudConfigurationManager.GetSetting("ehName"); var storageConnectionString = CloudConfigurationManager.GetSetting("azureTableConnection"); //var storageProcHost = new EventProcessorHost(Guid.NewGuid().ToString(), ehName, "storage", ehConnectionString, storageConnectionString); //storageProcHost.RegisterEventProcessorAsync<StorageProcessor>().Wait(); var entityProcHost = new EventProcessorHost(Guid.NewGuid().ToString(), ehName, "servicefabric", ehConnectionString, storageConnectionString); entityProcHost.RegisterEventProcessorAsync<EntityProcessor>().Wait(); Console.ReadLine(); }
public Task InitializeEventProcessor(string connectionString, string eventHubName, string storageConnectionString, string path, string cGroup = null, string vin = null, string activityId = null) { Filter.BlockingCollection = new BlockingCollection <string>(int.MaxValue); Filter.EventDataCollection = new BlockingCollection <EventData>(int.MaxValue); Filter.Path = path; Filter.Vin = vin; Filter.ActivityId = activityId; this.eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName); this.consumerGroup = string.IsNullOrWhiteSpace(cGroup) ? eventHubClient.GetDefaultConsumerGroup() : eventHubClient.GetConsumerGroup(cGroup); this.eventProcessorHost = new EventProcessorHost("EventHubReader", eventHubClient.Path, this.consumerGroup.GroupName, connectionString, storageConnectionString); return(this.eventProcessorHost.RegisterEventProcessorAsync <EventProcessor>()); }
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); }
public async Task StartAsync(CancellationToken cancellationToken) { eventProcessorHost = new EventProcessorHost( "plantgrow", "realtimeweb", "Azure-IoT-hub-endpoint-url" , "Azure-Storage_account-Access_keys-connection_string-url", "data1"); // Registers the Event Processor Host and starts receiving messages await eventProcessorHost.RegisterEventProcessorFactoryAsync(new AzureStreamProcessorFactory(_subService), new EventProcessorOptions { InitialOffsetProvider = (pid) => EventPosition.FromEnqueuedTime(DateTime.UtcNow) }); }
private static EventProcessorHost RegisterEventProcessor <T>(string serviceBus, string eventHubName, string consumerKeyName, string consumerHash, string storageConnectionString) where T : IEventProcessor { string serviceBusConnectionString = Constants.GetBusConnectionString(serviceBus, consumerKeyName, consumerHash); var eventClient = EventHubClient.CreateFromConnectionString(serviceBusConnectionString, eventHubName); var eventProcessorHost = new EventProcessorHost(Environment.MachineName, eventHubName, eventClient.GetDefaultConsumerGroup().GroupName, serviceBusConnectionString, storageConnectionString); Console.WriteLine("Registering EventProcessor..."); eventProcessorHost.RegisterEventProcessorAsync <ConsoleEventProcessor>().Wait(); return(eventProcessorHost); }
public static async Task SetupEventProcessorDeviceMessages() { EventProcessorHost eventProcessorHost = new EventProcessorHost(Guid.NewGuid().ToString(), Strings.EventHubNameC2D.ToLowerInvariant(), Strings.EventHubConsumerGroupNameC2D, Strings.EventHubConnectionStringC2D, Strings.BLOBStorageConnectionstring); Console.WriteLine("Registering Cloud to Device EventProcessor..."); var options = new EventProcessorOptions(); options.ExceptionReceived += (sender, e) => { Console.WriteLine(e.Exception); }; await eventProcessorHost.RegisterEventProcessorAsync <SmartHVACDeviceEventProcessor>(options); }
internal static EventProcessorHostPartition GetPartitionContext(string partitionId = "0", string eventHubPath = "path", string consumerGroupName = "group", string owner = null) { var processor = new EventProcessorHost(consumerGroupName, "Endpoint=sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=", eventHubPath, new EventProcessorOptions(), Int32.MaxValue, null); return(new EventProcessorHostPartition(partitionId) { ProcessorHost = processor }); }
static void Main(string[] args) { string eventHubConnectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; string eventHubName = ConfigurationManager.AppSettings["EventHubName"]; string storageConnectionString = ConfigurationManager.AppSettings["Microsoft.WindowsAzure.Storage.ConnectionString"]; string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync <Pi2EventHubProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); }
EventProcessorHost IEventProcessorHostFactory.Create() { string eventProcessorHostName = $"MyEventProcessor-{DateTime.Now}"; var eventProcessorHost = new EventProcessorHost( eventProcessorHostName, _myEventHubConfig.EventHubName, PartitionReceiver.DefaultConsumerGroupName, _myEventHubConfig.SenderConnString, _myEventHubConfig.StorageAccConnString, _myEventHubConfig.StorageContainerName ); return(eventProcessorHost); }
/// <summary> /// Initialze a new instance of the event process host /// </summary> /// <returns>event processor host</returns> private async Task <EventProcessorHost> InitalizeEventProcessorHostAsync() { // start listening to the event hub var eventHubName = ServiceFabricUtil.GetServiceFabricConfigSetting("EventHubName").Result?.ToString(); var consumerGroup = ServiceFabricUtil.GetServiceFabricConfigSetting("ConsumerGroupName").Result?.ToString(); var eventProcessorHost = new EventProcessorHost( eventHubName, consumerGroup, await SecretsStore.Instance.GetMetricsEventHubListenerConnectionStringAsync(), await SecretsStore.Instance.GetMetricsStorageConnectionStringAsync(), "metricsingestor"); return(eventProcessorHost); }
async Task CheckpointEveryMessageReceived() { var eventProcessorHost = new EventProcessorHost( null, PartitionReceiver.DefaultConsumerGroupName, TestUtility.EventHubsConnectionString, TestUtility.StorageConnectionString, this.LeaseContainerName); var runResult = await RunGenericScenario(eventProcessorHost, totalNumberOfEventsToSend : 10, checkpointLastEvent : false, checkpoingEveryEvent : true); // Validate there were not failures. Assert.True(runResult.NumberOfFailures == 0, $"RunResult returned with {runResult.NumberOfFailures} failures!"); }
private static async Task StartReceivingCommandsAsync() { Console.WriteLine("Registering EventProcessor..."); EventProcessorHost eventProcessorHost = CreateEventProcessorHost(); // Registers the Event Processor Host and starts receiving messages await eventProcessorHost.RegisterEventProcessorAsync <EventProcessor>(); Console.WriteLine("Receiving. Press ENTER to stop."); Console.ReadLine(); // Disposes of the Event Processor Host await eventProcessorHost.UnregisterEventProcessorAsync(); }
static void Main(string[] args) { var ehConnectionString = CloudConfigurationManager.GetSetting("ehConnectionString"); var ehName = CloudConfigurationManager.GetSetting("ehName"); var storageConnectionString = CloudConfigurationManager.GetSetting("azureTableConnection"); //var storageProcHost = new EventProcessorHost(Guid.NewGuid().ToString(), ehName, "storage", ehConnectionString, storageConnectionString); //storageProcHost.RegisterEventProcessorAsync<StorageProcessor>().Wait(); var entityProcHost = new EventProcessorHost(Guid.NewGuid().ToString(), ehName, "servicefabric", ehConnectionString, storageConnectionString); entityProcHost.RegisterEventProcessorAsync <EntityProcessor>().Wait(); Console.ReadLine(); }
/// <summary> /// Initialze a new instance of the event process host /// </summary> /// <returns>event processor host</returns> private async Task <EventProcessorHost> InitalizeEventProcessorHostAsync() { // start listening to the event hub var eventHubName = Utility.GetConfigValue("EventHubName"); var consumerGroup = Utility.GetConfigValue("ConsumerGroupName"); var eventProcessorHost = new EventProcessorHost( eventHubName, consumerGroup, await SecretsStore.Instance.GetMetricsEventHubListenerConnectionStringAsync(), await SecretsStore.Instance.GetMetricsStorageConnectionStringAsync(), "metricsingestor"); return(eventProcessorHost); }
static async Task MainAsync() { string eventHubConnectionString = "Endpoint=sb://yazha-ns.servicebus.windows.net/;SharedAccessKeyName=listen;SharedAccessKey=MFg5Ef9ueC4tYcXHrMOR+a6p9XLCQYWBUrNxMxsSk04="; string eventHubName = "scalehubtest"; string storageAccountName = "yazha"; string storageAccountKey = "c4KmKhEIK0uR519ANRTIz50y7XtAdkB1nvrsy27C9JB1sajHrzY5McuEuufHuVgSqQAsj52tdv0igr2xOkD7PA=="; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); int count = 32; List <Task> taskList = new List <Task>(); for (int i = 0; i < count; i++) { var tmp = i; var task = Task.Run(async() => { string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); var factory = new EventProcessorFactory(tmp); await eventProcessorHost.RegisterEventProcessorFactoryAsync(factory); }); taskList.Add(task); } Task.WaitAll(taskList.ToArray()); //var t1 = Task.Run(async () => //{ // string eventProcessorHostName = Guid.NewGuid().ToString(); // EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); // await eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>(); //}); //var t2 = Task.Run(async () => //{ // var eventProcessorHostName = Guid.NewGuid().ToString(); // EventProcessorHost eventProcessorHost2 = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); // var factory = new EventProcessorFactory(); // await eventProcessorHost2.RegisterEventProcessorFactoryAsync(factory); //}); //Task.WaitAll(t1, t2); Console.WriteLine("Receiving. Press enter key to stop worker."); }
public async void StartEventProcessor() { var eventProcessorHost = new EventProcessorHost( conf.HubName, PartitionReceiver.DefaultConsumerGroupName, conf.ConnectionString, string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", conf.AccountName, conf.AccountKey), conf.ContainerName ); this.eventProcessorHost = eventProcessorHost; // Registers the Event Processor Host and starts receiving messages // https://stackoverflow.com/questions/33371803/how-to-pass-parameters-to-an-implementation-of-ieventprocessor await eventProcessorHost.RegisterEventProcessorFactoryAsync(new EventProcessorFactory(collector, GetSourceId())); }
public async Task Connect(string hubName, string hubConnStr, string storageName, string storageConnStr, string consumerGroup) { this.eventProcessorHost = new EventProcessorHost( hubName, consumerGroup != string.Empty ? consumerGroup : PartitionReceiver.DefaultConsumerGroupName, hubConnStr, storageConnStr, storageName); EventProcessorOptions options = new EventProcessorOptions() { ReceiveTimeout = TimeSpan.FromSeconds(RECEIVE_TIMEOUT_SECS), }; await this.eventProcessorHost.RegisterEventProcessorAsync <CustomEventProcessor>(options); }
static void Main(string[] args) { string iotHubConnectionString = ConfigurationManager.AppSettings["iotHubConnectionString"];//"HostName={iothub-name}.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey={shared-key}"; string iotHubD2cEndpoint = "messages/events"; StoreEventProcessor.StorageConnectionString = ConfigurationManager.AppSettings["storageConnectionString"];// "DefaultEndpointsProtocol =https;AccountName={storage-name};AccountKey={storage-key}"; StoreEventProcessor.ServiceBusConnectionString = ConfigurationManager.AppSettings["serviceBusConnectionString"];//"Endpoint=sb://{servicebus-name}.servicebus.windows.net/;SharedAccessKeyName={servicebus-key}"; string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, iotHubD2cEndpoint, EventHubConsumerGroup.DefaultGroupName, iotHubConnectionString, StoreEventProcessor.StorageConnectionString, "messages-events"); Console.WriteLine("Registering EventProcessor..."); eventProcessorHost.RegisterEventProcessorAsync<StoreEventProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }
public async Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("Message Service ... Registering EventProcessor..."); _logger.LogInformation($"Consumer Group: {EventHubConsumerGroup}"); eventProcessorHost = new EventProcessorHost( MsgSvcEventHubName, EventHubConsumerGroup, EventHubConnectionString, StorageConnectionString, StorageContainerName); // Registers the Event Processor Host and starts receiving messages //await eventProcessorHost.RegisterEventProcessorAsync<MsgServiceEventProcessor>(); await eventProcessorHost.RegisterEventProcessorFactoryAsync(new MsgServiceEventProcessorFactory(_config, _logger, _telemetryClient)); }
async Task StartEventProcessorHost() { string eventHubConnectionString = CloudConfigurationManager.GetSetting("ServiceBusConnectionString"); string blobConnectionString = CloudConfigurationManager.GetSetting("AzureStorageConnectionString"); // Required for checkpoint/state string EventHubName = CloudConfigurationManager.GetSetting("EventHubName"); eventProcessorHost = new EventProcessorHost(System.Environment.MachineName, EventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, blobConnectionString); EventProcessorOptions options = new EventProcessorOptions() { MaxBatchSize = 8192 }; await eventProcessorHost.RegisterEventProcessorAsync <DashboardEventHubProcessor>(); }
public static async Task ReceiveAsync() { Console.WriteLine("Receive Started..."); var eventProcessorHost = new EventProcessorHost( Constants.EhEntityPath, PartitionReceiver.DefaultConsumerGroupName, Constants.EhConnectionString, Constants.StorageConnectionString, Constants.StorageContainerName); await eventProcessorHost.RegisterEventProcessorAsync <EventProcessor>(); Console.WriteLine("Receiving. Press ENTER to stop worker."); Console.ReadLine(); await eventProcessorHost.UnregisterEventProcessorAsync(); }
static async Task Main(string[] args) { var host = new EventProcessorHost( HubName, consumerGroupName, HubConnectionString, BlobConnectionString, ProcessorLeaseContainerName); await host.RegisterEventProcessorAsync <TemperatureEventProcessor>(); Console.WriteLine("Event processor started, press enter to stop..."); Console.ReadLine(); await host.UnregisterEventProcessorAsync(); }
static void Main(string[] args) { string iotHubConnectionString = "HostName=xylotohub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=aFtv5GRYaWWtJvsTp9NETXQh8O4mqFCqxL+F0tArtM0="; string iotHubD2cEndpoint = "messages/events"; StoreEventProcessor.StorageConnectionString = "DefaultEndpointsProtocol=https;AccountName=devneuzyhubsa1;AccountKey=idRO5Eetw3XbdkFRUwtwPhlOuwe2xBPgsv3WjyhknyR0RzstIb7jyDc+R4cWfEhaRuWMZ9NA+uvGQhB5rIfeEw==;BlobEndpoint=https://devneuzyhubsa1.blob.core.windows.net/;TableEndpoint=https://devneuzyhubsa1.table.core.windows.net/;QueueEndpoint=https://devneuzyhubsa1.queue.core.windows.net/;FileEndpoint=https://devneuzyhubsa1.file.core.windows.net/"; StoreEventProcessor.ServiceBusConnectionString = "Endpoint=sb://devneuzyhubsb2.servicebus.windows.net/;SharedAccessKeyName=send;SharedAccessKey=KXm1zyrKJ+3cuFL5junQfJw5hXEkEgOVzaGhcoFt7fA="; string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, iotHubD2cEndpoint, EventHubConsumerGroup.DefaultGroupName, iotHubConnectionString, StoreEventProcessor.StorageConnectionString, "messages-events"); Console.WriteLine("Registering EventProcessor..."); eventProcessorHost.RegisterEventProcessorAsync<StoreEventProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }
static void Main(string[] args) { string eventHubConnectionString = "讀取原則的連接字串"; string eventHubName = "事件中樞名稱"; string storageAccountName = "儲存體帳戶名稱"; string storageAccountKey = "儲存體存取金鑰"; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync<ReceiveProcessor>().Wait(); Console.WriteLine("Receiving.Press enter key to stop worker."); Console.ReadLine(); }
static void Main(string[] args) { string storageAccountName = "bobjacapidemo"; string storageAccountKey = "lvYpWSHkdHpCOnv91B4tGLClqeIIe0ouDW9mBAYAlm69NrHGHXhW/jrIJx5nTMgkxPWGzOoJ1jVMTCFjVvh9mg=="; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventHubConnectionString = "Endpoint=sb://bobjacsb.servicebus.windows.net/;SharedAccessKeyName=Receiving;SharedAccessKey=RjMnP8d1rUzYF9knM7eB3lGrV231/WAtEOCI5dI8AtM="; string eventProcessorHostName = Guid.NewGuid().ToString(); string eventHubName = "apimgtdemo"; EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); eventProcessorHost.RegisterEventProcessorAsync<ApiManagementEventProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); }
public static void Main() { var eventHubName = "alert"; var consumerGroup = "email"; var eventProcessorName = "EmailAlertProcessor"; var busConnectionString = ConfigurationManager.ConnectionStrings["SigfoxDemoAlertListener"].ConnectionString; var storageConnectionString = ConfigurationManager.ConnectionStrings["SigfoxDemoStorage"].ConnectionString; if (!WebJobsHelper.RunAsWebJobs) Console.CancelKeyPress += Console_CancelKeyPress; EventHubClient eventHubClient = null; var retries = 3; while (retries > 0) { try { retries--; eventHubClient = EventHubClient.CreateFromConnectionString(busConnectionString, eventHubName); retries = 0; } catch (Exception e) { Console.Error.WriteLine("Error opening source Event Hub: " + e.Message); if (retries == 0) throw; } } if (consumerGroup == null) consumerGroup = eventHubClient.GetDefaultConsumerGroup().GroupName; var eventProcessorHost = new EventProcessorHost(eventProcessorName, eventHubClient.Path, consumerGroup, busConnectionString, storageConnectionString, eventHubName.ToLowerInvariant()); eventProcessorHost.RegisterEventProcessorAsync<EventProcessor>().Wait(); while (true) { if (WebJobsHelper.RunAsWebJobs) { Thread.Sleep(50); } else { Console.WriteLine("Waiting for new messages " + DateTime.UtcNow); Thread.Sleep(1000); } if (quit || WebJobsHelper.NeedShutdown) break; } eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }
private static void InitializeEventProcessorHost() { Trace.WriteLine("Initializing EventProcessor Host"); string hostName = CreateUniqueHostname(); try { _host = new EventProcessorHost(hostName, _eventHubPath, _consumerGroupName, _eventHubConnectionString, _storageConnectionString); Trace.WriteLine($"{hostName} created successfully."); } catch (Exception ex) { Trace.WriteLine($"Host creation failed: {ex.Message}\n\n{ex.StackTrace.ToString()}"); throw; } }
static void Main(string[] args) { string eventHubConnectionString = "Endpoint=sb://gftesthub-ns.servicebus.windows.net/;SharedAccessKeyName=ReceiveRule;SharedAccessKey=wEO+aZpuPDKDp4Z8zBUlbLQ5CEhEtBqKfjztpo5MM3Y="; string eventHubName = "gftesthub"; string storageAccountName = "gfeventhubstorage"; string storageAccountKey = "DkOjsj/2NSWY62+N79+kJbR9EvPk5seonYab5U5g95n4qfKvPUPVAqNPY7R3QdX64HBomXmsCfBQIH6HMHABIw=="; string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey); string eventProcessorHostName = Guid.NewGuid().ToString(); EventProcessorHost eventProcessorHost = new EventProcessorHost(eventProcessorHostName, eventHubName, EventHubConsumerGroup.DefaultGroupName, eventHubConnectionString, storageConnectionString); Console.WriteLine("Registering EventProcessor..."); eventProcessorHost.RegisterEventProcessorAsync<SimpleEventProcessor>().Wait(); Console.WriteLine("Receiving. Press enter key to stop worker."); Console.ReadLine(); eventProcessorHost.UnregisterEventProcessorAsync().Wait(); }