async Task InvokeOnNull()
{
PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromEnd());
try
{
EventWaitHandle nullReceivedEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
var handler = new TestPartitionReceiveHandler();
handler.EventsReceived += (s, eventDatas) =>
{
if (eventDatas == null)
{
TestUtility.Log("Received null.");
nullReceivedEvent.Set();
}
};
partitionReceiver.SetReceiveHandler(handler, true);
if (!nullReceivedEvent.WaitOne(TimeSpan.FromSeconds(120)))
{
throw new InvalidOperationException("Did not receive null.");
}
}
finally
{
// Unregister handler.
partitionReceiver.SetReceiveHandler(null);
// Close clients.
await partitionReceiver.CloseAsync();
}
}
async Task DefaultBehaviorNoInvokeOnNull()
{
PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromEnd());
try
{
EventWaitHandle nullReceivedEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
EventWaitHandle dataReceivedEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
var handler = new TestPartitionReceiveHandler();
handler.EventsReceived += (s, eventDatas) =>
{
if (eventDatas == null)
{
TestUtility.Log("Received null.");
nullReceivedEvent.Set();
}
else
{
TestUtility.Log("Received message.");
dataReceivedEvent.Set();
}
};
partitionReceiver.SetReceiveHandler(handler);
if (nullReceivedEvent.WaitOne(TimeSpan.FromSeconds(120)))
{
throw new InvalidOperationException("Received null.");
}
// Send one message. Pump should receive this.
await TestUtility.SendToPartitionAsync(this.EventHubClient, "0", "new event");
if (!dataReceivedEvent.WaitOne(TimeSpan.FromSeconds(60)))
{
throw new InvalidOperationException("Data Received Event was not signaled.");
}
}
finally
{
// Unregister handler.
partitionReceiver.SetReceiveHandler(null);
// Close clients.
await partitionReceiver.CloseAsync();
}
}
public async Task ReceiveEventsAsync(
string deviceId,
Func <EventData, bool> onEventReceived,
CancellationToken token)
{
EventHubClient client = this.EventHubClient;
int count = (await client.GetRuntimeInformationAsync()).PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceId, count);
PartitionReceiver receiver = client.CreateReceiver("$Default", partition, EventPosition.FromEnd());
var result = new TaskCompletionSource <bool>();
using (token.Register(() => result.TrySetCanceled()))
{
receiver.SetReceiveHandler(
new PartitionReceiveHandler(
data =>
{
bool done = onEventReceived(data);
if (done)
{
result.TrySetResult(true);
}
return(done);
}));
await result.Task;
}
await receiver.CloseAsync();
}
async Task PartitionReceiverSetReceiveHandler()
{
Log("Receiving Events via PartitionReceiver.SetReceiveHandler()");
string partitionId = "1";
PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10));
PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId);
try
{
string uniqueEventId = Guid.NewGuid().ToString();
Log($"Sending an event to Partition {partitionId} with custom property EventId {uniqueEventId}");
var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!"));
sendEvent.Properties = new Dictionary <string, object> {
["EventId"] = uniqueEventId
};
await partitionSender.SendAsync(sendEvent);
EventWaitHandle dataReceivedEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
var handler = new TestPartitionReceiveHandler();
handler.ErrorReceived += (s, e) => Log($"TestPartitionReceiveHandler.ProcessError {e.GetType().Name}: {e.Message}");
handler.EventsReceived += (s, eventDatas) =>
{
int count = eventDatas != null?eventDatas.Count() : 0;
Log($"Received {count} event(s):");
foreach (var eventData in eventDatas)
{
object objectValue;
if (eventData.Properties != null && eventData.Properties.TryGetValue("EventId", out objectValue))
{
Log($"Received message with EventId {objectValue}");
string receivedId = objectValue.ToString();
if (receivedId == uniqueEventId)
{
Log("Success");
dataReceivedEvent.Set();
break;
}
}
}
};
partitionReceiver.SetReceiveHandler(handler);
if (!dataReceivedEvent.WaitOne(TimeSpan.FromSeconds(20)))
{
throw new InvalidOperationException("Data Received Event was not signaled.");
}
}
finally
{
await partitionSender.CloseAsync();
await partitionReceiver.CloseAsync();
}
}
private async Task StartListeners()
{
var ehRuntime = await _eventHubClient.GetRuntimeInformationAsync();
foreach (var partitionId in ehRuntime.PartitionIds)
{
var cp = _checkpoint.Get($"{Constants.EventHubCheckpoint}.{_storeConfig.EventHubName}.{partitionId}");
_receiver = _eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromOffset(cp ?? "-1"));
_receiver.SetReceiveHandler(_storeReceiver);
}
}
static async Task ReceiveMessagesAsync(DateTime lastReceivedMesssage)
{
var builder = new EventHubsConnectionStringBuilder(Settings.Current.EventHubConnectionString);
Logger.LogInformation($"Receiving events from device '{Settings.Current.DeviceId}' on Event Hub '{builder.EntityPath}' with last received message at {lastReceivedMesssage.ToString()}");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
Settings.Current.ConsumerGroupId,
EventHubPartitionKeyResolver.ResolveToPartition(Settings.Current.DeviceId, (await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(lastReceivedMesssage == DateTime.MinValue ? DateTime.UtcNow : lastReceivedMesssage));
eventHubReceiver.SetReceiveHandler(new PartitionReceiveHandler(Settings.Current.DeviceId, Settings.Current.ExcludedModuleIds));
}
static async Task ReceiveMessages()
{
var builder = new EventHubsConnectionStringBuilder(Settings.Current.EventHubConnectionString);
Log.LogInformation($"Receiving events from device '{Settings.Current.DeviceId}' on Event Hub '{builder.EntityPath}'");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
"$Default",
EventHubPartitionKeyResolver.ResolveToPartition(Settings.Current.DeviceId, (await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(DateTime.UtcNow));
eventHubReceiver.SetReceiveHandler(new PartitionReceiveHandler(Settings.Current.DeviceId, Settings.Current.ExcludedModuleIds));
}
/// <inheritdoc />
public BoolResult StartProcessing(OperationContext context, EventSequencePoint sequencePoint, IPartitionReceiveHandler processor)
{
Tracer.Info(context, $"{Tracer.Name}: Initializing event processing for event hub '{_configuration.EventHubName}' and consumer group '{_configuration.ConsumerGroupName}'.");
if (_partitionReceiver == null)
{
_partitionReceiver = _eventHubClient.CreateReceiver(
_configuration.ConsumerGroupName,
PartitionId,
GetInitialOffset(context, sequencePoint),
new ReceiverOptions()
{
Identifier = _hostName
});
_partitionReceiver.SetReceiveHandler(processor);
}
return(BoolResult.Success);
}
protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
this.logger.LogInformation("Test Result Event Receiving Service running.");
DateTime eventEnqueuedFrom = DateTime.UtcNow;
var builder = new EventHubsConnectionStringBuilder(Settings.Current.EventHubConnectionString);
this.logger.LogDebug($"Receiving events from device '{Settings.Current.DeviceId}' on Event Hub '{builder.EntityPath}' enqueued on or after {eventEnqueuedFrom}");
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
Settings.Current.ConsumerGroupName,
EventHubPartitionKeyResolver.ResolveToPartition(Settings.Current.DeviceId, (await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(eventEnqueuedFrom));
eventHubReceiver.SetReceiveHandler(new PartitionReceiveHandler(Settings.Current.TrackingId, Settings.Current.DeviceId, this.storage));
await cancellationToken.WhenCanceled();
this.logger.LogInformation($"Finish ExecuteAsync method in {nameof(TestResultEventReceivingService)}");
}
public async Task ReceiveEventsAsync(
string deviceId,
DateTime seekTime,
Func <EventData, bool> onEventReceived,
CancellationToken token)
{
EventHubClient client = this.EventHubClient;
int count = (await client.GetRuntimeInformationAsync()).PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceId, count);
seekTime = seekTime.ToUniversalTime().Subtract(TimeSpan.FromMinutes(2)); // substract 2 minutes to account for client/server drift
EventPosition position = EventPosition.FromEnqueuedTime(seekTime);
PartitionReceiver receiver = client.CreateReceiver("$Default", partition, position);
var result = new TaskCompletionSource <bool>();
using (token.Register(() => result.TrySetCanceled()))
{
receiver.SetReceiveHandler(
new PartitionReceiveHandler(
data =>
{
bool done = onEventReceived(data);
if (done)
{
result.TrySetResult(true);
}
return(done);
}));
await result.Task;
}
await receiver.CloseAsync();
}
async Task ReceiveHandlerReregister()
{
int totalNumberOfMessagesToSend = 100;
string partitionId = "0";
var pInfo = await this.EventHubClient.GetPartitionRuntimeInformationAsync(partitionId);
PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromOffset(pInfo.LastEnqueuedOffset));
await TestUtility.SendToPartitionAsync(this.EventHubClient, partitionId, $"{partitionId} event.", totalNumberOfMessagesToSend);
try
{
var handler = new TestPartitionReceiveHandler();
handler.MaxBatchSize = 1;
// Not expecting any errors.
handler.ErrorReceived += (s, e) =>
{
// SetReceiveHandler will ignore any exception thrown so log here for output.
TestUtility.Log($"TestPartitionReceiveHandler.ProcessError {e.GetType().Name}: {e.Message}");
throw new Exception($"TestPartitionReceiveHandler.ProcessError {e.GetType().Name}: {e.Message}");
};
int totalnumberOfMessagesReceived = 0;
handler.EventsReceived += (s, eventDatas) =>
{
int count = eventDatas != null?eventDatas.Count() : 0;
Interlocked.Add(ref totalnumberOfMessagesReceived, count);
TestUtility.Log($"Received {count} event(s).");
};
TestUtility.Log("Registering");
partitionReceiver.SetReceiveHandler(handler);
TestUtility.Log("Unregistering");
partitionReceiver.SetReceiveHandler(null);
TestUtility.Log("Registering");
partitionReceiver.SetReceiveHandler(handler);
await Task.Delay(3000);
// Second register call will trigger error handler but throw from handler should be ignored
// so below register call should not fail.
TestUtility.Log("Registering when already registered");
partitionReceiver.SetReceiveHandler(handler);
TestUtility.Log("All register calls done.");
// Send another set of messages.
// Since handler is still registered we should be able to receive these messages just fine.
await TestUtility.SendToPartitionAsync(this.EventHubClient, partitionId, $"{partitionId} event.", totalNumberOfMessagesToSend);
// Allow 1 minute to receive all messages.
await Task.Delay(TimeSpan.FromSeconds(60));
TestUtility.Log($"Received {totalnumberOfMessagesReceived}.");
Assert.True(totalnumberOfMessagesReceived == totalNumberOfMessagesToSend * 2, $"Did not receive {totalNumberOfMessagesToSend * 2} messages, received {totalnumberOfMessagesReceived}.");
}
finally
{
// Unregister handler.
partitionReceiver.SetReceiveHandler(null);
// Close clients.
await partitionReceiver.CloseAsync();
}
}