public Task Shutdown(TimeSpan timeout) { // if receiver was already shutdown, do nothing if (ReceiverShutdown == Interlocked.Exchange(ref recieverState, ReceiverShutdown)) { return(TaskDone.Done); } logger.Info("Stopping reading from EventHub partition {0}-{1}", settings.Hub.Path, settings.Partition); // clear cache and receiver IEventHubQueueCache localCache = Interlocked.Exchange(ref cache, null); EventHubReceiver localReceiver = Interlocked.Exchange(ref receiver, null); // start closing receiver Task closeTask = TaskDone.Done; if (localReceiver != null) { closeTask = localReceiver.CloseAsync(); } // dispose of cache localCache?.Dispose(); // finish return receiver closing task return(closeTask); }
public async Task Shutdown(TimeSpan timeout) { EventHubReceiver localReceiver = Interlocked.Exchange(ref receiver, null); if (localReceiver != null) { await localReceiver.CloseAsync(); } }
public static EventHubReceiver GetReceiver(EventHubConsumerGroup consumerGroup, string partitionId, DateTime startDateTimeUtc) { if (receiver != null && receiver.PartitionId == partitionId && !receiver.IsClosed) { return(receiver); } else { receiver?.CloseAsync().Wait(); receiver = consumerGroup.CreateReceiver(partitionId, startDateTimeUtc); return(receiver); } }
// 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); } }
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); 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(); await eventHubClient.CloseAsync(); sequentialTestSemaphore.Release(1); } }
internal async Task SendMessageThrottledForHttp() { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); EventHubClient eventHubClient; EventHubReceiver eventHubReceiver = CreateEventHubReceiver(testDevice.Id, out eventHubClient); var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, Client.TransportType.Http1); try { deviceClient.OperationTimeoutInMilliseconds = (uint)FaultInjection.ShortRetryInMilliSec; await deviceClient.OpenAsync().ConfigureAwait(false); string payload, 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(); // 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(FaultInjection.ComposeErrorInjectionProperties(FaultInjection.FaultType_Throttle, FaultInjection.FaultCloseReason_Boom, FaultInjection.DefaultDelayInSec, FaultInjection.DefaultDurationInSec)).ConfigureAwait(false); _log.WriteLine($"Waiting for fault injection interval to finish {FaultInjection.DefaultDelayInSec}s."); await Task.Delay(FaultInjection.DefaultDurationInSec * 1000).ConfigureAwait(false); } finally { await deviceClient.CloseAsync().ConfigureAwait(false); await eventHubReceiver.CloseAsync().ConfigureAwait(false); } }
internal async Task SendSingleMessageX509(Client.TransportType transport) { Tuple <string, string> deviceInfo = TestUtil.CreateDeviceWithX509(DevicePrefix, hostName, registryManager); EventHubClient eventHubClient; EventHubReceiver 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 SendSingleMessageX509(Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, TestDeviceType.X509).ConfigureAwait(false); EventHubReceiver 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); } }
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)); }
public Task Shutdown(TimeSpan timeout) { logger.Info("Stopping reading from EventHub partition {0}-{1}", config.Hub.Path, config.Partition); // clear cache and receiver IEventHubQueueCache localCache = Interlocked.Exchange(ref cache, null); EventHubReceiver localReceiver = Interlocked.Exchange(ref receiver, null); // start closing receiver Task closeTask = TaskDone.Done; if (localReceiver != null) { closeTask = localReceiver.CloseAsync(); } // dispose of cache localCache?.Dispose(); // finish return receiver closing task return(closeTask); }
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); }
public Task Shutdown(TimeSpan timeout) { // clear cache and receiver IEventHubQueueCache localCache = Interlocked.Exchange(ref cache, null); EventHubReceiver localReceiver = Interlocked.Exchange(ref receiver, null); // start closing receiver Task closeTask = TaskDone.Done; if (localReceiver != null) { closeTask = localReceiver.CloseAsync(); } // dispose of cache if (localCache != null) { localCache.Dispose(); } // finish return receiver closing task return(closeTask); }
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); 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); } }
private async Task <IEnumerable <EventData> > GetEventData() { EventHubRuntimeInformation runtimeInformation = _eventHubClient.GetRuntimeInformation(); List <EventData> dataRecieved = new List <EventData>(); foreach (string partitionId in runtimeInformation.PartitionIds) { string partitionOffset = await _stateHandler.GetOffset(partitionId); //EventHubReceiver eventReceiver = _eventHubClient.GetDefaultConsumerGroup().CreateReceiver(partitionId, partitionOffset); EventHubReceiver eventReceiver = _eventHubClient.GetConsumerGroup("mojo").CreateReceiver(partitionId, partitionOffset); EventData eventData = eventReceiver.Receive(); await _stateHandler.SetOffset(eventData.Offset, partitionId); await eventReceiver.CloseAsync(); dataRecieved.Add(eventData); } return(dataRecieved); }
internal async Task SendSingleMessage(Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); EventHubClient eventHubClient; EventHubReceiver eventHubReceiver = CreateEventHubReceiver(testDevice.Id, out eventHubClient); var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, 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); } }
internal async Task SendMessageRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec, int durationInSec = 0, int retryDurationInMilliSec = 240000) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false); var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport); EventHubClient eventHubClient; EventHubReceiver eventHubReceiver = CreateEventHubReceiver(testDevice.Id, out eventHubClient); try { deviceClient.OperationTimeoutInMilliseconds = (uint)retryDurationInMilliSec; ConnectionStatus? lastConnectionStatus = null; ConnectionStatusChangeReason?lastConnectionStatusChangeReason = null; int setConnectionStatusChangesHandlerCount = 0; deviceClient.SetConnectionStatusChangesHandler((status, statusChangeReason) => { lastConnectionStatus = status; lastConnectionStatusChangeReason = statusChangeReason; setConnectionStatusChangesHandlerCount++; }); await deviceClient.OpenAsync().ConfigureAwait(false); if (transport != Client.TransportType.Http1) { Assert.AreEqual(1, setConnectionStatusChangesHandlerCount); Assert.AreEqual(ConnectionStatus.Connected, lastConnectionStatus); Assert.AreEqual(ConnectionStatusChangeReason.Connection_Ok, lastConnectionStatusChangeReason); } string payload, 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(); // send error command and clear eventHubReceiver of the fault injection message await deviceClient.SendEventAsync(FaultInjection.ComposeErrorInjectionProperties(faultType, reason, delayInSec, durationInSec)).ConfigureAwait(false); await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(5)).ConfigureAwait(false); Thread.Sleep(1000); testMessage = ComposeD2CTestMessage(out payload, out p1Value); await deviceClient.SendEventAsync(testMessage).ConfigureAwait(false); sw.Reset(); 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(); await deviceClient.CloseAsync().ConfigureAwait(false); if (transport != Client.TransportType.Http1) { Assert.AreEqual(2, setConnectionStatusChangesHandlerCount); Assert.AreEqual(ConnectionStatus.Disabled, lastConnectionStatus); Assert.AreEqual(ConnectionStatusChangeReason.Client_Close, lastConnectionStatusChangeReason); } } finally { await deviceClient.CloseAsync().ConfigureAwait(false); await eventHubReceiver.CloseAsync().ConfigureAwait(false); } }
public static async Task<string> 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); await receiver.CloseAsync(); return data; } }