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