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