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