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