public async Task RunSampleAsync()
{
try
{
var devices = GenerateEdgeDevices(DeviceIdPrefix, NumOfEdgeDevices);
var conditionPropertyName = "condition-" + Guid.NewGuid().ToString("N");
var conditionPropertyValue = Guid.NewGuid().ToString();
var targetCondition = $"tags.{conditionPropertyName}='{conditionPropertyValue}'";
var edgeDevices = devices.ToList();
BulkRegistryOperationResult createResult = await CreateEdgeDevices(edgeDevices).ConfigureAwait(false);
if (createResult.Errors.Length > 0)
{
foreach (var err in createResult.Errors)
{
Console.WriteLine($"Create failed: {err.DeviceId}-{err.ErrorCode}-{err.ErrorStatus}");
}
}
foreach (var device in edgeDevices)
{
var twin = await _registryManager.GetTwinAsync(device.Id).ConfigureAwait(false);
twin.Tags[conditionPropertyName] = conditionPropertyValue;
await _registryManager.UpdateTwinAsync(device.Id, twin, twin.ETag).ConfigureAwait(false);
}
var baseConfiguration = new Configuration($"{ConfigurationIdPrefix}base-{Guid.NewGuid().ToString()}")
{
Labels = new Dictionary <string, string>
{
{ "App", "Mongo" }
},
Content = GetBaseConfigurationContent(),
Priority = BasePriority,
TargetCondition = targetCondition
};
var addOnConfiguration = new Configuration($"{ConfigurationIdPrefix}addon-{Guid.NewGuid().ToString()}")
{
Labels = new Dictionary <string, string>
{
{ "AddOn", "Stream Analytics" }
},
Content = GetAddOnConfigurationContent(),
Priority = BasePriority + 1,
TargetCondition = targetCondition
};
var baseConfigTask = _registryManager.AddConfigurationAsync(baseConfiguration);
var addOnConfigTask = _registryManager.AddConfigurationAsync(addOnConfiguration);
Task.WaitAll(baseConfigTask, addOnConfigTask);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static void Run([BlobTrigger("samples-workitems/{name}", Connection = "")] Stream myBlob, string name, ILogger log)
{
log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
try
{
string fwText = null;
using (TextReader tr = new StreamReader(myBlob))
{
fwText = tr.ReadToEnd();
}
Firmware fw = JsonConvert.DeserializeObject <Firmware>(fwText);
RegistryManager rm = RegistryManager.CreateFromConnectionString("<connection string>");
Configuration cfg = new Configuration(SanitizeConfigName(name));
cfg.Labels = new Dictionary <string, string>()
{
{ "AppType", "Firmware update" }
};
if (fw.Version.Minor > 0)
{
cfg.TargetCondition = $"properties.reported.firmware.version.major = {fw.Version.Major} AND (properties.reported.firmware.version.minor = {fw.Version.Minor - 1} or properties.reported.firmware.version.minor = {fw.Version.Minor})";
}
else
{
cfg.TargetCondition = $"properties.reported.firmware.version.major = {fw.Version.Major - 1} or properties.reported.firmware.version.major = {fw.Version.Major}";
}
cfg.Content = new ConfigurationContent();
cfg.Content.DeviceContent = new Dictionary <string, object> {
{
"properties.desired.firmware", new
{
version = new
{
major = fw.Version.Major,
minor = fw.Version.Minor,
},
url = fw.DownloadUrl.ToString()
}
}
};
cfg.Priority = fw.Version.Major * 10 + fw.Version.Minor;
if (fw.Version.Minor > 0)
{
cfg.Metrics.Queries.Add("compliant", $"select deviceId from devices where properties.reported.firmware.version.major > {fw.Version.Major} or (properties.reported.firmware.version.major = {fw.Version.Major} and properties.reported.firmware.version.minor >= {fw.Version.Minor})");
}
else
{
cfg.Metrics.Queries.Add("compliant", $"select deviceId from devices where properties.reported.firmware.version.major >= {fw.Version.Major}");
}
rm.AddConfigurationAsync(cfg).GetAwaiter().GetResult();
}
catch (Exception ex)
{
log.LogError(ex.ToString());
}
}
public async Task <bool> AddDeviceConfiguration(string configurationId,
string deviceContentKey,
object deviceContentValue,
Dictionary <string, string> metricsDictionary,
string targetCondition)
{
Configuration configuration = new Configuration(configurationId);
CreateDeviceContent(configuration, configurationId,
deviceContentKey, deviceContentValue);
CreateMetrics(configuration, configurationId, metricsDictionary);
CreateTargetCondition(configuration, configurationId, targetCondition);
Configuration configurationNew = await _registryManager.AddConfigurationAsync(configuration).ConfigureAwait(false);
if (configurationNew != null)
{
List <Configuration> configurations = await GetConfigurations(2);
foreach (Configuration item in configurations)
{
if (item.Id != configurationNew.Id)
{
await DeleteConfiguration(item.Id);
}
}
}
Console.WriteLine("Configuration added, id: " + configurationId);
return(true);
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.AddIotHubConfiguration))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.IotHubName = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.IotHubName = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.IotHubName);
}
IEnumerable <SharedAccessSignatureAuthorizationRule> authPolicies = this.IotHubClient.IotHubResource.ListKeys(this.ResourceGroupName, this.IotHubName);
SharedAccessSignatureAuthorizationRule policy = IotHubUtils.GetPolicy(authPolicies, PSAccessRights.RegistryWrite);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
PSConfiguration psConfiguration = new PSConfiguration();
psConfiguration.Id = this.Name;
psConfiguration.Priority = this.Priority;
psConfiguration.TargetCondition = string.IsNullOrEmpty(this.TargetCondition) ? "" : this.TargetCondition;
psConfiguration.Labels = new Hashtable();
psConfiguration.Metrics = new PSConfigurationMetrics()
{
Queries = new Hashtable(), Results = new Hashtable()
};
psConfiguration.Content = new PSConfigurationContent()
{
DeviceContent = new Hashtable(), ModulesContent = new Hashtable()
};
if (this.IsParameterBound(c => c.Label))
{
psConfiguration.Labels = this.Label;
}
if (this.IsParameterBound(c => c.Metric))
{
psConfiguration.Metrics.Queries = this.Metric;
}
psConfiguration.Content.ModulesContent = this.IsParameterBound(c => c.ModulesContent) ? this.ModulesContent : this.GetEdgeConfigurationContent();
this.WriteObject(IotHubDataPlaneUtils.ToPSDeployment(registryManager.AddConfigurationAsync(IotHubDataPlaneUtils.ToConfiguration(psConfiguration)).GetAwaiter().GetResult()));
}
}
private async Task AddDeviceConfiguration(string configurationId)
{
Configuration configuration = new Configuration(configurationId);
CreateDeviceContent(configuration, configurationId);
CreateMetricsAndTargetCondition(configuration, configurationId);
await _registryManager.AddConfigurationAsync(configuration).ConfigureAwait(false);
Console.WriteLine($"Configuration added, id: {configurationId}");
}
private static async Task AddDeviceConfiguration(RegistryManager registryManager, string configurationId)
{
Configuration configuration = new Configuration(configurationId);
CreateDeviceContent(configuration, configurationId);
CreateModulesContent(configuration, configurationId);
CreateMetricsAndTargetCondition(configuration, configurationId);
await registryManager.AddConfigurationAsync(configuration).ConfigureAwait(false);
Console.WriteLine("Configuration added, id: " + configurationId);
}
private async Task AddDeviceConfiguration(RegistryManager registryManager, string configurationId)
{
Configuration configuration = new Configuration(configurationId);
CreateModulesContent(configuration, configurationId);
// Add target condition, using "*" for all devices
configuration.TargetCondition = "*";
await registryManager.AddConfigurationAsync(configuration).ConfigureAwait(false);
Console.WriteLine("Configuration added, id: " + configurationId);
}
/// <summary>
/// Create or update deployment configuration
/// </summary>
/// <param name="configuration"></param>
/// <param name="forceUpdate"></param>
/// <param name="deploymentId"></param>
/// <param name="ct"> Cancellation token </param>
public async Task <Configuration> CreateOrUpdateConfigurationAsync(
Configuration configuration,
bool forceUpdate,
string deploymentId,
CancellationToken ct = default
)
{
try {
var getConfig = await RegistryManager.GetConfigurationAsync(deploymentId, ct);
if (getConfig == null)
{
// First try create configuration
try {
_context.OutputHelper?.WriteLine("Add new IoT Hub device configuration");
var added = await RegistryManager.AddConfigurationAsync(
configuration, ct);
return(added);
}
catch (DeviceAlreadyExistsException) when(forceUpdate)
{
//
// Technically update below should now work but for
// some reason it does not.
// Remove and re-add in case we are forcing updates.
//
_context.OutputHelper?.WriteLine("IoT Hub device configuration already existed, remove and recreate it");
await RegistryManager.RemoveConfigurationAsync(configuration.Id, ct);
var added = await RegistryManager.AddConfigurationAsync(
configuration, ct);
return(added);
}
}
_context.OutputHelper?.WriteLine("IoT Hub device configuration will be updated");
// Try update existing configuration
var result = await RegistryManager.UpdateConfigurationAsync(
configuration, forceUpdate, ct);
return(result);
}
catch (Exception e) {
_context.OutputHelper?.WriteLine("Error while creating or updating IoT Hub device configuration! {0}", e.Message);
throw;
}
}
/// <summary>
/// Create or update deployment configuration
/// </summary>
/// <param name="configuration"></param>
/// <param name="deploymentId"></param>
/// <param name="ct"> Cancellation token </param>
public async Task <Configuration> CreateOrUpdateConfigurationAsync(
Configuration configuration,
CancellationToken ct = default
)
{
try {
var getConfig = await RegistryManager.GetConfigurationAsync(configuration.Id, ct).ConfigureAwait(false);
if (getConfig == null)
{
// First try create configuration
try {
_context.OutputHelper?.WriteLine("Add new IoT Hub device configuration");
return(await RegistryManager.AddConfigurationAsync(configuration, ct).ConfigureAwait(false));
}
catch (DeviceAlreadyExistsException) {
// Technically update below should now work but for some reason it does not.
// Remove and re-add in case we are forcing updates.
_context.OutputHelper?.WriteLine("IoT Hub device configuration already existed, remove and recreate it");
await RegistryManager.RemoveConfigurationAsync(configuration.Id, ct).ConfigureAwait(false);
return(await RegistryManager.AddConfigurationAsync(configuration, ct).ConfigureAwait(false));
}
}
if (Equals(configuration, getConfig))
{
return(getConfig);
}
_context.OutputHelper?.WriteLine("Existing IoT Hub device configuration is different, remove and recreate it");
await RegistryManager.RemoveConfigurationAsync(configuration.Id, ct).ConfigureAwait(false);
return(await RegistryManager.AddConfigurationAsync(configuration, ct).ConfigureAwait(false));
}
catch (Exception e) {
_context.OutputHelper?.WriteLine("Error while creating or updating IoT Hub device configuration! {0}", e.Message);
throw;
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.AddIotHubConfiguration))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.IotHubName = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.IotHubName = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.IotHubName);
}
IEnumerable <SharedAccessSignatureAuthorizationRule> authPolicies = this.IotHubClient.IotHubResource.ListKeys(this.ResourceGroupName, this.IotHubName);
SharedAccessSignatureAuthorizationRule policy = IotHubUtils.GetPolicy(authPolicies, PSAccessRights.RegistryWrite);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
PSConfiguration psConfiguration = new PSConfiguration();
psConfiguration.Id = this.Name;
psConfiguration.Priority = this.Priority;
psConfiguration.TargetCondition = string.IsNullOrEmpty(this.TargetCondition) ? "" : this.TargetCondition;
psConfiguration.Labels = new Hashtable();
psConfiguration.Metrics = new PSConfigurationMetrics()
{
Queries = new Hashtable(), Results = new Hashtable()
};
psConfiguration.Content = new PSConfigurationContent()
{
DeviceContent = new Hashtable(), ModulesContent = new Hashtable()
};
if (this.IsParameterBound(c => c.Label))
{
psConfiguration.Labels = this.Label;
}
if (this.IsParameterBound(c => c.Metric))
{
psConfiguration.Metrics.Queries = this.Metric;
}
if (this.IsParameterBound(c => c.DeviceContent))
{
foreach (DictionaryEntry kvp in this.DeviceContent)
{
if (!Convert.ToString(kvp.Key).StartsWith("properties.desired", StringComparison.InvariantCultureIgnoreCase))
{
throw new ArgumentException("The device content key must begin with \"properties.desired\".");
}
}
psConfiguration.Content.DeviceContent = this.DeviceContent;
}
this.WriteObject(IotHubDataPlaneUtils.ToPSConfiguration(registryManager.AddConfigurationAsync(IotHubDataPlaneUtils.ToConfiguration(psConfiguration)).GetAwaiter().GetResult()));
}
}
public async Task RegistryManager_ExportDevices(StorageAuthenticationType storageAuthenticationType, bool isUserAssignedMsi)
{
// arrange
const string idPrefix = nameof(RegistryManager_ExportDevices);
string edgeId1 = $"{idPrefix}-Edge-{StorageContainer.GetRandomSuffix(4)}";
string edgeId2 = $"{idPrefix}-Edge-{StorageContainer.GetRandomSuffix(4)}";
string deviceId = $"{idPrefix}-{StorageContainer.GetRandomSuffix(4)}";
string configurationId = (idPrefix + Guid.NewGuid()).ToLower(); // Configuration Id characters must be all lower-case.
Logger.Trace($"Using Ids {deviceId}, {edgeId1}, {edgeId2}, and {configurationId}");
string devicesFileName = $"{idPrefix}-devicesexport-{StorageContainer.GetRandomSuffix(4)}.txt";
string configsFileName = $"{idPrefix}-configsexport-{StorageContainer.GetRandomSuffix(4)}.txt";
using RegistryManager registryManager = RegistryManager.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString);
try
{
string containerName = StorageContainer.BuildContainerName(idPrefix);
using StorageContainer storageContainer = await StorageContainer
.GetInstanceAsync(containerName)
.ConfigureAwait(false);
Logger.Trace($"Using container {storageContainer.Uri}");
Uri containerUri = storageAuthenticationType == StorageAuthenticationType.KeyBased
? storageContainer.SasUri
: storageContainer.Uri;
Device edge1 = await registryManager
.AddDeviceAsync(
new Device(edgeId1)
{
Authentication = new AuthenticationMechanism {
Type = AuthenticationType.Sas
},
Capabilities = new Shared.DeviceCapabilities {
IotEdge = true
},
})
.ConfigureAwait(false);
Device edge2 = await registryManager
.AddDeviceAsync(
new Device(edgeId2)
{
Authentication = new AuthenticationMechanism {
Type = AuthenticationType.Sas
},
Capabilities = new Shared.DeviceCapabilities {
IotEdge = true
},
ParentScopes = { edge1.Scope },
})
.ConfigureAwait(false);
Device device = await registryManager
.AddDeviceAsync(
new Device(deviceId)
{
Authentication = new AuthenticationMechanism {
Type = AuthenticationType.Sas
},
Scope = edge1.Scope,
})
.ConfigureAwait(false);
Configuration configuration = await registryManager
.AddConfigurationAsync(
new Configuration(configurationId)
{
Priority = 2,
Labels = { { "labelName", "labelValue" } },
TargetCondition = "*",
Content =
{
DeviceContent = { { "properties.desired.x", 4L } },
},
Metrics =
{
Queries = { { "successfullyConfigured", "select deviceId from devices where properties.reported.x = 4" } }
},
})
.ConfigureAwait(false);
// act
JobProperties exportJobResponse = await CreateAndWaitForJobAsync(
storageAuthenticationType,
isUserAssignedMsi,
devicesFileName,
configsFileName,
registryManager,
containerUri)
.ConfigureAwait(false);
// assert
await ValidateDevicesAsync(
devicesFileName,
storageContainer,
edge1,
edge2,
device)
.ConfigureAwait(false);
await ValidateConfigurationsAsync(
configsFileName,
storageContainer,
configuration)
.ConfigureAwait(false);
}
finally
{
await CleanUpDevicesAsync(edgeId1, edgeId2, deviceId, configurationId, registryManager).ConfigureAwait(false);
}
}
