public async Task <IList <EventData> > GetMessagesFromAllPartitions(DateTime startTime, int maxPerPartition = 10, int waitTimeSecs = 5) { var messages = new List <EventData>(); EventHubRuntimeInformation rtInfo = await this.eventHubClient.GetRuntimeInformationAsync(); foreach (string partition in rtInfo.PartitionIds) { PartitionReceiver partitionReceiver = this.eventHubClient.CreateReceiver( PartitionReceiver.DefaultConsumerGroupName, partition, startTime); // Retry a few times to make sure we get all expected messages. 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(); } return(messages); }
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}"); } } }
public async Task ReceiveFromInvalidPartition() { var ehClient = EventHubClient.CreateFromConnectionString(TestUtility.EventHubsConnectionString); PartitionReceiver receiver = null; try { // Some invalid partition values. These will fail on the service side. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); }); await receiver.CloseAsync(); } // Some invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { " ", null, "" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <InvalidOperationException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); }); await receiver.CloseAsync(); } } finally { await ehClient.CloseAsync(); } }
private async Task ReceiverPumpAsync(PartitionReceiver receiver, Func <IReadOnlyCollection <QueueMessage>, Task> onMessage, int maxBatchSize, CancellationToken cancellationToken) { while (true) { try { IEnumerable <EventData> events = await receiver.ReceiveAsync(maxBatchSize, _waitTime); if (events != null && !cancellationToken.IsCancellationRequested) { List <QueueMessage> qms = events.Select(ed => Converter.ToQueueMessage(ed, receiver.PartitionId)).ToList(); await onMessage(qms); QueueMessage lastMessage = qms.LastOrDefault(); //save state if (lastMessage != null) { const string sequenceNumberPropertyName = "x-opt-sequence-number"; if (lastMessage.Properties.TryGetValue(sequenceNumberPropertyName, out string sequenceNumber)) { long?sequenceNumberLong = null; if (long.TryParse(sequenceNumber, out long seqenceNumberNonNullable)) { sequenceNumberLong = seqenceNumberNonNullable; } await _state.SetPartitionStateAsync(receiver.PartitionId, sequenceNumberLong); } } } if (cancellationToken.IsCancellationRequested) { await receiver.CloseAsync(); return; } } catch (ArgumentException ex) { Console.WriteLine("failed with message: '{0}', clearing partition state.", ex); await _state.SetPartitionStateAsync(receiver.PartitionId, EventPosition.FromStart().SequenceNumber); } catch (OperationCanceledException) { return; } catch (Exception ex) { Console.WriteLine("receiver stopped: {0}", ex); return; } } }
public void ReceiveAsyncValidatesTheMaximumWaitTime(int timeSpanDelta) { var transportConsumer = new ObservableTransportConsumerMock(); var receiver = new PartitionReceiver("group", "0", "hub", true, TimeSpan.Zero, transportConsumer); var expectedWaitTime = TimeSpan.FromMilliseconds(timeSpanDelta); using var cancellation = new CancellationTokenSource(); Assert.That(async() => await receiver.ReceiveAsync(32, expectedWaitTime, cancellation.Token), Throws.InstanceOf <ArgumentException>()); }
static async Task Receive(int number) { var sms = await _receiver.ReceiveAsync(number); foreach (EventData s in sms) { Console.WriteLine($"Event Read from ReceiveAsync: { FromByteArray<SmsContent>(s.Body.ToArray()) } - Partition key : {s.SystemProperties.PartitionKey}"); } }
async Task SendReceiveNonexistentEntity() { // Rebuild connection string with a nonexistent entity. var csb = new EventHubsConnectionStringBuilder(this.connectionString); csb.EntityPath = Guid.NewGuid().ToString(); var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); // Try sending. PartitionSender sender = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Sending an event to nonexistent entity."); sender = ehClient.CreatePartitionSender("0"); await sender.SendAsync(new EventData(Encoding.UTF8.GetBytes("this send should fail."))); throw new InvalidOperationException("Send should have failed"); }); await sender.CloseAsync(); // Try receiving. PartitionReceiver receiver = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Receiving from nonexistent entity."); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", PartitionReceiver.StartOfStream); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive should have failed"); }); await receiver.CloseAsync(); // Try receiving on an nonexistent consumer group. ehClient = EventHubClient.CreateFromConnectionString(this.connectionString); await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Receiving from nonexistent consumer group."); receiver = ehClient.CreateReceiver(Guid.NewGuid().ToString(), "0", PartitionReceiver.StartOfStream); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive should have failed"); }); await receiver.CloseAsync(); }
/// <summary> /// Method created to connect and process the Topic/Subscription in the azure. /// </summary> /// <returns></returns> private void ProcessHub() { if (_topics.Count != 1) { throw new LightException($"EventHub implementation must have one Entity Model related!"); } var e = _topics.GetEnumerator(); e.MoveNext(); var topic = e.Current; var connectionStringBuilder = new EventHubsConnectionStringBuilder(GetConnection(topic)) { EntityPath = topic.Value.TopicName }; EventHubClient client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); PartitionReceiver receiver = client.CreateReceiver(topic.Value.Subscription, "0", EventPosition.FromStart(), null); IEnumerable <EventData> receivedEvents = receiver.ReceiveAsync(topic.Value.TakeQuantity).Result; try { while (true) { if (receivedEvents != null) { foreach (EventData receivedEvent in receivedEvents) { LightWorker.InvokeProcess(topic.Key, receivedEvent.Body.ToArray()); } } receivedEvents = receiver.ReceiveAsync(topic.Value.TakeQuantity).Result; } } catch (Exception exception) { Exception moreInfo = new Exception($"Exception reading topic={topic.Value.TopicName} with subscription={topic.Value.Subscription} from event hub. See inner exception for details. Message={exception.Message}", exception); //Use the class instead of interface because tracking exceptions directly is not supposed to be done outside AMAW (i.e. by the business code) ((LightTelemetry)WorkBench.Telemetry).TrackException(moreInfo); } }
// 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); }
async Task PartitionReceiverReceive() { Log("Receiving Events via PartitionReceiver.ReceiveAsync"); const string partitionId = "1"; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10)); try { string uniqueEventId = Guid.NewGuid().ToString(); Log($"Sending an event to Partition {partitionId} with custom property EventId {uniqueEventId}"); var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); sendEvent.Properties = new Dictionary <string, object> { ["EventId"] = uniqueEventId }; await partitionSender.SendAsync(sendEvent); bool expectedEventReceived = false; do { IEnumerable <EventData> eventDatas = await partitionReceiver.ReceiveAsync(10); if (eventDatas == null) { break; } 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)) { Log($"Received message with EventId {objectValue}"); string receivedId = objectValue.ToString(); if (receivedId == uniqueEventId) { Log("Success"); expectedEventReceived = true; break; } } } }while (!expectedEventReceived); Assert.True(expectedEventReceived, $"Did not receive expected event with EventId {uniqueEventId}"); } finally { await Task.WhenAll( partitionReceiver.CloseAsync(), partitionSender.CloseAsync()); } }
async Task ReceiveFromInvalidPartition() { PartitionReceiver receiver = null; // Some invalid partition values. These will fail on the service side. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive call should have failed"); }); await receiver.CloseAsync(); } // Some invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { " ", null, "" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <InvalidOperationException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive call should have failed"); }); await receiver.CloseAsync(); } }
public async Task UseSharedAccessSignature() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); var token = await tokenProvider.GetTokenAsync(csb.Endpoint.ToString(), TimeSpan.FromSeconds(120)); var sas = token.TokenValue.ToString(); // Update connection string builder to use shared access signature instead. csb.SasKey = ""; csb.SasKeyName = ""; csb.SharedAccessSignature = sas; // Create new client with updated connection string. var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } // Get EH runtime information. TestUtility.Log($"Getting Event Hub runtime information."); var ehInfo = await ehClient.GetRuntimeInformationAsync(); Assert.True(ehInfo != null, "Failed to get runtime information."); // Get EH partition runtime information. TestUtility.Log($"Getting Event Hub partition '0' runtime information."); var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0"); Assert.True(ehInfo != null, "Failed to get runtime partition information."); } }
protected async Task ReceiveMessagesFromDeviceAsync(PartitionReceiver receiver) { while (true) { var eventData = await receiver.ReceiveAsync(5, new TimeSpan(0, 0, 5)); //Timeout for receiving messages = 30 seconds int count = 0; if (eventData != null) { if (eventData != null) { foreach (var item in eventData) { count++; if (item.SystemProperties.EnqueuedTimeUtc >= lastRowValues[receiver.PartitionId].EnqueuedTimeUtc && Convert.ToInt64(item.SystemProperties.Offset) > lastRowValues[receiver.PartitionId].EnqueuedOffset) { if (item.Properties.ContainsKey("MessageType") && item.Properties.ContainsKey("UnicodeEncoding")) { if (this.MessageType.Equals(item.Properties["MessageType"])) { //Assert ? item.Properties["UnicodeEncoding"] == "UTF8" string data = UnicodeEncoding.UTF8.GetString(item.Body.Array); var jsonDeserializerSettings = new JsonSerializerSettings() { DateFormatHandling = DateFormatHandling.IsoDateFormat, DateParseHandling = DateParseHandling.DateTimeOffset, DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind }; List <Dictionary <string, object> > results = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(data, jsonDeserializerSettings); foreach (var r in results) { RowRead row = new RowRead(); row.Values = r; receivedRows.Add(row); } } } LastReceivedMessage lastReceivedMessage; lastReceivedMessage.EnqueuedTimeUtc = item.SystemProperties.EnqueuedTimeUtc; lastReceivedMessage.EnqueuedOffset = Convert.ToInt64(item.SystemProperties.Offset); lastRowValues[receiver.PartitionId] = lastReceivedMessage; } } } } if (count == 0) { break; } } await Task.CompletedTask; }
// Sends single message to given partition and returns it after receiving. async Task <EventData> SendAndReceiveSingleEvent(string partitionId) { var eDataToSend = new EventData(new byte[1]); // Stamp this message so we can recognize it when received. var stampValue = Guid.NewGuid().ToString(); var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); eDataToSend.Properties = new Dictionary <string, object> { { "stamp", stampValue } }; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); Log($"Sending single event to partition {partitionId} with stamp {stampValue}"); await partitionSender.SendAsync(eDataToSend); Log($"Receiving all messages from partition {partitionId}"); PartitionReceiver receiver = null; try { receiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, PartitionReceiver.StartOfStream); while (true) { var receivedEvents = await receiver.ReceiveAsync(100); if (receivedEvents == null || receivedEvents.Count() == 0) { throw new Exception("Not able to receive stamped message!"); } Log($"Received {receivedEvents.Count()} event(s) in batch where last event is sent on {receivedEvents.Last().SystemProperties.EnqueuedTimeUtc}"); // Continue until we locate stamped message. foreach (var receivedEvent in receivedEvents) { if (receivedEvent.Properties != null && receivedEvent.Properties.ContainsKey("stamp") && receivedEvent.Properties["stamp"].ToString() == eDataToSend.Properties["stamp"].ToString()) { return(receivedEvent); } } } } finally { await receiver.CloseAsync(); } }
//// 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. internal async Task SendSingleMessageX509(Client.TransportType transport) { // TODO: Update Jenkins Config string endpoint = Configuration.IoTHub.EventHubString; if (endpoint.IsNullOrWhiteSpace()) { return; } Tuple <string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager); EventHubClient eventHubClient; PartitionReceiver eventHubReceiver = await CreateEventHubReceiver(deviceInfo.Item1).ConfigureAwait(false); X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey(); var auth = new DeviceAuthenticationWithX509Certificate(deviceInfo.Item1, cert); var deviceClient = DeviceClient.Create(deviceInfo.Item2, auth, transport); try { await deviceClient.OpenAsync().ConfigureAwait(false); string payload; string p1Value; Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value); await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false); 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)).ConfigureAwait(false); isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value); } sw.Stop(); Assert.IsTrue(isReceived, "Message is not received."); } finally { await deviceClient.CloseAsync().ConfigureAwait(false); await eventHubReceiver.CloseAsync().ConfigureAwait(false); await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager).ConfigureAwait(false); } }
internal async Task SendMessageThrottledForHttp() { // TODO: Update Jenkins Config if (Configuration.IoTHub.EventHubString.IsNullOrWhiteSpace()) { return; } await sequentialTestSemaphore.WaitAsync(); Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager); EventHubClient eventHubClient; PartitionReceiver eventHubReceiver = await CreateEventHubReceiver(deviceInfo.Item1); var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, Client.TransportType.Http1); try { deviceClient.OperationTimeoutInMilliseconds = (uint)TestUtil.ShortRetryInMilliSec; 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(); // 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)); } finally { await deviceClient.CloseAsync(); await eventHubReceiver.CloseAsync(); sequentialTestSemaphore.Release(1); } }
/// <summary> /// Executes the performance test scenario asynchronously. /// </summary> /// /// <param name="cancellationToken">The token used to signal when cancellation is requested.</param> /// public async override Task RunAsync(CancellationToken cancellationToken) { // Read the requested number of events. var remainingEvents = Options.Count; while ((!cancellationToken.IsCancellationRequested) && (remainingEvents > 0)) { remainingEvents -= (await _receiver.ReceiveAsync(remainingEvents).ConfigureAwait(false)).Count(); } // If iteration stopped due to cancellation, ensure that the expected exception is thrown. cancellationToken.ThrowIfCancellationRequested(); }
public async Task ReceiveAsyncInvokesTheTransportConsumer() { var defaultMaximumReceiveWaitTime = TimeSpan.FromMilliseconds(8); var transportConsumer = new ObservableTransportConsumerMock(); var receiver = new PartitionReceiver("group", "0", "hub", true, defaultMaximumReceiveWaitTime, transportConsumer); var expectedMessageCount = 45; using var cancellation = new CancellationTokenSource(); await receiver.ReceiveAsync(expectedMessageCount, null, cancellation.Token); (var actualMessageCount, TimeSpan? actualWaitTime) = transportConsumer.ReceiveCalledWith; Assert.That(actualMessageCount, Is.EqualTo(expectedMessageCount), "The message counts should match."); Assert.That(actualWaitTime, Is.EqualTo(defaultMaximumReceiveWaitTime), "The wait time should match."); }
public async Task UseITokenProviderWithAad() { var appAuthority = ""; var aadAppId = ""; var aadAppSecret = ""; AzureActiveDirectoryTokenProvider.AuthenticationCallback authCallback = async(audience, authority, state) => { var authContext = new AuthenticationContext(authority); var cc = new ClientCredential(aadAppId, aadAppSecret); var authResult = await authContext.AcquireTokenAsync(audience, cc); return(authResult.AccessToken); }; var tokenProvider = TokenProvider.CreateAzureActiveDirectoryTokenProvider(authCallback, appAuthority); // Create new client with updated connection string. await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var ehClient = EventHubClient.CreateWithTokenProvider(csb.Endpoint, csb.EntityPath, tokenProvider); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } } }
private static void receive(PartitionReceiver partitionReceiver, string requestId) { try { while (true) { var receiveTask = partitionReceiver.ReceiveAsync(1, TimeSpan.FromSeconds(10)); receiveTask.Wait(); IEnumerable <EventData> receivedEvents = receiveTask.Result; if (receivedEvents != null) { foreach (EventData eventData in receivedEvents) { if (eventData != null) { if (eventData.Properties != null && eventData.Properties.ContainsKey(COMMAND_REQUEST_ID_PROPERTY_NAME)) { string payload = Encoding.UTF8.GetString(eventData.Body); Console.WriteLine("Received an update on the async command:"); Console.WriteLine(); foreach (string propertyKey in eventData.Properties.Keys) { Console.WriteLine(" " + propertyKey + ":" + eventData.Properties[propertyKey]); } Console.WriteLine(); Console.WriteLine(" " + "Update Payload: "); Console.WriteLine(" " + payload); Console.WriteLine(); if (payload.Contains("100%")) { Console.WriteLine("Async command has finished, enter any key to finish\n"); } } } } } } } catch (ThreadInterruptedException e) { //Thread was aborted, so allow it to end partitionReceiver.Close(); } }
async Task PartitionReceiverReceiveBatch() { const int MaxBatchSize = 5; TestUtility.Log("Receiving Events via PartitionReceiver.ReceiveAsync(BatchSize)"); const string partitionId = "0"; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10)); try { int eventCount = 20; TestUtility.Log($"Sending {eventCount} events to Partition {partitionId}"); var sendEvents = new List <EventData>(eventCount); for (int i = 0; i < eventCount; i++) { sendEvents.Add(new EventData(Encoding.UTF8.GetBytes($"Hello EventHub! Message {i}"))); } await partitionSender.SendAsync(sendEvents); int maxReceivedBatchSize = 0; while (true) { IEnumerable <EventData> partition1Events = await partitionReceiver.ReceiveAsync(MaxBatchSize); int receivedEventCount = partition1Events != null?partition1Events.Count() : 0; TestUtility.Log($"Received {receivedEventCount} event(s)"); if (partition1Events == null) { break; } maxReceivedBatchSize = Math.Max(maxReceivedBatchSize, receivedEventCount); } Assert.True(maxReceivedBatchSize == MaxBatchSize, $"A max batch size of {MaxBatchSize} events was not honored! Actual {maxReceivedBatchSize}."); } finally { await partitionReceiver.CloseAsync(); await partitionSender.CloseAsync(); } }
private async Task ValidateDisabledBehavior(PartitionReceiver partitionReceiver) { Assert.True(partitionReceiver.ReceiverRuntimeMetricEnabled == false, "ReceiverRuntimeMetricEnabled == true"); // Receive a message and validate RuntimeInfo isn't set. var msg = await partitionReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive a message."); Assert.True(partitionReceiver.RuntimeInfo.LastEnqueuedOffset == null, $"FAILED partitionReceiver.RuntimeInfo.LastEnqueuedOffset == {partitionReceiver.RuntimeInfo.LastEnqueuedOffset}"); Assert.True(partitionReceiver.RuntimeInfo.LastEnqueuedTimeUtc == DateTime.MinValue, $"FAILED partitionReceiver.RuntimeInfo.LastEnqueuedTimeUtc == {partitionReceiver.RuntimeInfo.LastEnqueuedTimeUtc}"); Assert.True(partitionReceiver.RuntimeInfo.LastSequenceNumber == -1, $"FAILED partitionReceiver.RuntimeInfo.LastSequenceNumber == {partitionReceiver.RuntimeInfo.LastSequenceNumber}"); Assert.True(partitionReceiver.RuntimeInfo.RetrievalTime == DateTime.MinValue, $"FAILED partitionReceiver.RuntimeInfo.RetrievalTime == {partitionReceiver.RuntimeInfo.RetrievalTime}"); }
public async Task PrepareAzureEventHubResource_NewNamespace_NoError() { var message = "Hello"; EventHubClient eventHubClient = await _eventHubResource.GetEventHubClientAsync("testEventHub"); await eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(message))); PartitionReceiver receiver = await _eventHubResource.GetEventHubReceiverAsync("testEventHub"); IEnumerable <EventData> events = await receiver.ReceiveAsync(1); EventData eventData = events.FirstOrDefault(); Assert.NotNull(eventData); var result = Encoding.UTF8.GetString(eventData.Body); Assert.Equal(message, result); }
//// 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. internal async Task SendSingleMessageX509(Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, TestDeviceType.X509).ConfigureAwait(false); PartitionReceiver eventHubReceiver = await CreateEventHubReceiver(testDevice.Id).ConfigureAwait(false); X509Certificate2 cert = Configuration.IoTHub.GetCertificateWithPrivateKey(); var auth = new DeviceAuthenticationWithX509Certificate(testDevice.Id, cert); var deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, auth, transport); try { await deviceClient.OpenAsync().ConfigureAwait(false); string payload; string p1Value; Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value); await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false); 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)).ConfigureAwait(false); isReceived = VerifyTestMessage(events, testDevice.Id, payload, p1Value); } sw.Stop(); Assert.IsTrue(isReceived, "Message is not received."); } finally { await deviceClient.CloseAsync().ConfigureAwait(false); await eventHubReceiver.CloseAsync().ConfigureAwait(false); _log.WriteLine($"Waiting for fault injection interval to finish {FaultInjection.DefaultDelayInSec}s."); await Task.Delay(FaultInjection.DefaultDurationInSec * 1000).ConfigureAwait(false); } }
// Receives all messages on the given receiver. async Task <List <EventData> > ReceiveAllMessages(PartitionReceiver receiver) { List <EventData> messages = new List <EventData>(); while (true) { var receivedEvents = await receiver.ReceiveAsync(100); if (receivedEvents == null) { // There is no more events to receive. break; } messages.AddRange(receivedEvents); } return(messages); }
private static async Task <IReadOnlyList <EventData> > ReceiveAll(PartitionReceiver receiver) { var messages = new List <EventData>(); var waitTime = TimeSpan.FromMilliseconds(1000); while (true) { IEnumerable <EventData> received = await receiver.ReceiveAsync(10, waitTime); if (received == null) { break; } messages.AddRange(received); } return(messages); }
public async Task UseITokenProviderWithSas() { // Generate SAS token provider. var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); // Create new client with updated connection string. var ehClient = EventHubClient.CreateWithTokenProvider(csb.Endpoint, csb.EntityPath, tokenProvider); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } // Get EH runtime information. TestUtility.Log($"Getting Event Hub runtime information."); var ehInfo = await ehClient.GetRuntimeInformationAsync(); Assert.True(ehInfo != null, "Failed to get runtime information."); // Get EH partition runtime information. TestUtility.Log($"Getting Event Hub partition '0' runtime information."); var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0"); Assert.True(ehInfo != null, "Failed to get runtime partition information."); }
internal async Task SendSingleMessage(Client.TransportType transport) { // TODO: Update Jenkins Config if (Configuration.IoTHub.EventHubString.IsNullOrWhiteSpace()) { return; } Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager); PartitionReceiver eventHubReceiver = await CreateEventHubReceiver(deviceInfo.Item1); var deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, 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(30)); isReceived = VerifyTestMessage(events, deviceInfo.Item1, payload, p1Value); } sw.Stop(); Assert.IsTrue(isReceived, "Message is not received."); } finally { await deviceClient.CloseAsync(); await eventHubReceiver.CloseAsync(); await TestUtil.RemoveDeviceAsync(deviceInfo.Item1, registryManager); } }
public async Task UseITokenProviderWithAad() { var tenantId = ""; var aadAppId = ""; var aadAppSecret = ""; if (string.IsNullOrEmpty(tenantId)) { TestUtility.Log($"Skipping test during scheduled runs."); return; } var authContext = new AuthenticationContext($"https://login.windows.net/{tenantId}"); var cc = new ClientCredential(aadAppId, aadAppSecret); var tokenProvider = TokenProvider.CreateAadTokenProvider(authContext, cc); // Create new client with updated connection string. var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString); var ehClient = EventHubClient.Create(csb.Endpoint, csb.EntityPath, tokenProvider); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } }
public async Task ReadFromSpecificPartition() { await using var scope = await EventHubScope.CreateAsync(1); #region Snippet:EventHubs_Migrate_T1_ReadFromSpecificPartition #if SNIPPET var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; #else var connectionString = TestUtility.EventHubsConnectionString; var eventHubName = scope.EventHubName; var consumerGroup = PartitionReceiver.DefaultConsumerGroupName; #endif var builder = new EventHubsConnectionStringBuilder(connectionString); builder.EntityPath = eventHubName; EventHubClient client = EventHubClient.CreateFromConnectionString(builder.ToString()); PartitionReceiver receiver = default; try { string firstPartition = (await client.GetRuntimeInformationAsync()).PartitionIds.First(); receiver = client.CreateReceiver(consumerGroup, firstPartition, EventPosition.FromStart()); IEnumerable <EventData> events = await receiver.ReceiveAsync(50); foreach (var eventData in events) { Debug.WriteLine($"Read event of length { eventData.Body.Count } from { firstPartition }"); } } finally { receiver?.Close(); client.Close(); } #endregion }