public override void ExecuteCmdlet() { 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); if (this.Name != null) { this.WriteObject(IotHubDataPlaneUtils.ToPSDeployment(registryManager.GetConfigurationAsync(this.Name).GetAwaiter().GetResult())); } else { this.WriteObject(IotHubDataPlaneUtils.ToPSDeployments(registryManager.GetConfigurationsAsync(Int32.MaxValue).GetAwaiter().GetResult()), true); } }
public override void ExecuteCmdlet() { if (ShouldProcess(this.IotHubName, Properties.Resources.SetIotHubConfiguration)) { 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); Configuration config = registryManager.GetConfigurationAsync(this.Name).GetAwaiter().GetResult(); if (config != null && config.Content.ModulesContent != null) { PSDeployment psDeployment = IotHubDataPlaneUtils.ToPSDeployment(config); if (this.IsParameterBound(c => c.Priority)) { psDeployment.Priority = this.Priority; } if (this.IsParameterBound(c => c.TargetCondition)) { psDeployment.TargetCondition = this.TargetCondition; } if (this.IsParameterBound(c => c.Label)) { psDeployment.Labels = this.Label; } if (this.IsParameterBound(c => c.Metric)) { psDeployment.Metrics.Queries = this.Metric; } this.WriteObject(IotHubDataPlaneUtils.ToPSDeployment(registryManager.UpdateConfigurationAsync(IotHubDataPlaneUtils.ToConfiguration(psDeployment), this.Force.IsPresent).GetAwaiter().GetResult())); } else { throw new ArgumentException("The deployment doesn't exist."); } } }
/// <summary> /// Wait until one successful deployment is reported. /// </summary> public async Task WaitForSuccessfulDeploymentAsync( Configuration deploymentConfiguration, CancellationToken ct) { try { while (true) { ct.ThrowIfCancellationRequested(); var activeConfiguration = await RegistryManager .GetConfigurationAsync(deploymentConfiguration.Id, ct) .ConfigureAwait(false); if (activeConfiguration != null && Equals(activeConfiguration, deploymentConfiguration) && activeConfiguration.SystemMetrics.Results.ContainsKey("reportedSuccessfulCount") && activeConfiguration.SystemMetrics.Results["reportedSuccessfulCount"] == 1) { _context.OutputHelper?.WriteLine("All required IoT Edge modules are loaded!"); return; } await Task.Delay(TestConstants.DefaultDelayMilliseconds, ct).ConfigureAwait(false); } } catch (OperationCanceledException) { _context.OutputHelper?.WriteLine("Waiting for IoT Edge modules to be loaded timeout - please check iot edge device for details"); throw; } catch (Exception e) { _context.OutputHelper?.WriteLine("Error occurred while waiting for edge Modules"); _context.OutputHelper?.WriteLine(e.Message); throw; } }
/// <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.InvokeIotHubConfigurationMetricsQuery)) { 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); Configuration config = registryManager.GetConfigurationAsync(this.Name).GetAwaiter().GetResult(); if (config != null && config.Content.ModulesContent != null) { PSDeployment psDeployment = IotHubDataPlaneUtils.ToPSDeployment(config); Hashtable queries; string metricKey = this.MetricName; if (this.MetricType.Equals(PSConfigurationMetricType.System)) { if (this.MetricName.Equals("targeted", StringComparison.OrdinalIgnoreCase)) { metricKey = "targetedCount"; } if (this.MetricName.Equals("applied", StringComparison.OrdinalIgnoreCase)) { metricKey = "appliedCount"; } if (this.MetricName.Equals("reporting success", StringComparison.OrdinalIgnoreCase)) { metricKey = "reportedSuccessfulCount"; } if (this.MetricName.Equals("reporting failure", StringComparison.OrdinalIgnoreCase)) { metricKey = "reportedFailedCount"; } queries = psDeployment.SystemMetrics.Queries; } else { queries = psDeployment.Metrics.Queries; } if (queries.ContainsKey(metricKey)) { PSConfigurationMetricsResult psConfigurationMetricsResult = new PSConfigurationMetricsResult(); psConfigurationMetricsResult.Name = this.MetricName; psConfigurationMetricsResult.Criteria = queries[metricKey].ToString(); IQuery metricQuery = registryManager.CreateQuery(queries[metricKey].ToString()); psConfigurationMetricsResult.Result = metricQuery.GetNextAsJsonAsync().GetAwaiter().GetResult().ToList(); this.WriteObject(psConfigurationMetricsResult); } else { throw new ArgumentException(string.Format("The metric '{0}' is not defined in the deployment '{1}'", this.MetricName, this.Name)); } } else { throw new ArgumentException("The deployment doesn't exist."); } } }
public async Task RegistryManager_ImportDevices(StorageAuthenticationType storageAuthenticationType, bool isUserAssignedMsi) { // arrange const string idPrefix = nameof(RegistryManager_ImportDevices); string deviceId = $"{idPrefix}-device-{StorageContainer.GetRandomSuffix(4)}"; string configId = $"{idPrefix}-config-{StorageContainer.GetRandomSuffix(4)}".ToLower(); // Configuration Id characters must be all lower-case. Logger.Trace($"Using Ids {deviceId} and {configId}."); string devicesFileName = $"{idPrefix}-devices-{StorageContainer.GetRandomSuffix(4)}.txt"; string configsFileName = $"{idPrefix}-configs-{StorageContainer.GetRandomSuffix(4)}.txt"; using RegistryManager registryManager = RegistryManager.CreateFromConnectionString(TestConfiguration.IoTHub.ConnectionString); try { string containerName = StorageContainer.BuildContainerName(nameof(RegistryManager_ImportDevices)); using StorageContainer storageContainer = await StorageContainer.GetInstanceAsync(containerName).ConfigureAwait(false); Logger.Trace($"Using devices container {storageContainer.Uri}"); Uri containerUri = storageAuthenticationType == StorageAuthenticationType.KeyBased ? storageContainer.SasUri : storageContainer.Uri; using Stream devicesStream = ImportExportHelpers.BuildImportStream( new List <ExportImportDevice> { new ExportImportDevice( new Device(deviceId) { Authentication = new AuthenticationMechanism { Type = AuthenticationType.Sas } }, ImportMode.Create), }); await UploadFileAndConfirmAsync(storageContainer, devicesStream, devicesFileName).ConfigureAwait(false); using Stream configsStream = ImportExportHelpers.BuildImportStream( new List <ImportConfiguration> { new ImportConfiguration(configId) { ImportMode = ConfigurationImportMode.CreateOrUpdateIfMatchETag, Priority = 3, Labels = { { "labelName", "labelValue" } }, TargetCondition = "*", Content = { DeviceContent = { { "properties.desired.x", 5L } }, }, Metrics = { Queries = { { "successfullyConfigured", "select deviceId from devices where properties.reported.x = 5" } } }, }, }); await UploadFileAndConfirmAsync(storageContainer, configsStream, configsFileName).ConfigureAwait(false); ManagedIdentity identity = isUserAssignedMsi ? new ManagedIdentity { UserAssignedIdentity = TestConfiguration.IoTHub.UserAssignedMsiResourceId } : null; // act JobProperties importJobResponse = await CreateAndWaitForJobAsync( storageAuthenticationType, devicesFileName, configsFileName, registryManager, containerUri, identity) .ConfigureAwait(false); // assert importJobResponse.Status.Should().Be(JobStatus.Completed, "Otherwise import failed"); importJobResponse.FailureReason.Should().BeNullOrEmpty("Otherwise import failed"); // should not throw due to 404, but device may not immediately appear in registry Device device = null; Configuration config = null; for (int i = 0; i < MaxIterationWait; ++i) { await Task.Delay(s_waitDuration).ConfigureAwait(false); try { device = await registryManager.GetDeviceAsync(deviceId).ConfigureAwait(false); config = await registryManager.GetConfigurationAsync(configId).ConfigureAwait(false); break; } catch (Exception ex) { Logger.Trace($"Could not find device/config on iteration {i} due to [{ex.Message}]"); } } if (device == null) { Assert.Fail($"Device {deviceId} not found in registry manager"); } if (config == null) { Assert.Fail($"Config {configId} not found in registry manager"); } } finally { try { await registryManager.RemoveDeviceAsync(deviceId).ConfigureAwait(false); await registryManager.RemoveConfigurationAsync(configId).ConfigureAwait(false); } catch (Exception ex) { Logger.Trace($"Failed to clean up device/config due to {ex}"); } } }
public override void ExecuteCmdlet() { if (ShouldProcess(this.IotHubName, Properties.Resources.RemoveIotHubConfiguration)) { 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); try { if (this.Name != null) { Configuration config = registryManager.GetConfigurationAsync(this.Name).GetAwaiter().GetResult(); if (config != null && config.Content.ModulesContent == null) { registryManager.RemoveConfigurationAsync(this.Name).GetAwaiter().GetResult(); } else { throw new ArgumentException("The configuration doesn't exist."); } } else { IEnumerable <Configuration> configs = registryManager.GetConfigurationsAsync(Int32.MaxValue).GetAwaiter().GetResult(); foreach (Configuration config in configs) { if (config.Content.ModulesContent == null) { registryManager.RemoveConfigurationAsync(config).GetAwaiter().GetResult(); } } } if (PassThru.IsPresent) { this.WriteObject(true); } } catch { if (PassThru.IsPresent) { this.WriteObject(false); } } } }