/// <summary> /// Performs the tasks needed to initialize and set up the environment for an instance /// of the test scenario. When multiple instances are run in parallel, setup will be /// run once for each prior to its execution. /// </summary> /// public async override Task SetupAsync() { await base.SetupAsync(); // Attempt to take a consumer group from the available set; to ensure that the // test scenario can support the requested level of parallelism without violating // the concurrent reader limits of a consumer group, the default consumer group // should not be used. if (!ConsumerGroups.TryDequeue(out var consumerGroup)) { throw new InvalidOperationException("Unable to reserve a consumer group to read from."); } _receiver = new PartitionReceiver( consumerGroup, PartitionId, EventPosition.Earliest, TestEnvironment.EventHubsConnectionString, Scope.EventHubName); // Force the connection and link creation by reading a single event. await _receiver.ReceiveBatchAsync(1).ConfigureAwait(false); }
public async Task ReadPartitionWithReceiver() { #region Snippet:EventHubs_Sample05_ReadPartitionWithReceiver 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(); using CancellationTokenSource cancellationSource = new CancellationTokenSource(); cancellationSource.CancelAfter(TimeSpan.FromSeconds(30)); string firstPartition; await using (var producer = new EventHubProducerClient(connectionString, eventHubName)) { firstPartition = (await producer.GetPartitionIdsAsync()).First(); } var receiver = new PartitionReceiver( consumerGroup, firstPartition, EventPosition.Earliest, connectionString, eventHubName); try { while (!cancellationSource.IsCancellationRequested) { int batchSize = 50; TimeSpan waitTime = TimeSpan.FromSeconds(1); IEnumerable <EventData> eventBatch = await receiver.ReceiveBatchAsync( batchSize, waitTime, cancellationSource.Token); foreach (EventData eventData in eventBatch) { byte[] eventBodyBytes = eventData.EventBody.ToArray(); Debug.WriteLine($"Read event of length { eventBodyBytes.Length } from { firstPartition }"); } } } catch (TaskCanceledException) { // This is expected if the cancellation token is // signaled. } finally { await receiver.CloseAsync(); } #endregion }
/// <summary> /// yields a batch of global::Azure.Messaging.EventHubs.EventData from the // partition on which this receiver is created. Returns 'null' if no EventData is // present. /// </summary> /// <param name="maxMessageCount"></param> /// <param name="waitTime"></param> /// <returns></returns> public IEnumerable <EventData> Recieve(int numOfMessagesToDequeue, TimeSpan?waitTime) { IEnumerable <EventData> data = null; if (waitTime.HasValue) { // TODO some form of this is better if we get no partition id. /*var en = client.ReadEventsAsync().GetAsyncEnumerator(); * while (en.MoveNextAsync().Result) * { * var cur = en.Current; * * }*/ data = reciever.ReceiveBatchAsync(numOfMessagesToDequeue, waitTime.Value).Result; } else { data = reciever.ReceiveBatchAsync(numOfMessagesToDequeue).Result; } return(data); }
/// <summary> /// Executes the performance test scenario asynchronously. /// </summary> /// /// <param name="cancellationToken">The token used to signal when cancellation is requested.</param> /// public async override Task RunAsync(CancellationToken cancellationToken) { // Read the requested number of events. var remainingEvents = Options.Count; while ((!cancellationToken.IsCancellationRequested) && (remainingEvents > 0)) { remainingEvents -= (await _receiver.ReceiveBatchAsync(remainingEvents).ConfigureAwait(false)).Count(); } // If iteration stopped due to cancellation, ensure that the expected exception is thrown. cancellationToken.ThrowIfCancellationRequested(); }
public async Task <IEnumerable <EventData> > ReceiveAsync(int maxCount, TimeSpan waitTime) { return(await client.ReceiveBatchAsync(maxCount, waitTime)); }