public async Task <EvaluationResult> DeviceTwin(DeviceWebAPIParameters parms)
{
var result = new EvaluationResult {
Code = 0, Message = "Received a command", Passed = true
};
try
{
var iotReg = new IotUtilities.IotRegistry(parms.IotConnection);
var connectionStrings = await iotReg.GetTwinsConnectionString();
var retries = 0;
var retry = true;
//Added basic retry pattern
while ((retry) && (retries < 3))
{
try
{
var client = DeviceClient.CreateFromConnectionString(connectionStrings[0], s_transportType);
if (client == null)
{
throw new ArgumentException("Failed to create a device client");
}
Twin twin = await client.GetTwinAsync().ConfigureAwait(false);
if (twin.Properties.Desired.Contains("sample"))
{
dynamic prop = twin.Properties.Desired["sample"];
result.Message = prop;
TwinCollection reportedProperties = new TwinCollection();
reportedProperties["sample"] = result.Message;
try
{
await client.UpdateReportedPropertiesAsync(reportedProperties).ConfigureAwait(false);
}
catch
{
//Ignore error here. This is a write operation and it fails if the value already exists.
}
}
else
{
result.Message = $"The \"sample\" property does not exist for the {twin.DeviceId} device.";
result.Passed = false;
result.Code = -1;
}
retry = false;
}
catch (Exception inner)
{
retries++;
if (retries < 3)
{
Thread.Sleep(1000);
}
else
{
result.Passed = false;
result.Code = inner.HResult;
result.Message = $"Error: {inner.Message}";
}
}
}
}
catch (Exception ex)
{
result.Passed = false;
result.Code = ex.HResult;
result.Message = $"Error: {ex.Message}";
}
return(result);
}
public async Task <EvaluationResult> ReceiveEvents(string consumerGroup = null)
{
var result = new EvaluationResult {
Code = 0, Message = "Received messages", Passed = true
};
try
{
consumerGroup = consumerGroup ?? PartitionReceiver.DefaultConsumerGroupName;
var regUtil = new IotUtilities.IotRegistry(parms.IotConnection);
var deviceNames = await regUtil.GetDeviceNames();
var priorRowKeys = await storage.RetrieveLastKeys(deviceNames);
var priorRowKey = priorRowKeys[0];
var currentRowKey = priorRowKey;
var eventProcessorHost = new EventProcessorHost(
parms.HubName,
consumerGroup,
parms.EhubConnection,
parms.EhubStorage,
this.containerName);
try
{
//await eventProcessorHost.RegisterEventProcessorAsync<EventHubProcessor>();
await eventProcessorHost.RegisterEventProcessorFactoryAsync(new MyEventProcessorFactory(parms.EhubStorage, tableName, containerName));
var start = DateTime.Now;
var currentTime = DateTime.Now;
var seconds = (currentTime - start).TotalSeconds;
//Wait for the first table entry for 30 seconds.
while ((priorRowKey == currentRowKey) && (seconds < 30))
{
Thread.Sleep(100);
currentTime = DateTime.Now;
currentRowKey = (await storage.RetrieveLastKeys(deviceNames))[0];
seconds = (currentTime - start).TotalSeconds;
System.Diagnostics.Trace.WriteLine($"Seconds: {seconds}\tPrior: {priorRowKey}\tCurrent: {currentRowKey}");
}
if (currentRowKey == priorRowKey)
{
//No rows found
result.Code = -1;
result.Passed = false;
result.Message = "No errors occurred, but no events were processed.";
}
else
{
//Wait for events to come in. If synchronous, this will be 0 seconds. This can be no more than 10 seconds.
if (parms.EventReceiveDelay > 10)
{
parms.EventReceiveDelay = 10;
}
if (parms.EventReceiveDelay > 0)
{
Thread.Sleep(parms.EventReceiveDelay * 1000);
}
List <DeviceReadingEntity> data = new List <DeviceReadingEntity>();
data.AddRange((await storage.RetrieveProcessedData(5, deviceNames)).Data);
result.Data = data;
result.Message = $"IoT device messages were received and processed into the {tableName} storage table";
}
}
finally
{
await eventProcessorHost.UnregisterEventProcessorAsync();
}
}
catch (Exception outer)
{
result.Passed = false;
result.Code = outer.HResult;
result.Message = $"Error: {outer.Message}";
}
return(result);
}
