public async Task InspectPartition()
{
#region Snippet:EventHubs_Sample03_InspectPartition
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _scope.EventHubName;
var consumer = new EventHubConsumerClient(consumerGroup, connectionString, eventHubName);
try
{
string[] partitions = await consumer.GetPartitionIdsAsync();
string firstPartition = partitions.FirstOrDefault();
PartitionProperties partitionProperties = await consumer.GetPartitionPropertiesAsync(firstPartition);
Debug.WriteLine($"Partition: { partitionProperties.Id }");
Debug.WriteLine($"\tThe partition contains no events: { partitionProperties.IsEmpty }");
Debug.WriteLine($"\tThe first sequence number is: { partitionProperties.BeginningSequenceNumber }");
Debug.WriteLine($"\tThe last sequence number is: { partitionProperties.LastEnqueuedSequenceNumber }");
Debug.WriteLine($"\tThe last offset is: { partitionProperties.LastEnqueuedOffset }");
Debug.WriteLine($"\tThe last enqueued time is: { partitionProperties.LastEnqueuedTime }, in UTC.");
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReceiveAsync(Action <Message <TKey, TValue> > action)
{
//TODO: For production make use of processors
// https://devblogs.microsoft.com/azure-sdk/eventhubs-clients/#choosing-a-client-from-azure-messaging-eventhubs
await using var consumer = new EventHubConsumerClient(_consumerGroup, _connectionString, _hubName);
try
{
while (true)
{
// To ensure that we do not wait for an indeterminate length of time, we'll
// stop reading after we receive five events. For a fresh Event Hub, those
// will be the first five that we had published. We'll also ask for
// cancellation after 90 seconds, just to be safe.
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(1000);
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(cancellationSource.Token))
{
action(JsonConvert.DeserializeObject <Message <TKey, TValue> >(partitionEvent.Data.EventBody.ToString()));
}
}
}
finally
{
await consumer.CloseAsync();
}
}
public async Task ConfigureConsumerRetryWithFullOptions()
{
#region Snippet:EventHubs_Sample02_ConsumerRetryWithFullOptions
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _scope.EventHubName;
var consumerOptions = new EventHubConsumerClientOptions
{
RetryOptions = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Exponential,
MaximumRetries = 5,
Delay = TimeSpan.FromMilliseconds(800),
MaximumDelay = TimeSpan.FromSeconds(10)
}
};
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName,
consumerOptions);
#endregion
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(EventHubsTestEnvironment.Instance.TestExecutionTimeLimit);
await consumer.CloseAsync(cancellationSource.Token).IgnoreExceptions();
}
public async Task ConfigureConsumerRetryByProperty()
{
#region Snippet:EventHubs_Sample02_ConsumerRetryByProperty
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _scope.EventHubName;
var consumerOptions = new EventHubConsumerClientOptions();
consumerOptions.RetryOptions.Mode = EventHubsRetryMode.Fixed;
consumerOptions.RetryOptions.MaximumRetries = 5;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName,
consumerOptions);
#endregion
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(EventHubsTestEnvironment.Instance.TestExecutionTimeLimit);
await consumer.CloseAsync(cancellationSource.Token).IgnoreExceptions();
}
public async Task ReadPartitionTrackLastEnqueued()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample05_ReadPartitionTrackLastEnqueued
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = scope.EventHubName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
string firstPartition = (await consumer.GetPartitionIdsAsync(cancellationSource.Token)).First();
EventPosition startingPosition = EventPosition.Earliest;
var options = new ReadEventOptions
{
TrackLastEnqueuedEventProperties = true
};
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsFromPartitionAsync(
firstPartition,
startingPosition,
options,
cancellationSource.Token))
{
LastEnqueuedEventProperties properties =
partitionEvent.Partition.ReadLastEnqueuedEventProperties();
Debug.WriteLine($"Partition: { partitionEvent.Partition.PartitionId }");
Debug.WriteLine($"\tThe last sequence number is: { properties.SequenceNumber }");
Debug.WriteLine($"\tThe last offset is: { properties.Offset }");
Debug.WriteLine($"\tThe last enqueued time is: { properties.EnqueuedTime }, in UTC.");
Debug.WriteLine($"\tThe information was updated at: { properties.LastReceivedTime }, in UTC.");
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReadAllPartitionsWaitTime()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample05_ReadAllPartitionsWaitTime
#if SNIPPET
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
#else
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
var eventHubName = scope.EventHubName;
#endif
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
int loopTicks = 0;
int maximumTicks = 10;
var options = new ReadEventOptions
{
MaximumWaitTime = TimeSpan.FromSeconds(1)
};
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(options))
{
if (partitionEvent.Data != null)
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
}
else
{
Debug.WriteLine("Wait time elapsed; no event was available.");
}
loopTicks++;
if (loopTicks >= maximumTicks)
{
break;
}
}
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
/// <summary>
/// Performs the tasks needed to clean up the environment for an instance
/// of the test scenario. When multiple instances are run in parallel, cleanup
/// will be run once for each after execution has completed.
/// </summary>
///
public async override Task CleanupAsync()
{
await _readEnumerator.DisposeAsync();
await _consumer.CloseAsync().ConfigureAwait(false);
await base.CleanupAsync();
}
public async Task ReadAllPartitions()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample05_ReadAllPartitions
#if SNIPPET
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
#else
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
var eventHubName = scope.EventHubName;
#endif
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(45));
int eventsRead = 0;
int maximumEvents = 3;
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(cancellationSource.Token))
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
eventsRead++;
if (eventsRead >= maximumEvents)
{
break;
}
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReadPartitionFromSequence()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample05_ReadPartitionFromSequence
#if SNIPPET
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
#else
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
var eventHubName = scope.EventHubName;
#endif
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
string firstPartition = (await consumer.GetPartitionIdsAsync(cancellationSource.Token)).First();
PartitionProperties properties = await consumer.GetPartitionPropertiesAsync(firstPartition, cancellationSource.Token);
EventPosition startingPosition = EventPosition.FromSequenceNumber(properties.LastEnqueuedSequenceNumber);
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsFromPartitionAsync(
firstPartition,
startingPosition,
cancellationSource.Token))
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReadPartitionFromDate()
{
#region Snippet:EventHubs_Sample05_ReadPartitionFromDate
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _scope.EventHubName;
/*@@*/ consumerGroup = _availableConsumerGroups.Dequeue();
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
DateTimeOffset oneHourAgo = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromHours(1));
EventPosition startingPosition = EventPosition.FromEnqueuedTime(oneHourAgo);
string firstPartition = (await consumer.GetPartitionIdsAsync(cancellationSource.Token)).First();
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsFromPartitionAsync(
firstPartition,
startingPosition,
cancellationSource.Token))
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReadEvents()
{
await using var scope = await EventHubScope.CreateAsync(1);
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
var eventHubName = scope.EventHubName;
var consumer = new EventHubConsumerClient(EventHubConsumerClient.DefaultConsumerGroupName, connectionString, eventHubName);
#region Snippet:EventHubs_Sample01_ReadEvents
try
{
// To ensure that we do not wait for an indeterminate length of time, we'll
// stop reading after we receive five events. For a fresh Event Hub, those
// will be the first five that we had published. We'll also ask for
// cancellation after 90 seconds, just to be safe.
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(90));
var maximumEvents = 5;
var eventDataRead = new List <string>();
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(cancellationSource.Token))
{
eventDataRead.Add(partitionEvent.Data.EventBody.ToString());
if (eventDataRead.Count >= maximumEvents)
{
break;
}
}
// At this point, the data sent as the body of each event is held
// in the eventDataRead set.
}
catch
{
// Transient failures will be automatically retried as part of the
// operation. If this block is invoked, then the exception was either
// fatal or all retries were exhausted without a successful read.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
private async Task ReceiveMessagesFromDeviceAsync(CancellationToken ct)
{
await using var consumer = new EventHubConsumerClient(
EventHubConsumerClient.DefaultConsumerGroupName,
eventHubConnectionString,
eventHubName);
Console.WriteLine("Listening for messages on all partitions.");
try
{
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(startReadingAtEarliestEvent: false,
cancellationToken: ct))
{
ClearData();
//Console.WriteLine($"\nMessage received on partition {partitionEvent.Partition.PartitionId}:");
string data = Encoding.UTF8.GetString(partitionEvent.Data.Body.ToArray());
if (data.Contains("inferences")) // TODO: need to better handling other message
{
IoTMessage message = System.Text.Json.JsonSerializer.Deserialize <IoTMessage>(data);
//Console.WriteLine($"{message.timestamp} Inference:");
foreach (var inf in message.inferences)
{
DrawData(message.timestamp, inf.entity.tag.value, inf.entity.tag.confidence,
inf.entity.box.l, inf.entity.box.t, inf.entity.box.w, inf.entity.box.h);
}
}
else if (data.Contains("code")) // error
{
ErrorMessage message = System.Text.Json.JsonSerializer.Deserialize <ErrorMessage>(data);
Console.WriteLine($"Error: {message.code}, {message.target}");
}
}
}
catch (TaskCanceledException)
{
// This is expected when the token is signaled; it should not be considered an
// error in this scenario.
}
finally
{
await consumer.CloseAsync();
}
}
public async Task ReadAllPartitionsFromLatest()
{
#region Snippet:EventHubs_Sample05_ReadAllPartitionsFromLatest
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _scope.EventHubName;
/*@@*/ consumerGroup = _availableConsumerGroups.Dequeue();
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(
startReadingAtEarliestEvent: false,
cancellationToken: cancellationSource.Token))
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
private static async Task ReadFromPartition(string partitionNumber)
{
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(120));
await using var consumerClient = new EventHubConsumerClient(ConsumerGroup, ConnectionString, EventHubName);
try
{
var props = await consumerClient.GetPartitionPropertiesAsync(partitionNumber);
var startingPosition = EventPosition.FromSequenceNumber(
//props.LastEnqueuedSequenceNumber
props.BeginningSequenceNumber);
await foreach (PartitionEvent partitionEvent in consumerClient.ReadEventsFromPartitionAsync(partitionNumber, startingPosition, cancellationTokenSource.Token))
{
Console.WriteLine("***** NEW COFFEE *****");
var partitionId = partitionEvent.Partition.PartitionId;
var sequenceNumber = partitionEvent.Data.SequenceNumber;
var key = partitionEvent.Data.PartitionKey;
Console.WriteLine($"Partition Id: {partitionId}{Environment.NewLine}"
+ $"SenquenceNumber: {sequenceNumber}{Environment.NewLine}"
+ $"Partition key: {key}");
var coffee = JsonSerializer.Deserialize <CoffeeData>(partitionEvent.Data.EventBody.ToArray());
Console.WriteLine($"Temperature: {coffee.WaterTemperature}, time: {coffee.BeadingTime}, type: {coffee.CoffeeType}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
await consumerClient.CloseAsync();
}
}
public async Task CreateClients()
{
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
var eventHubName = _scope.EventHubName;
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
#region Snippet:EventHubs_Sample01_CreateClients
var producer = new EventHubProducerClient(connectionString, eventHubName);
var consumer = new EventHubConsumerClient(consumerGroup, connectionString, eventHubName);
#endregion
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(EventHubsTestEnvironment.Instance.TestExecutionTimeLimit);
await producer.CloseAsync(cancellationSource.Token).IgnoreExceptions();
await consumer.CloseAsync(cancellationSource.Token).IgnoreExceptions();
}
public async Task ReadAllPartitions()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample07_ReadAllPartitions
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = scope.EventHubName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using (CancellationTokenSource cancellationSource = new CancellationTokenSource())
{
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
int eventsRead = 0;
int maximumEvents = 50;
IAsyncEnumerator <PartitionEvent> iterator =
consumer.ReadEventsAsync(cancellationSource.Token).GetAsyncEnumerator();
try
{
while (await iterator.MoveNextAsync())
{
PartitionEvent partitionEvent = iterator.Current;
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
eventsRead++;
if (eventsRead >= maximumEvents)
{
break;
}
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await iterator.DisposeAsync();
}
}
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
public async Task ReadPartitionWaitTime()
{
await using var scope = await EventHubScope.CreateAsync(1);
#region Snippet:EventHubs_Sample05_ReadPartitionWaitTime
var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
/*@@*/
/*@@*/ connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = scope.EventHubName;
var consumer = new EventHubConsumerClient(
consumerGroup,
connectionString,
eventHubName);
try
{
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
string firstPartition = (await consumer.GetPartitionIdsAsync(cancellationSource.Token)).First();
EventPosition startingPosition = EventPosition.Earliest;
int loopTicks = 0;
int maximumTicks = 10;
var options = new ReadEventOptions
{
MaximumWaitTime = TimeSpan.FromSeconds(1)
};
await foreach (PartitionEvent partitionEvent in consumer.ReadEventsFromPartitionAsync(
firstPartition,
startingPosition,
options))
{
if (partitionEvent.Data != null)
{
string readFromPartition = partitionEvent.Partition.PartitionId;
byte[] eventBodyBytes = partitionEvent.Data.EventBody.ToArray();
Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { readFromPartition }");
}
else
{
Debug.WriteLine("Wait time elapsed; no event was available.");
}
loopTicks++;
if (loopTicks >= maximumTicks)
{
break;
}
}
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
await consumer.CloseAsync();
}
#endregion
}
internal void Close()
{
client.CloseAsync().Wait();
}
