private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
while (true)
{
var events = await eventHubReceiver.ReceiveAsync(100);
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
Console.WriteLine($"Message received: {data}");
//Console.WriteLine("Application properties (set by device):");
//foreach (var prop in eventData.Properties)
//{
// Console.WriteLine(" {0}: {1}", prop.Key, prop.Value);
//}
//Console.WriteLine("System properties (set by IoT Hub):");
//foreach (var prop in eventData.SystemProperties)
//{
// Console.WriteLine(" {0}: {1}", prop.Key, prop.Value);
//}
}
}
}
private static async Task ReceiveMessagesFromPartition(string partition, CancellationToken ct)
{
receiver = eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partition, EventPosition.FromEnqueuedTime(DateTime.Now));
Console.WriteLine($"Connected to partition {receiver.PartitionId}, consumer group {receiver.ConsumerGroupName}");
while (true)
{
if (ct.IsCancellationRequested)
{
return;
}
// Receive a maximum of 100 messages in this call to ReceiveAsync
var ehEvents = await receiver.ReceiveAsync(100);
// ReceiveAsync can return null if there are no messages
if (ehEvents != null)
{
// Since ReceiveAsync can return more than a single event you will need a loop to process
foreach (var ehEvent in ehEvents)
{
// Decode the byte array segment
var message = UnicodeEncoding.UTF8.GetString(ehEvent.Body.Array);
Console.WriteLine($"Received. '{message}'");
}
}
}
}
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();
}
// Asynchronously create a PartitionReceiver for a partition and then start reading any messages sent from the simulated client.
private static async Task ReceiveMessagesFromDeviceAsync(string partition)
{
// Create the receiver using the default consumer group.
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
Console.WriteLine("Created receiver on partition: " + partition);
while (true)
{
// Check for EventData - this methods times out if there is nothing to retrieve.
var events = await eventHubReceiver.ReceiveAsync(100);
// If there is data in the batch, process it.
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
greenMessage("Telemetry received: " + data);
foreach (var prop in eventData.Properties)
{
if (prop.Value.ToString() == "true")
{
redMessage(prop.Key);
}
}
Console.WriteLine();
}
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
Console.WriteLine("Create receiver on partition: " + partition);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var events = await eventHubReceiver.ReceiveAsync(100);
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
Console.WriteLine("Message received on partition {0}:", partition);
var temperature = double.Parse(data, System.Globalization.CultureInfo.InvariantCulture);
var deviceId = eventData.SystemProperties["iothub-connection-device-id"].ToString();
Console.WriteLine($"Device: {deviceId} - data: {temperature}");
}
}
}
private async Task <PartitionReceiver> CreateEventHubReceiver(string deviceName)
{
PartitionReceiver eventHubReceiver = null;
Stopwatch sw = new Stopwatch();
sw.Start();
var builder = new EventHubsConnectionStringBuilder(Configuration.IoTHub.EventHubString)
{
EntityPath = Configuration.IoTHub.EventHubCompatibleName
};
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
var eventRuntimeInformation = await eventHubClient.GetRuntimeInformationAsync().ConfigureAwait(false);
var eventHubPartitionsCount = eventRuntimeInformation.PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceName, eventHubPartitionsCount);
string consumerGroupName = Configuration.IoTHub.EventHubConsumerGroup;
while (eventHubReceiver == null && sw.Elapsed.Minutes < 1)
{
try
{
eventHubReceiver = eventHubClient.CreateReceiver(consumerGroupName, partition, DateTime.Now.AddMinutes(-5));
}
catch (QuotaExceededException ex)
{
Debug.WriteLine(ex);
}
}
sw.Stop();
return(eventHubReceiver);
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken cancellationToken)
{
var eventHubReceiver = _eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partition, EventPosition.FromEnd());
while (true)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
var eventData = await eventHubReceiver.ReceiveAsync(1);
if (eventData == null)
{
continue;
}
foreach (var d in eventData)
{
var data = Encoding.UTF8.GetString(d.Body);
Console.WriteLine($"{d.SystemProperties["iothub-connection-device-id"]}: {data}");
//Console.WriteLine("Message received. Partition: {0} Data: '{1}'", partition, data);
}
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = _eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var events = await eventHubReceiver.ReceiveAsync(100);
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
if (data == "loaded")
{
_eventReceived.Set();
break;
}
}
}
}
private async Task ReceiveMessagesFromDeviceAsync(string partitionId, CancellationToken ct)
{
var eventHubReceiver = EventHubClientConnector
.CreateReceiver(
PartitionReceiver.DefaultConsumerGroupName, partitionId, PartitionReceiver.EndOfStream);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var eventData = await eventHubReceiver.ReceiveAsync(100);
if (eventData == null)
{
continue;
}
foreach (var eventDat in eventData)
{
string data = Encoding.UTF8.GetString(eventDat.Body.Array);
Debug.WriteLine("Message received. Partition: {0} Data: '{1}'", partitionId, data);
foreach (var receiver in Receivers)
{
Debug.WriteLine("Processing success: " + receiver(data));
}
}
}
Debug.WriteLine("Cancel Receiver task");
}
public override async void StartListening()
{
try
{
var connectionString =
new EventHubsConnectionStringBuilder(
new Uri(GapConfig.EventHubsCompatibleEndpoint),
GapConfig.EventHubsCompatiblePath,
GapConfig.IotHubSasKeyName,
GapConfig.IotHubSasKey);
eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString());
// Create a PartitionReciever for each partition on the hub.
var runtimeInfo = await eventHubClient.GetRuntimeInformationAsync();
var d2cPartitions = runtimeInfo.PartitionIds;
// TODO: listening on partition 0 only.
receivers =
d2cPartitions
.Select(d2c => eventHubClient.CreateReceiver("$Default", d2c, EventPosition.FromEnqueuedTime(DateTime.Now)))
.ToList();
listenerTimer = ThreadPoolTimer.CreatePeriodicTimer(BackgoundListen, timerPeriod);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
/// <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().ConfigureAwait(false);
// 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 (!s_consumerGroups.TryDequeue(out var consumerGroup))
{
throw new InvalidOperationException("Unable to reserve a consumer group to read from.");
}
_client = EventHubClient.CreateFromConnectionString(TestUtility.BuildEventHubsConnectionString(s_scope.EventHubName));
_partitionId = (await _client.GetRuntimeInformationAsync().ConfigureAwait(false)).PartitionIds[0];
_receiver = _client.CreateReceiver(
consumerGroup,
_partitionId,
EventPosition.FromStart());
// Force the connection and link creation by reading a single event.
await _receiver.ReceiveAsync(1).ConfigureAwait(false);
}
// Asynchronously create a PartitionReceiver for a partition and then start
// reading any messages sent from the simulated client.
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
// Create the receiver using the default consumer group.
// For the purposes of this sample, read only messages sent since
// the time the receiver is created. Typically, you don't want to skip any messages.
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
Console.WriteLine("Create receiver on partition: " + partition);
while (true)
{
if (ct.IsCancellationRequested) break;
Console.WriteLine("Listening for messages on: " + partition);
// Check for EventData - this methods times out if there is nothing to retrieve.
var events = await eventHubReceiver.ReceiveAsync(100);
// If there is data in the batch, process it.
if (events == null) continue;
foreach(EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
Console.WriteLine("Message received on partition {0}:", partition);
Console.WriteLine(" {0}:", data);
Console.WriteLine("Application properties (set by device):");
foreach (var prop in eventData.Properties)
{
Console.WriteLine(" {0}: {1}", prop.Key, prop.Value);
}
Console.WriteLine("System properties (set by IoT Hub):");
foreach (var prop in eventData.SystemProperties)
{
Console.WriteLine(" {0}: {1}", prop.Key, prop.Value);
}
}
}
}
// Asynchronously create a PartitionReceiver for a partition and then start
// reading any messages sent from the simulated client.
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
// Create the receiver using the default consumer group.
// For the purposes of this sample, read only messages sent since
// the time the receiver is created. Typically, you don't want to skip any messages.
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var events = await eventHubReceiver.ReceiveAsync(100);
// If there is data in the batch, process it.
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
Console.WriteLine(" {0}:", data);
}
}
}
private static async Task <IEventHubReceiver> CreateReceiver(EventHubPartitionSettings partitionSettings, string offset, Logger logger, ITelemetryProducer telemetryProducer)
{
bool offsetInclusive = true;
var connectionStringBuilder = new EventHubsConnectionStringBuilder(partitionSettings.Hub.ConnectionString)
{
EntityPath = partitionSettings.Hub.Path
};
EventHubClient client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
// if we have a starting offset or if we're not configured to start reading from utc now, read from offset
if (!partitionSettings.Hub.StartFromNow ||
offset != EventHubConstants.StartOfStream)
{
logger.Info("Starting to read from EventHub partition {0}-{1} at offset {2}", partitionSettings.Hub.Path, partitionSettings.Partition, offset);
}
else
{
// to start reading from most recent data, we get the latest offset from the partition.
EventHubPartitionRuntimeInformation partitionInfo =
await client.GetPartitionRuntimeInformationAsync(partitionSettings.Partition);
offset = partitionInfo.LastEnqueuedOffset;
offsetInclusive = false;
logger.Info("Starting to read latest messages from EventHub partition {0}-{1} at offset {2}", partitionSettings.Hub.Path, partitionSettings.Partition, offset);
}
PartitionReceiver receiver = client.CreateReceiver(partitionSettings.Hub.ConsumerGroup, partitionSettings.Partition, offset, offsetInclusive);
if (partitionSettings.Hub.PrefetchCount.HasValue)
{
receiver.PrefetchCount = partitionSettings.Hub.PrefetchCount.Value;
}
return(new EventHubReceiverProxy(receiver));
}
public async Task Connect()
{
if (Connected)
{
return;
}
await SemaphoreSlim.WaitAsync();
if (Connected)
{
return;
}
try
{
var runTimeInformation = await _eventHubClient.GetRuntimeInformationAsync();
foreach (var partitionId in runTimeInformation.PartitionIds)
{
var receiver = _eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromEnd());
_receivers.Add(receiver);
}
_timer = new Timer(1000)
{
AutoReset = true
};
_timer.Elapsed += Poll;
_timer.Start();
Connected = true;
}
finally
{
SemaphoreSlim.Release();
}
}
public async Task <List <EventData> > GetMessagesForDevice(string deviceId, DateTime startTime, int maxPerPartition = 100, int waitTimeSecs = 5)
{
var messages = new List <EventData>();
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(this.eventHubConnectionString);
PartitionReceiver partitionReceiver = eventHubClient.CreateReceiver(
EventHubConsumerGroup,
EventHubPartitionKeyResolver.ResolveToPartition(deviceId, (await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(startTime));
// Retry a few times due to weird behavior with ReceiveAsync() not returning all messages available
for (int i = 0; i < 3; i++)
{
IEnumerable <EventData> events = await partitionReceiver.ReceiveAsync(maxPerPartition, TimeSpan.FromSeconds(waitTimeSecs));
if (events != null)
{
messages.AddRange(events);
}
if (i < 3)
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
await partitionReceiver.CloseAsync();
await eventHubClient.CloseAsync();
return(messages);
}
private async Task ReceiveMessagesFromPartitionAsync(string partition, CancellationToken ct)
{
// Create the receiver using the default consumer group.
var getMessagesSince = DateTime.UtcNow.AddDays(-1);
var eventHubReceiver = _eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(getMessagesSince));
_logger.LogInformation($"Creating a receiver on partition {partition}");
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
_logger.LogDebug($"Listening for messages on {partition}");
var events = await eventHubReceiver.ReceiveAsync(100);
if (events == null)
{
continue;
}
foreach (var eventData in events)
{
Guid.TryParse(eventData.SystemProperties["iothub-connection-device-id"].ToString(), out var deviceId);
var message = GetMessageContent(eventData);
_actorSystem.SendMeasurement(deviceId, message);
}
}
}
private async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
// Check for EventData - this methods times out if there is nothing to retrieve.
var events = await eventHubReceiver.ReceiveAsync(100);
// If there is data in the batch, process it.
if (events == null)
{
continue;
}
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
//Console.WriteLine("Message received on partition {0}:", partition);
//Console.WriteLine(" {0}:", data);
textBox1.AppendText(data);
}
}
}
public static async Task <EventHubTestListener> CreateListenerPal(string deviceName)
{
PartitionReceiver receiver = null;
Stopwatch sw = new Stopwatch();
sw.Start();
var builder = new EventHubsConnectionStringBuilder(Configuration.IoTHub.EventHubString)
{
EntityPath = Configuration.IoTHub.EventHubCompatibleName
};
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
var eventRuntimeInformation = await eventHubClient.GetRuntimeInformationAsync().ConfigureAwait(false);
var eventHubPartitionsCount = eventRuntimeInformation.PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceName, eventHubPartitionsCount);
string consumerGroupName = Configuration.IoTHub.EventHubConsumerGroup;
while (receiver == null && sw.Elapsed.TotalMinutes < MaximumWaitTimeInMinutes)
{
try
{
receiver = eventHubClient.CreateReceiver(consumerGroupName, partition, DateTime.Now.AddMinutes(-5));
}
catch (QuotaExceededException ex)
{
s_log.WriteLine($"{nameof(EventHubTestListener)}.{nameof(CreateListener)}: Cannot create receiver: {ex}");
}
}
sw.Stop();
return(new EventHubTestListener(receiver));
}
public static void CreateListenerPalAndReceiveMessages()
{
var builder = new EventHubsConnectionStringBuilder(Configuration.IoTHub.EventHubString)
{
EntityPath = Configuration.IoTHub.EventHubCompatibleName
};
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
var eventRuntimeInformation = eventHubClient.GetRuntimeInformationAsync().Result;
var eventHubPartitionsCount = eventRuntimeInformation.PartitionCount;
string consumerGroupName = Configuration.IoTHub.EventHubConsumerGroup;
foreach (string partitionId in eventRuntimeInformation.PartitionIds)
{
try
{
PartitionReceiver receiver = eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.Now.AddMinutes(-LookbackTimeInMinutes));
s_log.WriteLine($"EventHub receiver created for partition {partitionId}, listening from {LookbackTimeInMinutes}");
new Task(async() =>
{
while (true)
{
IEnumerable <EventData> eventDatas = await receiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(OperationTimeoutInSeconds)).ConfigureAwait(false);
ProcessEventData(eventDatas);
}
}).Start();
}
catch (EventHubsException ex)
{
s_log.WriteLine($"{nameof(EventHubTestListener)}.{nameof(CreateListenerPalAndReceiveMessages)}: Cannot create receiver for partitionID {partitionId}: {ex}");
}
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
var eventHubReceiver = eventHubClient.CreateReceiver("receive", partition, EventPosition.FromEnqueuedTime(DateTime.Now.AddMinutes(-10)));
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var events = await eventHubReceiver.ReceiveAsync(20);
if (events != null)
{
foreach (EventData eventData in events)
{
var data = JObject.Parse(Encoding.UTF8.GetString(eventData.Body.Array));
var label = GameObject.Find(data["alias"].ToString()).GetComponent <Text>();
label.text = data["alias"]
+ "\n" + data["temperature"].ToString() + " °C / " + data["humidity"].ToString() + "%";
Debug.Log(data);
}
}
}
}
private static async Task ReceiveMessagesFromDeviceAsync(string partition, CancellationToken ct)
{
// Create the receiver using the default consumer group.
// For the purposes of this sample, read only messages sent since
// the time the receiver is created. Typically, you don't want to skip any messages.
var eventHubReceiver = s_eventHubClient.CreateReceiver("$Default", partition, EventPosition.FromEnqueuedTime(DateTime.Now));
Console.WriteLine("Create receiver on partition: " + partition);
//while (true)
//{
//if (ct.IsCancellationRequested) break;
Console.WriteLine("Listening for messages on: " + partition);
// Check for EventData - this methods times out if there is nothing to retrieve.
var events = await eventHubReceiver.ReceiveAsync(100);
// If there is data in the batch, process it.
//if (events == null) continue;
foreach (EventData eventData in events)
{
string data = Encoding.UTF8.GetString(eventData.Body.Array);
//Console.WriteLine("Message received on partition {0}:", partition);
Console.WriteLine(" {0}:", data);
WorkerModel workerModel = new WorkerModel();
workerModel = JsonConvert.DeserializeObject <WorkerModel>(data);
lstWorkerModels.Add(workerModel);
}
//}
}
protected async Task VerifyDataOnIoTHub(string moduleId)
{
Console.WriteLine($"Verifying data on IoTHub from {moduleId}");
// First Verify if module is already running.
await this.bootstrapper.VerifyModuleIsRunning(moduleId);
var builder = new EventHubsConnectionStringBuilder(this.eventhubCompatibleEndpointWithEntityPath)
{
TransportType = this.eventHubClientTransportType
};
Console.WriteLine($"Receiving events from device '{this.context.DeviceId}' on Event Hub '{builder.EntityPath}'");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
this.proxy.ForEach(p => eventHubClient.WebProxy = p);
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
"$Default",
EventHubPartitionKeyResolver.ResolveToPartition(
this.context.DeviceId,
(await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnd());
// TODO: [Improvement] should verify test results without using event hub, which introduce latency.
var result = new TaskCompletionSource <bool>();
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(20))) // This long timeout is needed in case event hub is slow to process messages
{
using (cts.Token.Register(() => result.TrySetCanceled()))
{
eventHubReceiver.SetReceiveHandler(
new PartitionReceiveHandler(
eventData =>
{
eventData.SystemProperties.TryGetValue("iothub-connection-device-id", out object devId);
eventData.SystemProperties.TryGetValue("iothub-connection-module-id", out object modId);
if (devId != null && devId.ToString().Equals(this.context.DeviceId) &&
modId != null && modId.ToString().Equals(moduleId))
{
result.TrySetResult(true);
return(true);
}
return(false);
}));
await result.Task;
}
}
Console.WriteLine("VerifyDataOnIoTHub completed.");
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
}
private async Task <PartitionReceiver> SetupWithCheckpointAsync(string consumerGroup, string partitionId)
{
string?offset = await _checkpointer.GetCheckpointAsync(partitionId);
EventPosition position;
if (string.IsNullOrEmpty(offset))
{
position = EventPosition.FromStart();
}
else
{
position = EventPosition.FromOffset(offset, false);
}
return(_client.CreateReceiver(consumerGroup, partitionId, position));
}
public async Task LoadData()
{
//Deserialize last received message
using (SerializeDataOnFile sdf = new SerializeDataOnFile(this.FileNameSerializeLastOffset))
{
Dictionary <string, object> lastRowValuesAsObjects = sdf.GetDictionary();
lastRowValues = new Dictionary <string, LastReceivedMessage>();
foreach (var item in lastRowValuesAsObjects)
{
LastReceivedMessage lastItem;
lastItem.EnqueuedOffset = Convert.ToInt64(((string)item.Value).Split(',')[0]);
lastItem.EnqueuedTimeUtc = Convert.ToDateTime(((string)item.Value).Split(',')[1]);
lastRowValues.Add(item.Key, lastItem);
}
}
//Load
receivedRows = new List <RowRead>();
var connectionStringBuilder = new EventHubsConnectionStringBuilder(this.ConnectionStringEventHubCompatible)
{
EntityPath = this.EntityEventHubCompatible
};
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
var runTimeInformation = await eventHubClient.GetRuntimeInformationAsync();
foreach (string partition in runTimeInformation.PartitionIds)
{
// It checks if lastRowValues contains for current partition last received message
if (!lastRowValues.ContainsKey(partition))
{
LastReceivedMessage lastReceivedMessage;
lastReceivedMessage.EnqueuedTimeUtc = this.StartTimeInHours == 0 ? DateTime.UtcNow.AddHours(-24) : DateTime.UtcNow.AddHours(this.StartTimeInHours);
lastReceivedMessage.EnqueuedOffset = -1; //Starting offset for EventHub. Note: For IoT Hub, starting offset is 0.
lastRowValues.Add(partition, lastReceivedMessage);
}
// Receiving
var receiver = eventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partition, lastRowValues[partition].EnqueuedOffset.ToString());
await ReceiveMessagesFromDeviceAsync(receiver);
}
valuesRead = receivedRows.ToArray();
//Serialize last received message
using (SerializeDataOnFile sdf = new SerializeDataOnFile(this.FileNameSerializeLastOffset))
{
Dictionary <string, object> lastRowValuesAsObjects = new Dictionary <string, object>();
foreach (var item in lastRowValues)
{
lastRowValuesAsObjects.Add(item.Key, $"{item.Value.EnqueuedOffset},{item.Value.EnqueuedTimeUtc}");
}
sdf.SetDictionary(lastRowValuesAsObjects);
}
}
protected async Task VerifyDataOnIoTHubAsync()
{
// Leaf device without parent not expected to send messages
if (!this.edgeDeviceId.HasValue)
{
return;
}
var builder = new EventHubsConnectionStringBuilder(this.eventhubCompatibleEndpointWithEntityPath)
{
TransportType = this.eventHubClientTransportType
};
Console.WriteLine($"Receiving events from device '{this.context.Device.Id}' on Event Hub '{builder.EntityPath}'");
EventHubClient eventHubClient =
EventHubClient.CreateFromConnectionString(builder.ToString());
this.proxy.ForEach(p => eventHubClient.WebProxy = p);
PartitionReceiver eventHubReceiver = eventHubClient.CreateReceiver(
"$Default",
EventHubPartitionKeyResolver.ResolveToPartition(
this.context.Device.Id,
(await eventHubClient.GetRuntimeInformationAsync()).PartitionCount),
EventPosition.FromEnqueuedTime(DateTime.Now.AddMinutes(-5)));
var result = new TaskCompletionSource <bool>();
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(3)))
{
using (cts.Token.Register(() => result.TrySetCanceled()))
{
eventHubReceiver.SetReceiveHandler(
new PartitionReceiveHandler(
eventData =>
{
eventData.SystemProperties.TryGetValue("iothub-connection-device-id", out var devId);
if (devId != null && devId.ToString().Equals(this.context.Device.Id, StringComparison.Ordinal) &&
Encoding.UTF8.GetString(eventData.Body).Contains(this.context.MessageGuid, StringComparison.Ordinal))
{
result.TrySetResult(true);
return(true);
}
return(false);
}));
await result.Task;
}
}
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
}
void InitPartitions(EventHubClient client)
{
string[] partitionList = client.GetRuntimeInformationAsync().Result.PartitionIds;
foreach (string partitionId in partitionList)
{
var receiver = client.CreateReceiver("$default", partitionId, PartitionReceiver.EndOfStream);
receiver.SetReceiveHandler(this);
}
}
// Send and receive given event on given partition.
protected async Task <EventData> SendAndReceiveEventAsync(string partitionId, EventData sendEvent, EventHubClient client)
{
PartitionSender partitionSender = client.CreatePartitionSender(partitionId);
PartitionReceiver partitionReceiver = client.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromEnqueuedTime(DateTime.UtcNow.AddMinutes(-10)));
EventData receivedEvent = null;
try
{
string uniqueEventId = Guid.NewGuid().ToString();
TestUtility.Log($"Sending event to Partition {partitionId} with custom property EventId {uniqueEventId}");
sendEvent.Properties["EventId"] = uniqueEventId;
await partitionSender.SendAsync(sendEvent);
bool expectedEventReceived = false;
do
{
IEnumerable <EventData> eventDatas = await partitionReceiver.ReceiveAsync(10);
if (eventDatas == null)
{
break;
}
TestUtility.Log($"Received a batch of {eventDatas.Count()} events:");
foreach (var eventData in eventDatas)
{
object objectValue;
if (eventData.Properties != null && eventData.Properties.TryGetValue("EventId", out objectValue))
{
TestUtility.Log($"Received message with EventId {objectValue}");
string receivedId = objectValue.ToString();
if (receivedId == uniqueEventId)
{
TestUtility.Log("Success");
receivedEvent = eventData;
expectedEventReceived = true;
break;
}
}
}
}while (!expectedEventReceived);
Assert.True(expectedEventReceived, $"Did not receive expected event with EventId {uniqueEventId}");
}
finally
{
await Task.WhenAll(
partitionReceiver.CloseAsync(),
partitionSender.CloseAsync());
}
return(receivedEvent);
}
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);
}
}
private async Task <PartitionReceiver> CreateEventHubReceiver(string deviceName)
{
string endpoint = Configuration.IoTHub.EventHubString;
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(endpoint);
var eventHubRuntime = await eventHubClient.GetRuntimeInformationAsync().ConfigureAwait(false);
var eventHubPartitionsCount = eventHubRuntime.PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceName, eventHubPartitionsCount);
string consumerGroupName = Configuration.IoTHub.ConsumerGroup;
return(eventHubClient.CreateReceiver(consumerGroupName, partition, DateTime.Now.AddMinutes(-5)));
}