static async Task Main() { try { // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, ehubNamespaceConnectionString, eventHubName); // Register handlers for processing events and handling errors processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromMinutes(3)); // Stop the processing await processor.StopProcessingAsync(); } catch (Exception e) { throw e; } }
public ProcessorTest(TOptions options) : base(options) { _checkpointStore = new BlobContainerClient(StorageTestEnvironment.Instance.StorageConnectionString, $"CheckpointStore-{Guid.NewGuid()}".ToLowerInvariant()); var clientOptions = new EventProcessorClientOptions() { LoadBalancingStrategy = options.LoadBalancingStrategy }; if (options.CacheEventCount.HasValue) { clientOptions.CacheEventCount = options.CacheEventCount.Value; } if (options.MaximumWaitTimeMs.HasValue) { clientOptions.MaximumWaitTime = TimeSpan.FromMilliseconds(options.MaximumWaitTimeMs.Value); } if (options.PrefetchCount.HasValue) { clientOptions.PrefetchCount = options.PrefetchCount.Value; } EventProcessorClient = new EventProcessorClient( _checkpointStore, EventHubConsumerClient.DefaultConsumerGroupName, EventHubsTestEnvironment.Instance.EventHubsConnectionString, EventHubsTestEnvironment.Instance.EventHubNameOverride, clientOptions); }
public void NamespaceConstructorClonesTheConnectionOptions() { var expectedTransportType = EventHubsTransportType.AmqpWebSockets; var otherTransportType = EventHubsTransportType.AmqpTcp; var options = new EventProcessorClientOptions { ConnectionOptions = new EventHubConnectionOptions { TransportType = expectedTransportType } }; var credential = new Mock <EventHubTokenCredential>(Mock.Of <TokenCredential>(), "{namespace}.servicebus.windows.net"); var eventProcessor = new EventProcessorClient(Mock.Of <BlobContainerClient>(), "consumerGroup", "namespace", "hub", credential.Object, options); // Simply retrieving the options from an inner connection won't be enough to prove the processor clones // its connection options because the cloning step also happens in the EventHubConnection constructor. // For this reason, we will change the transport type and verify that it won't affect the returned // connection options. options.ConnectionOptions.TransportType = otherTransportType; var connectionOptions = GetConnectionOptionsSample(eventProcessor); Assert.That(connectionOptions.TransportType, Is.EqualTo(expectedTransportType), $"The connection options should have been cloned."); }
static async Task Main() { string eventHubConnectionString = ConfigurationManager.AppSettings["EventHubConnectionString"]; string eventHubName = ConfigurationManager.AppSettings["EventHubName"]; string blobContainerName = ConfigurationManager.AppSettings["BlobContainerName"]; string blobStorageConnectionString = ConfigurationManager.AppSettings["BlockStorageConnectionString"]; // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, eventHubConnectionString, eventHubName); // Register handlers for processing events and handling errors processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(60)); // Stop the processing await processor.StopProcessingAsync(); }
public void NamespaceConstructorCreatesTheIdentifier() { var eventProcessor = new EventProcessorClient("consumerGroup", Mock.Of <PartitionManager>(), "namespace", "hub", Mock.Of <TokenCredential>()); Assert.That(eventProcessor.Identifier, Is.Not.Null); Assert.That(eventProcessor.Identifier, Is.Not.Empty); }
private async Task Process(CancellationToken cancellationToken) { var processor = new EventProcessorClient(BlobContainerClient, EventHubConsumerClient.DefaultConsumerGroupName, EventHubsConnectionString, EventHubName); processor.PartitionInitializingAsync += PartitionInitializingHandler; processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; try { Console.WriteLine("await processor.StartProcessingAsync(cancellationToken)"); await processor.StartProcessingAsync(cancellationToken); Console.WriteLine("await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken)"); await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken); } catch (OperationCanceledException) { } finally { Console.WriteLine("await processor.StopProcessingAsync();"); // TODO: Set timeout and log exceptions if cannot be cancelled await processor.StopProcessingAsync(); } processor.PartitionInitializingAsync -= PartitionInitializingHandler; processor.ProcessEventAsync -= ProcessEventHandler; processor.ProcessErrorAsync -= ProcessErrorHandler; }
public void CreateWithIdentity() { #region Snippet:EventHubs_Processor_ReadMe_CreateWithIdentity TokenCredential credential = new DefaultAzureCredential(); /*@@*/ credential = EventHubsTestEnvironment.Instance.Credential; string blobStorageUrl = "<< FULLY-QUALIFIED CONTAINER URL (like https://myaccount.blob.core.windows.net/mycontainer) >>"; /*@@*/ blobStorageUrl = $"https://{ StorageTestEnvironment.Instance.StorageAccountName }.{ StorageTestEnvironment.Instance.StorageEndpointSuffix }/{ "fake-container" }"; /*@@*/ BlobContainerClient storageClient = new BlobContainerClient(new Uri(blobStorageUrl), credential); var fullyQualifiedNamespace = "<< FULLY-QUALIFIED EVENT HUBS NAMESPACE (like something.servicebus.windows.net) >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ fullyQualifiedNamespace = EventHubsTestEnvironment.Instance.FullyQualifiedNamespace; /*@@*/ eventHubName = "fakeHub"; /*@@*/ consumerGroup = "fakeConsumer"; EventProcessorClient processor = new EventProcessorClient ( storageClient, consumerGroup, fullyQualifiedNamespace, eventHubName, credential ); #endregion }
public void ConfigureCustomEndpointAddress() { #region Snippet:EventHubs_Processor_Sample02_ConnectionOptionsCustomEndpoint var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = "not-real"; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = "fakeHub"; /*@@*/ consumerGroup = "fakeConsumer"; var processorOptions = new EventProcessorClientOptions(); processorOptions.ConnectionOptions.CustomEndpointAddress = new Uri("amqps://app-gateway.mycompany.com"); var storageClient = new BlobContainerClient( storageConnectionString, blobContainerName); var processor = new EventProcessorClient( storageClient, consumerGroup, eventHubsConnectionString, eventHubName, processorOptions); #endregion }
public void ConfigureRetryByProperty() { #region Snippet:EventHubs_Processor_Sample02_RetryByProperty var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = "not-real"; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = "fakeHub"; /*@@*/ consumerGroup = "fakeConsumer"; var processorOptions = new EventProcessorClientOptions(); processorOptions.RetryOptions.Mode = EventHubsRetryMode.Fixed; processorOptions.RetryOptions.MaximumRetries = 5; var storageClient = new BlobContainerClient( storageConnectionString, blobContainerName); var processor = new EventProcessorClient( storageClient, consumerGroup, eventHubsConnectionString, eventHubName, processorOptions); #endregion }
public void ConfigureTransportByProperty() { #region Snippet:EventHubs_Processor_Sample02_TransportProperty var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = _storageScope.ContainerName; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = _eventHubScope.EventHubName; /*@@*/ consumerGroup = _eventHubScope.ConsumerGroups.First(); var processorOptions = new EventProcessorClientOptions(); processorOptions.ConnectionOptions.TransportType = EventHubsTransportType.AmqpWebSockets; var storageClient = new BlobContainerClient( storageConnectionString, blobContainerName); var processor = new EventProcessorClient( storageClient, consumerGroup, eventHubsConnectionString, eventHubName, processorOptions); #endregion }
public void ConfigureProxyByProperty() { #region Snippet:EventHubs_Processor_Sample02_ProxyProperty var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = "not-real"; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = "fakeHub"; /*@@*/ consumerGroup = "fakeConsumer"; var processorOptions = new EventProcessorClientOptions(); processorOptions.ConnectionOptions.TransportType = EventHubsTransportType.AmqpWebSockets; processorOptions.ConnectionOptions.Proxy = new WebProxy("https://proxyserver:80", true); var storageClient = new BlobContainerClient( storageConnectionString, blobContainerName); var processor = new EventProcessorClient( storageClient, consumerGroup, eventHubsConnectionString, eventHubName, processorOptions); #endregion }
public override async Task RunAsync(CancellationToken ct) { // Reset previous checkpoints corresponding to an older source event hub (i.e. applicable if the source event hub changes) await CheckpointClient.ResetCheckpointsAsync(ct); EventProcessorClient.ProcessEventAsync += ProcessEventHandler; EventProcessorClient.ProcessErrorAsync += ProcessErrorHandler; EventProcessorClient.PartitionInitializingAsync += ProcessInitializingHandler; try { Console.WriteLine($"Starting event hub processor at {DateTime.UtcNow}"); await EventProcessorClient.StartProcessingAsync(ct); // Wait indefinitely until cancellation is requested ct.WaitHandle.WaitOne(); await EventProcessorClient.StopProcessingAsync(); } finally { EventProcessorClient.ProcessEventAsync -= ProcessEventHandler; EventProcessorClient.ProcessErrorAsync -= ProcessErrorHandler; EventProcessorClient.PartitionInitializingAsync -= ProcessInitializingHandler; } }
static async Task Main(string[] args) { var eventHubConnectionString = "Endpoint=sb://cursoaz204.servicebus.windows.net/;SharedAccessKeyName=receive;SharedAccessKey=EYXBssyaDJtp6sktCY+GAO2DcCiJhTymcSwPN58ByAc=;EntityPath=curso-az204"; var eventHubName = "curso-az204"; var blobStorageConnectionString = "DefaultEndpointsProtocol=https;AccountName=cursoaz204storageaccount;AccountKey=/4aRjlAKzLAEYIHGVBYPc2k5CrrvAdCw6Q8d+CyePg8CrG3NXVs0MRkb35TGpPeagpC17431ceOklB97W1Lp1A==;EndpointSuffix=core.windows.net"; var blobStorageContainerName = "eventhub-checkpoints"; var blobContainerClient = new BlobContainerClient(blobStorageConnectionString, blobStorageContainerName); var eventProcessorClient = new EventProcessorClient(blobContainerClient, EventHubConsumerClient.DefaultConsumerGroupName, eventHubConnectionString, eventHubName); eventProcessorClient.ProcessEventAsync += async(a) => { Console.WriteLine("Recibido: {0}", Encoding.UTF8.GetString(a.Data.Body.ToArray())); await a.UpdateCheckpointAsync(a.CancellationToken); }; eventProcessorClient.ProcessErrorAsync += (a) => { Console.WriteLine(a.Exception.Message); return(Task.CompletedTask); }; await eventProcessorClient.StartProcessingAsync(); Console.ReadLine(); Console.WriteLine("Fin"); await eventProcessorClient.StopProcessingAsync(); }
public EventHubIntegration(EventHubConfiguration configuration, EventHubOptions options) { Configuration = configuration; if (string.IsNullOrWhiteSpace(options.AccessKey)) { this.Client = new EventHubProducerClient(options.FullyQualifiedName, configuration.Name, new DefaultAzureCredential()); } else { this.Client = new EventHubProducerClient(options.ConnectionString, configuration.Name); } if (options.StorageOptions != default) { string consumerGroup = configuration.ConsumerGroup ?? "$Default"; var containerName = $"{configuration.Name.ToLower()}consumergroup"; BlobContainerClient = string.IsNullOrWhiteSpace(options.StorageOptions.AccountKey) ? new BlobContainerClient(new Uri(string.Format("https://{0}.blob.core.windows.net/{1}", options.StorageOptions.AccountName, containerName)), new DefaultAzureCredential()) : new BlobContainerClient(options.StorageOptions.GetConnectionString(), containerName); if (string.IsNullOrWhiteSpace(options.AccessKey)) { ClientReader = new EventProcessorClient(BlobContainerClient, consumerGroup, options.FullyQualifiedName, configuration.Name, new DefaultAzureCredential(), options.ProcessorOptions); } else { ClientReader = new EventProcessorClient(BlobContainerClient, consumerGroup, options.ConnectionString, configuration.Name, options.ProcessorOptions); } } }
static async Task Main() { // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName); var options = new EventProcessorClientOptions(); options.ConnectionOptions.TransportType = EventHubsTransportType.AmqpWebSockets; // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, ehubNamespaceConnectionString, eventHubName, options); // Register handlers for processing events and handling errors processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(10)); // Stop the processing await processor.StopProcessingAsync(); }
public ProcessorLockContext(EventProcessorClient client, ILogContext logContext, TimeSpan timeout, ushort maxCount, Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler, Func <PartitionClosingEventArgs, Task> partitionClosingHandler) { _logContext = logContext; _timeout = timeout; _maxCount = maxCount; client.PartitionInitializingAsync += async e => { await OnPartitionInitializing(e).ConfigureAwait(false); if (partitionInitializingHandler != null) { await partitionInitializingHandler(e).ConfigureAwait(false); } }; client.PartitionClosingAsync += async e => { await OnPartitionClosing(e).ConfigureAwait(false); if (partitionClosingHandler != null) { await partitionClosingHandler(e).ConfigureAwait(false); } }; }
public async void Listen(Action <string> eventHandler, Action <string> errorHandler) { _eventHandler = eventHandler; _errorHandler = errorHandler; // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient("DefaultEndpointsProtocol=https;AccountName=testblobstorage2021;AccountKey=hN77k/JHnRt+lGysIHJHuP2U9dvbIrYkPuwWrBN0O7ouj6mbQ47syeBxzmjvnPNugzVCXVancO8mVMXL8E0G8Q==;EndpointSuffix=core.windows.net", "blobcontainer"); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, "Endpoint=sb://testeventhub2021.servicebus.windows.net/;SharedAccessKeyName=eventhub;SharedAccessKey=dpDp+H+RKbIkqsLhzYmqlCSzJY9SI/WNm/e3vFk+1Ys=;EntityPath=eventhubdemo", "eventhubdemo"); // Register handlers for processing events and handling errors processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(Timeout.InfiniteTimeSpan); // Stop the processing await processor.StopProcessingAsync(); }
static async Task Main(string[] args) { Console.WriteLine("Event Hubs Receiver"); // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient(BlobStorageConnectionString, BlobContainerName); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, EhubNamespaceConnectionString, EventHubName); // Register handlers for processing events and handling errors processor.ProcessEventAsync += Handlers.ProcessorHandlers.ProcessEventHandler; processor.ProcessErrorAsync += Handlers.ProcessorHandlers.ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(10)); // Stop the processing await processor.StopProcessingAsync(); Console.WriteLine("Event Received"); }
public async Task ProcessUntilCanceled() { await using var eventHubScope = await EventHubScope.CreateAsync(2); await using var storageScope = await StorageScope.CreateAsync(); #region Snippet:EventHubs_Processor_ReadMe_ProcessUntilCanceled var cancellationSource = new CancellationTokenSource(); cancellationSource.CancelAfter(TimeSpan.FromSeconds(45)); var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = storageScope.ContainerName; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = eventHubScope.EventHubName; /*@@*/ consumerGroup = eventHubScope.ConsumerGroups.First(); Task processEventHandler(ProcessEventArgs eventArgs) => Task.CompletedTask; Task processErrorHandler(ProcessErrorEventArgs eventArgs) => Task.CompletedTask; var storageClient = new BlobContainerClient(storageConnectionString, blobContainerName); var processor = new EventProcessorClient(storageClient, consumerGroup, eventHubsConnectionString, eventHubName); processor.ProcessEventAsync += processEventHandler; processor.ProcessErrorAsync += processErrorHandler; await processor.StartProcessingAsync(); try { // The processor performs its work in the background; block until cancellation // to allow processing to take place. await Task.Delay(Timeout.Infinite, cancellationSource.Token); } catch (TaskCanceledException) { // This is expected when the delay is canceled. } try { await processor.StopProcessingAsync(); } finally { // To prevent leaks, the handlers should be removed when processing is complete. processor.ProcessEventAsync -= processEventHandler; processor.ProcessErrorAsync -= processErrorHandler; } #endregion }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var storageConnectionString = Configuration["Storage:ConnectionString"]; var storageContainer = Configuration["Storage:Container"]; var storageClient = new BlobContainerClient(storageConnectionString, storageContainer); var eventHubConnectionString = Configuration["EventHubs:ConnectionString"]; var eventHubName = Configuration["EventHubs:EventHub"]; var eventHubConsumerGroupName = EventHubConsumerClient.DefaultConsumerGroupName; // Configuration["EventHubs:ConsumerGroup"]; var processor = new EventProcessorClient(storageClient, eventHubConsumerGroupName, eventHubConnectionString, eventHubName); processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; EventsProcessed = 0; await processor.StartProcessingAsync(); try { while (!stoppingToken.IsCancellationRequested) { await Task.Delay(1000); } await processor.StopProcessingAsync(); } finally { processor.ProcessEventAsync -= ProcessEventHandler; processor.ProcessErrorAsync -= ProcessErrorHandler; } }
public void Create() { #region Snippet:EventHubs_Processor_ReadMe_Create var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = "not-real"; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = "fakeHub"; /*@@*/ consumerGroup = "fakeConsumer"; BlobContainerClient storageClient = new BlobContainerClient(storageConnectionString, blobContainerName); EventProcessorClient processor = new EventProcessorClient ( storageClient, consumerGroup, eventHubsConnectionString, eventHubName ); #endregion }
static async Task Main(string[] args) { // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName); // Create an event processor client to process events in the event hub EventProcessorClient processorClinet = new EventProcessorClient(storageClient, consumerGroup, ehubNamespaceConnectionString, eventHubName); // Register handlers for processing events and handling errors processorClinet.ProcessEventAsync += ProcessEventHandler; processorClinet.ProcessErrorAsync += ProcessErrorHandler; // Start processing await processorClinet.StartProcessingAsync(); // Processing time DateTime finishProcessing = DateTime.Now.AddMinutes(10); while (DateTime.Now < finishProcessing) { // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(10)); } // Stop processing await processorClinet.StopProcessingAsync(); }
public void ConnectionStringConstructorCreatesTheIdentifier() { var eventProcessor = new EventProcessorClient("consumerGroup", Mock.Of <PartitionManager>(), "Endpoint=sb://somehost.com;SharedAccessKeyName=ABC;SharedAccessKey=123;EntityPath=somehub"); Assert.That(eventProcessor.Identifier, Is.Not.Null); Assert.That(eventProcessor.Identifier, Is.Not.Empty); }
static async Task Main() { Console.WriteLine("Receving the events from event hub..."); // Read the default consumer group string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; //Create blob container client that event will use BlobContainerClient storageClient = new BlobContainerClient(storageAccountConnectionString, containerName); //Create event processor client to process events in event hub while (true) { EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, eventHubsNamespaceConnetionString, eventHubName); processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(10)); await processor.StopProcessingAsync(); } }
// This approach uses an EventPRocessorClient to maintain state of events read and to process new events. // To read more on this, see: https://docs.microsoft.com/en-us/dotnet/api/overview/azure/messaging.eventhubs.processor-readme public async static Task <string> processEvents(string ehConnectionString, string blobConnectionString) { string ehName = "telemetryhub"; string blobContainerName = "sample-container"; // For now, read as the default consumer group: $Default // Change this to match certain consumer types/permissions you establish // in the EventHub properties. string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use to keep track of what has been // historically read or processed already and what events are new. BlobContainerClient storageClient = new BlobContainerClient(blobConnectionString, blobContainerName); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, ehConnectionString, ehName); // Register handlers for processing events and handling errors (see static Task definitions later in this class) processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // By its nature, this approach runs continuously to process events as they're added to the queue // Therefore, for this sample code, we will start it and stop it after 15 seconds just to see how // it works. // // In the real world, you will likely have a dedicated processor class/function running // in perpetuity so that new events can be processed as they're recieved. await processor.StartProcessingAsync(); await Task.Delay(TimeSpan.FromSeconds(15)); await processor.StopProcessingAsync(); return("Complete"); }
public EventHubProcessorContext(IHostConfiguration hostConfiguration, ReceiveSettings receiveSettings, BlobContainerClient blobContainerClient, EventProcessorClient client, Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler, Func <PartitionClosingEventArgs, Task> partitionClosingHandler, CancellationToken cancellationToken) : base(cancellationToken) { _blobContainerClient = blobContainerClient; _client = client; var lockContext = new ProcessorLockContext(hostConfiguration, receiveSettings); _client.PartitionInitializingAsync += async args => { await lockContext.OnPartitionInitializing(args).ConfigureAwait(false); if (partitionInitializingHandler != null) { await partitionInitializingHandler(args).ConfigureAwait(false); } }; _client.PartitionClosingAsync += async args => { if (partitionClosingHandler != null) { await partitionClosingHandler(args).ConfigureAwait(false); } await lockContext.OnPartitionClosing(args).ConfigureAwait(false); }; _client.ProcessErrorAsync += OnError; _client.ProcessEventAsync += OnMessage; ReceiveSettings = receiveSettings; _lockContext = lockContext; }
public void ConnectionStringConstructorClonesTheConnectionOptions() { var expectedTransportType = EventHubsTransportType.AmqpWebSockets; var otherTransportType = EventHubsTransportType.AmqpTcp; var options = new EventProcessorClientOptions { ConnectionOptions = new EventHubConnectionOptions { TransportType = expectedTransportType } }; var eventProcessor = new EventProcessorClient(Mock.Of <BlobContainerClient>(), "consumerGroup", "Endpoint=sb://somehost.com;SharedAccessKeyName=ABC;SharedAccessKey=123;EntityPath=somehub", options); // Simply retrieving the options from an inner connection won't be enough to prove the processor clones // its connection options because the cloning step also happens in the EventHubConnection constructor. // For this reason, we will change the transport type and verify that it won't affect the returned // connection options. options.ConnectionOptions.TransportType = otherTransportType; var connectionOptions = GetConnectionOptionsSample(eventProcessor); Assert.That(connectionOptions.TransportType, Is.EqualTo(expectedTransportType), $"The connection options should have been cloned."); }
public async Task <string> OpenAsync(CancellationToken cancellationToken) { try { var nsm = NamespaceManager.CreateFromConnectionString(_ehConnString); EventHubDescription desc = new EventHubDescription(_ehPath); await nsm.CreateEventHubIfNotExistsAsync(desc); _client = new EventProcessorClient(new EventprocessorClientOptions { Host = Environment.MachineName + " " + Guid.NewGuid().ToString(), ConnString = _ehConnString, HubPath = _ehPath, StorageConnString = _storageConnString, OnMessageAction = (message) => { this._messageCallback?.Invoke(message); }, OnError = (error) => { this._loggerAction?.Invoke(error); } }); _client.Start(); //return Task.FromResult($"EventHub at {this._ehPath}"); return($"EventHub at {this._ehPath}"); } catch (Exception e) { this._loggerAction?.Invoke(e); return($"Not listening on {this._ehPath}"); } }
static async Task Main() { // Read all environment variables // Event Hub processor needs its own blob container (to store checkpoints, etc.) string ehubNamespaceConnStr = Environment.GetEnvironmentVariable("EHUB_NS_CONNSTR"); string eventProcBlobConnStr = Environment.GetEnvironmentVariable("EHUB_BLOB_CONNSTR"); string eHub = Environment.GetEnvironmentVariable("EHUB"); string eventProcContainer = Environment.GetEnvironmentVariable("EHUB_CONTAINER"); // Read from the default consumer group: $Default string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName; // Create a blob container client that the event processor will use BlobContainerClient eventProcStorageClient = new BlobContainerClient(eventProcBlobConnStr, eventProcContainer); // Create an event processor client to process events in the event hub EventProcessorClient processor = new EventProcessorClient(eventProcStorageClient, consumerGroup, ehubNamespaceConnStr, eHub); // Register handlers for processing events and handling errors processor.ProcessEventAsync += ProcessEventHandler; processor.ProcessErrorAsync += ProcessErrorHandler; // Start the processing await processor.StartProcessingAsync(); // Wait for 10 seconds for the events to be processed await Task.Delay(TimeSpan.FromSeconds(1000)); // Stop the processing await processor.StopProcessingAsync(); }
public void ConfigureHandlers() { #region Snippet:EventHubs_Processor_ReadMe_ConfigureHandlers #if SNIPPET var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; #else var storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; var blobContainerName = "not-real"; var eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; var eventHubName = "fakeHub"; var consumerGroup = "fakeConsumer"; #endif async Task processEventHandler(ProcessEventArgs eventArgs) { try { // Perform the application-specific processing for an event. This method // is intended for illustration and is not defined in this snippet. await DoSomethingWithTheEvent(eventArgs.Partition, eventArgs.Data); } catch { // Handle the exception from handler code } } async Task processErrorHandler(ProcessErrorEventArgs eventArgs) { try { // Perform the application-specific processing for an error. This method // is intended for illustration and is not defined in this snippet. await DoSomethingWithTheError(eventArgs.Exception); } catch { // Handle the exception from handler code } } var storageClient = new BlobContainerClient(storageConnectionString, blobContainerName); var processor = new EventProcessorClient(storageClient, consumerGroup, eventHubsConnectionString, eventHubName); processor.ProcessEventAsync += processEventHandler; processor.ProcessErrorAsync += processErrorHandler; #endregion Task DoSomethingWithTheEvent(PartitionContext partition, EventData data) => Task.CompletedTask; Task DoSomethingWithTheError(Exception ex) => Task.CompletedTask; }