private async Task SendMessageRecovery(Client.TransportType transport,
string faultType, string reason, int delayInSec, int durationInSec = 0, int retryDurationInMilliSec = 240000)
{
await sequentialTestSemaphore.WaitAsync();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
deviceClient.OperationTimeoutInMilliseconds = (uint)retryDurationInMilliSec;
await deviceClient.OpenAsync();
string payload, p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
// send error command and clear eventHubReceiver of the fault injection message
await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(faultType, reason, delayInSec,
durationInSec));
await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
Thread.Sleep(1000);
testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
sw.Reset();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
await deviceClient.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
sequentialTestSemaphore.Release(1);
}
private async void MonitorEventHubAsync(DateTime startTime, CancellationToken ct, string consumerGroupName)
{
EventHubClient eventHubClient = null;
EventHubReceiver eventHubReceiver = null;
try
{
eventHubClient = EventHubClient.CreateFromConnectionString(activeIoTHubConnectionString, "messages/events");
int eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceID, eventHubPartitionsCount);
eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(partition, startTime);
//receive the events from startTime until current time in a single call and process them
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(20));
foreach (var eventData in events)
{
byte[] rxbuff = eventData.GetBytes();
makeCommDataForLogData("Rx", rxbuff);
}
//having already received past events, monitor current events in a loop
while (true)
{
ct.ThrowIfCancellationRequested();
var eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(0.5));
if (eventData != null)
{
byte[] rxbuff = eventData.GetBytes();
makeCommDataForLogData("Rx", rxbuff);
}
}
}
catch (Exception ex)
{
if (ct.IsCancellationRequested)
{
//Stopped Monitoring events by user action.
}
else
{
//Something happen.
}
if (eventHubReceiver != null)
{
eventHubReceiver.Close();
}
if (eventHubClient != null)
{
eventHubClient.Close();
}
}
}
private async void MonitorEventHubAsync(DateTime startTime, CancellationToken ct, string consumerGroupName)
{
EventHubClient eventHubClient = null;
EventHubReceiver eventHubReceiver = null;
try
{
eventHubClient = EventHubClient.CreateFromConnectionString(activeIoTHubConnectionString, "messages/events");
eventHubTextBox.Text = String.Format("Receiving events...\r\n");
eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceIDsComboBoxForEvent.SelectedItem.ToString(), eventHubPartitionsCount);
eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(partition, startTime);
while (true)
{
ct.ThrowIfCancellationRequested();
EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(1));
if (eventData != null)
{
string data = Encoding.UTF8.GetString(eventData.GetBytes());
DateTime enqueuedTime = eventData.EnqueuedTimeUtc.ToLocalTime();
eventHubTextBox.Text += String.Format("{0}> Data:[{1}]", enqueuedTime, data);
if (eventData.Properties.Count > 0)
{
eventHubTextBox.Text += "Properties:\r\n";
foreach (var property in eventData.Properties)
{
eventHubTextBox.Text += String.Format("'{0}': '{1}'\r\n", property.Key, property.Value);
}
}
eventHubTextBox.Text += "\r\n";
}
}
}
catch (Exception ex)
{
if (ct.IsCancellationRequested)
{
eventHubTextBox.Text += String.Format("Stopped Monitoring events. {0}\r\n", ex.Message);
}
else
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
eventHubTextBox.Text += String.Format("Stopped Monitoring events. {0}\r\n", ex.Message);
}
if (eventHubReceiver != null)
{
eventHubReceiver.Close();
}
if (eventHubClient != null)
{
eventHubClient.Close();
}
dataMonitorButton.Enabled = true;
deviceIDsComboBoxForEvent.Enabled = true;
cancelMonitoringButton.Enabled = false;
}
}
public static async Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
List <string> eneryString = new List <string>();
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
if (data.StartsWith("ambulance"))
{
string[] value = data.Split(',');
LoadAmbulanceData(value[0], Convert.ToDouble(value[1]), Convert.ToDouble(value[2]));
}
if (data.StartsWith("Medical_IOT"))
{
string[] patientData = data.Split(',');
AnalysePatientData(patientData[0], patientData[1], patientData[2], patientData[3], patientData[4]);
}
Console.WriteLine(data);
}
}
public void Run(string connectionString, string hubName)
{
NamespaceManager nsmgr = NamespaceManager.CreateFromConnectionString(connectionString);
EventHubDescription desc = nsmgr.GetEventHub(hubName);
string consumerGroupName = _consumerGroupPrefix + DateTime.UtcNow.Ticks.ToString();
ConsumerGroupDescription consumerGroupDesc = nsmgr.CreateConsumerGroupIfNotExists(new ConsumerGroupDescription(hubName, consumerGroupName));
EventHubClient client = EventHubClient.CreateFromConnectionString(connectionString, hubName);
int numPartitions = desc.PartitionCount;
_receivers = new EventHubReceiver[numPartitions];
//_receiversLastUpdate = new DateTime[numPartitions];
//for (int i = 0; i < numPartitions; i++)
//{
// _receiversLastUpdate[i] = DateTime.UtcNow;
//}
_tasks = new Task[numPartitions];
_buffers = new Dictionary <string, CircularBuffer <SensorDataContract> >();
for (int iPart = 0; iPart < desc.PartitionCount; iPart++)
{
EventHubReceiver receiver = client.GetConsumerGroup(consumerGroupName).CreateReceiver(
desc.PartitionIds[iPart], DateTime.UtcNow - TimeSpan.FromMinutes(2));
_receivers[iPart] = receiver;
Task <IEnumerable <EventData> > task = receiver.ReceiveAsync(1000, TimeSpan.FromSeconds(1));
int thisPart = iPart;
task.ContinueWith(new Action <Task <IEnumerable <EventData> > >((t) => OnTaskComplete(t, thisPart)));
_tasks[iPart] = task;
}
}
private async Task SendMessageThrottledForHttp()
{
await sequentialTestSemaphore.WaitAsync();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, Client.TransportType.Http1);
deviceClient.OperationTimeoutInMilliseconds = (uint)TestUtil.ShortRetryInMilliSec;
await deviceClient.OpenAsync();
string payload, p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
// Implementation of error injection of throttling on http is that it will throttle the
// fault injection message itself only. The duration of fault has no effect on http throttle.
// Client is supposed to retry sending the throttling fault message until operation timeout.
await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(TestUtil.FaultType_Throttle,
TestUtil.FaultCloseReason_Boom, TestUtil.DefaultDelayInSec, TestUtil.DefaultDurationInSec));
sequentialTestSemaphore.Release(1);
}
public static void CreateListenerPalAndReceiveMessages()
{
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString, "messages/events");
var eventRuntimeInformation = eventHubClient.GetRuntimeInformation();
string consumerGroupName = Configuration.IoTHub.EventHubConsumerGroup;
foreach (string partitionId in eventRuntimeInformation.PartitionIds)
{
try
{
EventHubReceiver receiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(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 (QuotaExceededException ex)
{
s_log.WriteLine($"{nameof(EventHubTestListener)}.{nameof(CreateListenerPalAndReceiveMessages)}: Cannot create receiver for partitionID {partitionId}: {ex}");
}
}
}
public static async Task ReadTelemetry(string deviceId, CancellationToken ct)
{
EventHubClient eventHubClient = null;
EventHubReceiver eventHubReceiver = null;
var consumerGroup = ConfigurationManager.AppSettings["ConsumerGroup"];
try
{
var ioTHubConnectionString = ConfigurationManager.AppSettings["IOTHubConnectionString"];
eventHubClient = EventHubClient.CreateFromConnectionString(ioTHubConnectionString, "messages/events");
//var ioTHubConnectionString =
// "Endpoint=sb://ihsuprodhkres004dednamespace.servicebus.windows.net/;SharedAccessKeyName=iothubowner;SharedAccessKey=Rte+iSJejSjnT4pXbdbGoRd786APJGiX/5pEkk1mAU8=";
//eventHubClient = EventHubClient.CreateFromConnectionString(ioTHubConnectionString,
// "iothub-ehub-raghuhub-1063-f06377c774");
Console.WriteLine("Receiving events...\r\n");
var eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceId, eventHubPartitionsCount);
eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroup).CreateReceiver(partition);
while (!ct.IsCancellationRequested)
{
EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(10));
if (eventData != null)
{
Console.WriteLine("Received Message : ");
Console.WriteLine(Encoding.UTF8.GetString(eventData.GetBytes()));
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
public async Task StartListening(CancellationToken token)
{
while (true)
{
string messageString = String.Empty;
try
{
if (token.IsCancellationRequested)
{
return;
}
var eventData = await receiver.ReceiveAsync(new TimeSpan(1, 0, 0));
if (eventData != null)
{
var info = eventData.GetBytes();
messageString = UnicodeEncoding.UTF8.GetString(info);
MessageReceived(this, JToken.Parse(messageString));
}
}
catch (Exception ex)
{
Trace.TraceError(String.Format("Error: {0} while processing message: {1}", ex.Message, messageString));
}
}
}
private async Task SendSingleMessage(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.OpenAsync();
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
await deviceClient.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
public async Task Setup(NetworkParameters parameters)
{
eventHubClient = EventHubClient.CreateFromConnectionString(parameters.ConnectionString, "messages/events");
Console.WriteLine("Created client");
var runtimeinfo = eventHubClient.GetRuntimeInformation();
partitionsCount = runtimeinfo.PartitionCount;
var partition = EventHubPartitionKeyResolver.ResolveToPartition(parameters.DeviceName, partitionsCount);
Console.WriteLine("Got partition");
if (parameters.StartTime == null)
{
parameters.StartTime = DateTime.Now;
}
eventHubReceiver = eventHubClient.GetConsumerGroup(parameters.ConsumerGroupName).CreateReceiver(partition, parameters.StartTime);
Console.WriteLine("Created reciever");
var pastEvents = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(3));
int cnt = 0;
foreach (var ev in pastEvents)
{
cnt++;
}
Console.WriteLine("Got {0} events from past", cnt);
}
// This function create a device with x509 cert and send a message to the iothub on the transport specified.
// It then verifies the message is received at the eventHubClient.
private async Task SendSingleMessageX509(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
string certBase64 = Environment.GetEnvironmentVariable("IOTHUB_X509_PFX_CERTIFICATE");
Byte[] buff = Convert.FromBase64String(certBase64);
var cert = new X509Certificate2(buff);
var auth = new DeviceAuthenticationWithX509Certificate(deviceInfo.Item1, cert);
var deviceClient = DeviceClient.Create(deviceInfo.Item2, auth, transport);
await deviceClient.OpenAsync();
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
await deviceClient.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
private async Task EventLoop(EventHubReceiver receiver)
{
mStarted = true;
var eventsBuffer = new List <EventData>();
var lastOffset = string.Empty;
while (mKeepRunning)
{
var events = await receiver.ReceiveAsync(mOptions.BatchSize);
foreach (var evt in events)
{
lastOffset = evt.Offset;
eventsBuffer.Add(evt);
if (eventsBuffer.Count == mOptions.BatchSize)
{
var shouldSave = await mOptions.Processor.ProcessEventsAsync(events.AsEnumerable(), mState);
if (shouldSave)
{
mState.Offset = lastOffset;
await mState.SaveAsync();
}
eventsBuffer.Clear();
}
}
}
mStarted = false;
}
private async Task Listen(EventHubReceiver receiver)
{
while (!_tokenSrc.IsCancellationRequested)
{
_sbTasks.RemoveAll(x => x.IsCompleted);
//Every 30 seconds, let's check for a cancellation. As far as I could tell, there is not a listen method that
//has native cancellation support. There is for the normal Azure service bus, but guess it hasn't made it to
//the IoT hub libraries.
var eventData = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
if (eventData == null)
{
continue;
}
var ctx = GlobalHost.ConnectionManager.GetHubContext <BusRHub>();
var data = Encoding.UTF8.GetString(eventData.GetBytes());
var theEvent = JsonConvert.DeserializeObject <AllInOneModelDto>(data).ToFullModel() as AllInOneModel;
//Send the event
if (theEvent == null)
{
ctx.Clients.All.eventReceived(data);
continue;
}
var stream = (EventStreamEnum)theEvent.EventStream;
ctx.Clients.All.eventReceived(theEvent.ToString(_deviceRepo));
//If this is a summary event, trigger that method
if (stream == EventStreamEnum.Summary)
{
ctx.Clients.All.summaryUpdate(theEvent.ToString(_deviceRepo));
continue;
}
//If it's a state change
if (stream != EventStreamEnum.StateChange)
{
continue;
}
//Let's get some more friendly device information
var dev = _deviceRepo.GetByDeviceId(theEvent.DeviceId ?? theEvent.IntersectionId ?? Guid.Empty);
//and trigger the stateChange method for our clients
ctx.Clients.All.stateChange(dev.DeviceId, theEvent.CurrentState);
//Finally the bulbChange method when appropriate to update the graphical UI
if (dev?.DeviceType == "Bulb")
{
ctx.Clients.All.bulbChange(dev.DeviceId, theEvent.CurrentState == "On" || theEvent.CurrentState == "AssumedOn");
}
}
var test = true;
}
private async Task SendMessageRecovery(Client.TransportType transport,
string faultType, string reason, int delayInSec, int durationInSec = 0)
{
await sequentialTestSemaphore.WaitAsync();
Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.OpenAsync();
string payload, p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
// send error command and clear eventHubReceiver of the fault injection message
await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(faultType, reason, delayInSec, durationInSec));
await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
Thread.Sleep(1000);
testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
await deviceClient.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
sequentialTestSemaphore.Release(1);
}
async static Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null) continue;
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine("Message received: '{0}'", data);
}
}
private async Task HandleReceivedInformation()
{
EventData eventData = await eventHubReceiver.ReceiveAsync();
string data = Encoding.UTF8.GetString(eventData.GetBytes());
JObject serializedObject = JObject.Parse(data);
string lightNumber = serializedObject["lightNumber"].ToString();
string lightStatus = serializedObject["lightStatus"].ToString();
DateTime lastMove = Convert.ToDateTime(serializedObject["date"]);
HandleLights(lightNumber, lightStatus);
}
private static async Task EventLoopAsync(EventHubReceiver eventHubReceiver)
{
while (true)
{
var edata = await eventHubReceiver.ReceiveAsync();
if (edata != null)
{
var data = Encoding.UTF8.GetString(edata.GetBytes());
Console.WriteLine($"{eventHubReceiver.PartitionId}, {data}");
}
}
}
// This function create a device with x509 cert and send a message to the iothub on the transport specified.
// It then verifies the message is received at the eventHubClient.
private async Task SendSingleMessageX509(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager);
EventHubClient eventHubClient;
EventHubReceiver eventHubReceiver = CreateEventHubReceiver(deviceInfo.Item1, out eventHubClient);
string certBase64 = Environment.GetEnvironmentVariable("IOTHUB_X509_PFX_CERTIFICATE");
Byte[] buff = Convert.FromBase64String(certBase64);
var cert = new X509Certificate2(buff);
var auth = new DeviceAuthenticationWithX509Certificate(deviceInfo.Item1, cert);
var deviceClient = DeviceClient.Create(deviceInfo.Item2, auth, transport);
try
{
await deviceClient.OpenAsync();
string payload;
string p1Value;
Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value);
await deviceClient.SendEventAsync(testMessage);
bool isReceived = false;
Stopwatch sw = new Stopwatch();
sw.Start();
while (!isReceived && sw.Elapsed.Minutes < 1)
{
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value);
}
sw.Stop();
Assert.IsTrue(isReceived, "Message is not received.");
}
finally
{
await deviceClient.CloseAsync();
await eventHubReceiver.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
}
public static async Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
string[] value = data.Split(',');
DangerWindow(value[0], value[1]);
}
}
async static Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
var eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
var data = Encoding.UTF8.GetString(eventData.GetBytes());
Console.WriteLine("Message received: '{0}'", data);
}
}
async Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
HandleData(data);
}
}
private async Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Debug.WriteLine(String.Format("Message received: {0}", data));
ParseAndSave(data);
}
}
async static Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
var message = $"{eventData.EnqueuedTimeUtc.ToLocalTime():hh:mm:ss.fff} {eventData.SystemProperties["iothub-connection-device-id"]} sent '{data}'";
Console.WriteLine(message);
}
}
public async Task Receive()
{
Console.WriteLine("Awaiting messages");
keepReceiving = true;
while (keepReceiving)
{
var eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(1));
if (eventData == null)
{
continue;
}
Digest(eventData);
}
}
public void ReadFromEventHubPartition()
{
string serviceBusNamespace = "iotmc-ns";
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
int eventHubPartitionCount = 8;
string eventHubSASKey = "<< Add your SAS here >>";
string eventHubConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty),
eventHubSASKeyName,
eventHubSASKey);
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName);
EventHubConsumerGroup eventHubConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
for (int i = 0; i < eventHubPartitionCount; i++)
{
string partitionId = i.ToString();
Task.Run(async() =>
{
//Just "new" message -> DateTime.Now
EventHubReceiver eventHubReceiver = eventHubConsumerGroup.CreateReceiver(partitionId, DateTime.Now);
//All existing messages in partition -> -1
//EventHubReceiver eventHubReceiver = await eventHubConsumerGroup.CreateReceiverAsync(partitionId, "-1");
do
{
EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(2));
if (eventData != null)
{
string message = Encoding.UTF8.GetString(eventData.GetBytes());
string messageDetails = String.Format("Received: Seq number={0} Offset={1} Partition={2} EnqueueTimeUtc={3} Message={4}",
eventData.SequenceNumber,
eventData.Offset,
eventHubReceiver.PartitionId,
eventData.EnqueuedTimeUtc.ToShortTimeString(),
message);
Console.WriteLine(messageDetails);
//Store Partition-Id & Offset for further processing
string restorePoint_PartitionId = eventHubReceiver.PartitionId;
string restorePoint_Offset = eventData.Offset;
}
} while (true);
});
}
}
async Task sendSingleMessage(Client.TransportType transport)
{
Tuple <string, string> deviceInfo = TestUtil.CreateDevice("E2E_Message_CSharp_", hostName, registryManager);
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(hubConnectionString, "messages/events");
var eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount;
string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceInfo.Item1, eventHubPartitionsCount);
string consumerGroupName = Environment.GetEnvironmentVariable("IOTHUB_EVENTHUB_CONSUMER_GROUP");
if (consumerGroupName == null)
{
consumerGroupName = "$Default";
}
EventHubReceiver eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(partition, DateTime.Now);
var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport);
await deviceClient.OpenAsync();
string dataBuffer = Guid.NewGuid().ToString();
string propertyName = "property1";
string propertyValue = Guid.NewGuid().ToString();
Client.Message eventMessage = new Client.Message(Encoding.UTF8.GetBytes(dataBuffer));
eventMessage.Properties[propertyName] = propertyValue;
await deviceClient.SendEventAsync(eventMessage);
var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5));
foreach (var eventData in events)
{
var data = Encoding.UTF8.GetString(eventData.GetBytes());
Assert.AreEqual(data, dataBuffer);
var connectionDeviceId = eventData.SystemProperties["iothub-connection-device-id"].ToString();
Assert.AreEqual(connectionDeviceId.ToUpper(), deviceInfo.Item1.ToUpper());
Assert.AreEqual(eventData.Properties.Count, 1);
var property = eventData.Properties.Single();
Assert.AreEqual(property.Key, propertyName);
Assert.AreEqual(property.Value, propertyValue);
}
await deviceClient.CloseAsync();
await eventHubClient.CloseAsync();
TestUtil.RemoveDevice(deviceInfo.Item1, registryManager);
}
private static async Task EventLoopAsync(EventHubReceiver eventHubReceiver)
{
while (true)
{
var edata = await eventHubReceiver.ReceiveAsync();
if (edata != null)
{
var data = Encoding.UTF8.GetString(edata.GetBytes());
foreach (var item in edata.SystemProperties)
{
Console.Write($"{item.Key}, {item.Value.ToString()}");
}
Console.WriteLine($"\r\n{data}");
}
}
}
async static Task ReceiveMessagesFromDeviceAsync(EventHubReceiver receiver)
{
while (true)
{
EventData eventData = await receiver.ReceiveAsync();
if (eventData == null)
{
continue;
}
string data = Encoding.UTF8.GetString(eventData.GetBytes());
Debug.WriteLine(String.Format("Message received: {0}", data));
int h = int.Parse(data.Substring(0, 2));
//var res = controller.PostParameters(new Parameters() { Value = h, Name = "Humidity", Id = Guid.NewGuid().ToString(), CreatedAt=DateTime.Now, Deleted = false, UpdatedAt = DateTime.Now, Version=new byte[] { } });
}
}
public void ReadFromEventHubPartition()
{
string serviceBusNamespace = "iotmc-ns";
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
int eventHubPartitionCount = 8;
string eventHubSASKey = "<< Add your SAS here >>";
string eventHubConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty),
eventHubSASKeyName,
eventHubSASKey);
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubName);
EventHubConsumerGroup eventHubConsumerGroup = eventHubClient.GetDefaultConsumerGroup();
for (int i = 0; i < eventHubPartitionCount; i++)
{
string partitionId = i.ToString();
Task.Run(async() =>
{
//Just "new" message -> DateTime.Now
EventHubReceiver eventHubReceiver = eventHubConsumerGroup.CreateReceiver(partitionId, DateTime.Now);
//All existing messages in partition -> -1
//EventHubReceiver eventHubReceiver = await eventHubConsumerGroup.CreateReceiverAsync(partitionId, "-1");
do
{
EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(2));
if (eventData != null)
{
Telemetry telemetry = JsonConvert.DeserializeObject <Telemetry>(Encoding.UTF8.GetString(eventData.GetBytes()));
AnalyticsEngine._humidityTelemetryIngest.Push(telemetry.Humidity);
AnalyticsEngine._pollutionTelemetryIngest.Push(telemetry.Pollution);
Debug.WriteLine(telemetry.Pollution.ToString(), eventData.EnqueuedTimeUtc.ToString());
//Store Partition-Id & Offset for further processing
string restorePoint_PartitionId = eventHubReceiver.PartitionId;
string restorePoint_Offset = eventData.Offset;
}
} while (true);
});
}
}
public bool ProcessOutput(EventHubReceiver eventHubReceiver, string selectedDevice, CancellationToken ct)
{
//having already received past events, monitor current events in a loop
while (true)
{
ct.ThrowIfCancellationRequested();
var eventData = eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(1)).Result;
if (eventData != null)
{
var data = Encoding.UTF8.GetString(eventData.GetBytes());
var enqueuedTime = eventData.EnqueuedTimeUtc.ToLocalTime();
var connectionDeviceId = eventData.SystemProperties["iothub-connection-device-id"].ToString();
if (string.CompareOrdinal(selectedDevice, connectionDeviceId) == 0)
{
DumpData($"{enqueuedTime}> Device: [{connectionDeviceId}], Data:[{data}]");
if (eventData.Properties.Count > 0)
{
DumpData("Properties:\r\n");
foreach (var property in eventData.Properties)
{
DumpData($"'{property.Key}': '{property.Value}'\r\n");
}
}
if (enableSystemProperties.Checked)
{
if (eventData.Properties.Count == 0)
{
DumpData("\r\n");
}
foreach (var item in eventData.SystemProperties)
{
DumpData($"SYSTEM>{item.Key}={item.Value}\r\n");
}
}
DumpData("\r\n");
}
}
}
return(true);
}
public Task ReadAsync(EventHubReceiver receiver, CancellationTokenSource cancellation)
{
return Task.Factory.StartNew(async () => {
Debug.WriteLine(string.Format("partition {0} started", PartitionId));
while (!cancellation.IsCancellationRequested)
{
var message = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
if (message != null)
{
_messages.OnNext(new EventHubMessage(receiver.PartitionId,message));
}
}
await receiver.CloseAsync();
Debug.WriteLine(string.Format("partition {0} finished", PartitionId));
}, cancellation.Token, TaskCreationOptions.LongRunning, TaskScheduler.Current);
}
private async Task EventLoop(EventHubReceiver receiver)
{
mStarted = true;
var eventsBuffer = new List<EventData>();
var lastOffset = string.Empty;
while (mKeepRunning)
{
var events = await receiver.ReceiveAsync(mOptions.BatchSize);
foreach (var evt in events)
{
lastOffset = evt.Offset;
eventsBuffer.Add(evt);
if (eventsBuffer.Count == mOptions.BatchSize)
{
var shouldSave = await mOptions.Processor.ProcessEventsAsync(events.AsEnumerable(), mState);
if (shouldSave)
{
mState.Offset = lastOffset;
await mState.SaveAsync();
}
eventsBuffer.Clear();
}
}
}
mStarted = false;
}