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