private async Task ReportAllDeviceProperties()
{
Logger.Log("Reporting all device properties to device twin...", LoggingLevel.Information);
Logger.Log("Querying device state...", LoggingLevel.Information);
JObject windowsObj = new JObject();
foreach (var handler in this._desiredPropertyMap.Values)
{
StatusSection statusSection = new StatusSection(StatusSection.StateType.Pending);
await ReportStatusAsync(handler.PropertySectionName, statusSection);
// TODO: how do we ensure that only Reported=yes sections report results?
try
{
windowsObj[handler.PropertySectionName] = await handler.GetReportedPropertyAsync();
statusSection.State = StatusSection.StateType.Completed;
Logger.Log(statusSection.ToString(), LoggingLevel.Information);
await ReportStatusAsync(handler.PropertySectionName, statusSection);
}
catch (Error e)
{
statusSection.State = StatusSection.StateType.Failed;
statusSection.TheError = e;
Logger.Log(statusSection.ToString(), LoggingLevel.Error);
await ReportStatusAsync(handler.PropertySectionName, statusSection);
}
catch (Exception e)
{
statusSection.State = StatusSection.StateType.Failed;
statusSection.TheError = new Error(ErrorSubSystem.Unknown, e.HResult, e.Message);
Logger.Log(statusSection.ToString(), LoggingLevel.Error);
await ReportStatusAsync(handler.PropertySectionName, statusSection);
}
}
Dictionary <string, object> collection = new Dictionary <string, object>();
collection[DMJSonConstants.DTWindowsIoTNameSpace] = windowsObj;
Debug.WriteLine($"Report properties: {collection[DMJSonConstants.DTWindowsIoTNameSpace].ToString()}");
_deviceTwin.ReportProperties(collection).FireAndForget();
}
public static async Task EnsureErrorsLogged(IClientHandlerCallBack _callback, string sectionName, Func <Task> action)
{
try
{
await action();
}
catch (Error ex)
{
StatusSection status = new StatusSection(StatusSection.StateType.Failed, ex);
Logger.Log(status.ToString(), LoggingLevel.Error);
await _callback.ReportStatusAsync(sectionName, status);
}
catch (Exception ex)
{
Error e = new Error(ErrorSubSystem.Unknown, ex.HResult, ex.Message);
StatusSection status = new StatusSection(StatusSection.StateType.Failed, e);
Logger.Log(status.ToString(), LoggingLevel.Error);
await _callback.ReportStatusAsync(sectionName, status);
}
}
public async Task <string> Invoke(string arg)
{
Debug.WriteLine($"Executing direct method: {this._methodName}");
try
{
return(await _method(arg));
}
catch (Error ex)
{
StatusSection status = new StatusSection(StatusSection.StateType.Failed, ex);
Logger.Log(status.ToString(), LoggingLevel.Error);
return(status.AsJsonObject().ToString());
}
catch (Exception ex)
{
Error e = new Error(Message.ErrorSubSystem.Unknown, ex.HResult, ex.Message);
StatusSection status = new StatusSection(StatusSection.StateType.Failed, e);
Logger.Log(status.ToString(), LoggingLevel.Error);
return(status.AsJsonObject().ToString());
}
}
private async Task ApplyDesiredStateAsync(long version, JObject windowsPropValue, bool forceFullTwinUpdate)
{
Logger.Log(string.Format("Applying {0} node desired state for version {1} ...", DMJSonConstants.DTWindowsIoTNameSpace, version), LoggingLevel.Verbose);
try
{
// Only one set of updates at a time...
await _desiredPropertiesLock.WaitAsync();
// If we force a full twin update OR
// we haven't processed any updates yet OR
// we missed a version ...
// Then, get all of the twin's properties
if (forceFullTwinUpdate || _lastDesiredPropertyVersion == -1 || version > (_lastDesiredPropertyVersion + 1))
{
Dictionary <string, object> desiredProperties = await this._deviceTwin.GetDesiredPropertiesAsync();
ExtractInfoFromDesiredProperties(desiredProperties, out version, out windowsPropValue);
}
else if (version <= _lastDesiredPropertyVersion)
{
// If this version is older (or the same) than the last we processed ...
// Then, skip this update
return;
}
_lastDesiredPropertyVersion = version;
if (windowsPropValue == null)
{
// Nothing to apply.
return;
}
foreach (var sectionProp in windowsPropValue.Children().OfType <JProperty>())
{
// Handle any dependencies first
List <IClientPropertyDependencyHandler> handlers;
if (this._desiredPropertyDependencyMap.TryGetValue(sectionProp.Name, out handlers))
{
handlers.ForEach((handler) =>
{
try
{
Debug.WriteLine($"{sectionProp.Name} = {sectionProp.Value.ToString()}");
if (sectionProp.Value is JObject)
{
handler.OnDesiredPropertyDependencyChange(sectionProp.Name, (JObject)sectionProp.Value);
}
}
catch (Exception e)
{
Debug.WriteLine($"Exception caught while handling desired property - {sectionProp.Name}");
Debug.WriteLine(e);
throw;
}
});
}
}
foreach (var sectionProp in windowsPropValue.Children().OfType <JProperty>())
{
// If we've been told to stop, we should not process any desired properties...
if (_lastCommandStatus == CommandStatus.PendingDMAppRestart)
{
break;
}
IClientPropertyHandler handler;
if (this._desiredPropertyMap.TryGetValue(sectionProp.Name, out handler))
{
StatusSection statusSection = new StatusSection(StatusSection.StateType.Pending);
await ReportStatusAsync(sectionProp.Name, statusSection);
try
{
Debug.WriteLine($"{sectionProp.Name} = {sectionProp.Value.ToString()}");
if (sectionProp.Value is JValue && sectionProp.Value.Type == JTokenType.String && (string)sectionProp.Value == "refreshing")
{
continue;
}
_lastCommandStatus = await handler.OnDesiredPropertyChange(sectionProp.Value);
statusSection.State = StatusSection.StateType.Completed;
await ReportStatusAsync(sectionProp.Name, statusSection);
}
catch (Error e)
{
statusSection.State = StatusSection.StateType.Failed;
statusSection.TheError = e;
Logger.Log(statusSection.ToString(), LoggingLevel.Error);
await ReportStatusAsync(sectionProp.Name, statusSection);
}
catch (Exception e)
{
statusSection.State = StatusSection.StateType.Failed;
statusSection.TheError = new Error(ErrorSubSystem.Unknown, e.HResult, e.Message);
Logger.Log(statusSection.ToString(), LoggingLevel.Error);
await ReportStatusAsync(sectionProp.Name, statusSection);
}
}
}
}
finally
{
this._desiredPropertiesLock.Release();
}
}