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