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;
}
