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()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (string.IsNullOrEmpty(this.RouteName))
{
this.WriteObject(IotHubUtils.ToPSRouteProperties(iotHubDescription.Properties.Routing.Routes), true);
}
else
{
this.WriteObject(IotHubUtils.ToPSRouteMetadata(iotHubDescription.Properties.Routing.Routes.FirstOrDefault(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase))), false);
}
}
public override void ExecuteCmdlet()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (string.IsNullOrEmpty(this.Key))
{
this.WriteObject(IotHubUtils.ToPSEnrichmentProperties(iotHubDescription.Properties.Routing.Enrichments), true);
}
else
{
if (!iotHubDescription.Properties.Routing.Enrichments.Any(x => x.Key.Equals(this.Key.Trim(), StringComparison.OrdinalIgnoreCase)))
{
throw new ArgumentException(string.Format(Properties.Resources.MessageEnrichmentKeyMissing, this.Key));
}
this.WriteObject(IotHubUtils.ToPSEnrichmentMetadata(iotHubDescription.Properties.Routing.Enrichments.FirstOrDefault(x => x.Key.Equals(this.Key, StringComparison.OrdinalIgnoreCase))), false);
}
}
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.");
}
}
}
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);
Twin deviceTwin = registryManager.GetTwinAsync(this.DeviceId).GetAwaiter().GetResult();
if (deviceTwin == null)
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" doesn't exist.");
}
this.WriteObject(IotHubDataPlaneUtils.ToPSDeviceTwin(deviceTwin));
}
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()));
}
}
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)
{
registryManager.RemoveConfigurationAsync(this.Name).GetAwaiter().GetResult();
}
else
{
IEnumerable <Configuration> configs = registryManager.GetConfigurationsAsync(Int32.MaxValue).GetAwaiter().GetResult();
foreach (Configuration config in configs)
{
registryManager.RemoveConfigurationAsync(config).GetAwaiter().GetResult();
}
}
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.ModuleId, Properties.Resources.AddIotHubModule))
{
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);
PSAuthenticationMechanism auth = new PSAuthenticationMechanism();
PSModule module = new PSModule();
module.Id = this.ModuleId;
module.DeviceId = this.DeviceId;
switch (this.AuthMethod)
{
case PSDeviceAuthType.x509_thumbprint:
auth.Type = PSAuthenticationType.SelfSigned;
auth.X509Thumbprint = new PSX509Thumbprint();
auth.X509Thumbprint.PrimaryThumbprint = this.authTypeDynamicParameter.PrimaryThumbprint;
auth.X509Thumbprint.SecondaryThumbprint = this.authTypeDynamicParameter.SecondaryThumbprint;
break;
case PSDeviceAuthType.x509_ca:
auth.Type = PSAuthenticationType.CertificateAuthority;
break;
default:
auth.SymmetricKey = new PSSymmetricKey();
auth.Type = PSAuthenticationType.Sas;
break;
}
module.Authentication = auth;
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
this.WriteObject(IotHubDataPlaneUtils.ToPSModule(registryManager.AddModuleAsync(IotHubDataPlaneUtils.ToModule(module)).GetAwaiter().GetResult()));
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.RouteName, Properties.Resources.UpdateIotHubRoute))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (iotHubDescription.Properties.Routing.Routes.Any(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase)))
{
RouteProperties routeProperties = iotHubDescription.Properties.Routing.Routes.FirstOrDefault(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase));
if (this.Source.HasValue)
{
routeProperties.Source = this.Source.Value.ToString();
}
if (!string.IsNullOrEmpty(this.EndpointName))
{
routeProperties.EndpointNames = new List <string>()
{
this.EndpointName
};
}
if (!string.IsNullOrEmpty(this.Condition))
{
routeProperties.Condition = this.Condition;
}
if (this.Enabled.IsPresent)
{
routeProperties.IsEnabled = this.Enabled.IsPresent;
}
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
IotHubDescription updatedIotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
this.WriteObject(IotHubUtils.ToPSRouteMetadata(updatedIotHubDescription.Properties.Routing.Routes.FirstOrDefault(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase))), false);
}
else
{
throw new ArgumentException("Entered route doesn't exist.");
}
}
}
public override void ExecuteCmdlet()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (ShouldProcess(this.Key, Properties.Resources.RemoveIotHubMessageEnrichment))
{
if (string.IsNullOrEmpty(this.Key))
{
iotHubDescription.Properties.Routing.Enrichments = new List <EnrichmentProperties>();
}
else
{
if (!iotHubDescription.Properties.Routing.Enrichments.Any(x => x.Key.Equals(this.Key.Trim(), StringComparison.OrdinalIgnoreCase)))
{
throw new ArgumentException(string.Format(Properties.Resources.MessageEnrichmentKeyMissing, this.Key));
}
iotHubDescription.Properties.Routing.Enrichments = iotHubDescription.Properties.Routing.Enrichments.Where(x => x.Key.ToLowerInvariant() != this.Key.ToLowerInvariant()).ToList();
}
try
{
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.UpdateIotHubDeviceTwin))
{
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);
Twin deviceTwin = registryManager.GetTwinAsync(this.DeviceId).GetAwaiter().GetResult();
if (deviceTwin == null)
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" doesn't exist.");
}
if (this.IsParameterBound(c => c.Tag))
{
deviceTwin.Tags = new TwinCollection(JsonConvert.SerializeObject(this.Tag));
}
if (this.IsParameterBound(c => c.Desired))
{
deviceTwin.Properties.Desired = new TwinCollection(JsonConvert.SerializeObject(this.Desired));
}
if (this.Partial.IsPresent)
{
this.WriteObject(registryManager.UpdateTwinAsync(this.DeviceId, deviceTwin, deviceTwin.ETag).GetAwaiter().GetResult());
}
else
{
this.WriteObject(registryManager.ReplaceTwinAsync(this.DeviceId, deviceTwin, deviceTwin.ETag).GetAwaiter().GetResult());
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.SetIotHubDistributedTracing))
{
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);
PSDistributedTracing psDistributedTracing = new PSDistributedTracing();
Twin deviceTwin = registryManager.GetTwinAsync(this.DeviceId).GetAwaiter().GetResult();
IotHubDataPlaneUtils.ValidateDeviceTracing(this.DeviceId, iotHubDescription.Sku.Tier.Value.ToString(), iotHubDescription.Location, deviceTwin.Capabilities.IotEdge);
if (deviceTwin.Properties.Desired.Contains(IotHubDataPlaneUtils.TracingProperty))
{
psDistributedTracing = JsonConvert.DeserializeObject <PSDistributedTracing>(deviceTwin.Properties.Desired[IotHubDataPlaneUtils.TracingProperty].ToString());
}
psDistributedTracing.SamplingMode = this.SamplingMode;
if (this.SamplingMode.Equals(PSDistributedTracingSamplingMode.Enabled))
{
if (this.IsParameterBound(c => c.SamplingRate))
{
psDistributedTracing.SamplingRate = this.SamplingRate;
}
}
deviceTwin.Properties.Desired[IotHubDataPlaneUtils.TracingProperty] = psDistributedTracing;
deviceTwin = registryManager.UpdateTwinAsync(this.DeviceId, deviceTwin, deviceTwin.ETag).GetAwaiter().GetResult();
this.WriteObject(IotHubDataPlaneUtils.GetDeviceTracing(this.DeviceId, deviceTwin));
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.Key, Properties.Resources.AddIotHubMessageEnrichment))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (iotHubDescription.Properties.Routing.Enrichments == null)
{
iotHubDescription.Properties.Routing.Enrichments = new List <EnrichmentProperties>();
}
if (!iotHubDescription.Properties.Routing.Enrichments.Any(x => x.Key.Equals(this.Key.Trim(), StringComparison.OrdinalIgnoreCase)))
{
IList <string> endpointNames = new List <string>();
foreach (string endpoint in this.Endpoint)
{
endpointNames.Add(endpoint.Trim());
}
iotHubDescription.Properties.Routing.Enrichments.Add(
new EnrichmentProperties(
this.Key.Trim(),
this.Value.Trim(),
endpointNames
));
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
IotHubDescription updatedIotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
this.WriteObject(IotHubUtils.ToPSEnrichmentMetadata(updatedIotHubDescription.Properties.Routing.Enrichments.FirstOrDefault(x => x.Key.Equals(this.Key, StringComparison.OrdinalIgnoreCase))), false);
}
else
{
throw new ArgumentException(string.Format(Properties.Resources.MessageEnrichmentKeyExist, this.Key));
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.InvokeIotHubDeviceMethod))
{
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.ServiceConnect);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
if (!this.IsParameterBound(c => c.ResponseTimeOut))
{
this.ResponseTimeOut = 10;
}
if (!this.IsParameterBound(c => c.ConnectionTimeOut))
{
this.ConnectionTimeOut = 10;
}
CloudToDeviceMethod method = new CloudToDeviceMethod(this.Name, new TimeSpan(0, 0, this.ResponseTimeOut), new TimeSpan(0, 0, this.ConnectionTimeOut));
if (this.IsParameterBound(c => c.Payload))
{
method = method.SetPayloadJson(this.Payload);
}
CloudToDeviceMethodResult result = serviceClient.InvokeDeviceMethodAsync(this.DeviceId, method).GetAwaiter().GetResult();
PSCloudToDeviceMethodResult psCloudToDeviceMethodResult = new PSCloudToDeviceMethodResult()
{
Status = result.Status,
Payload = result.GetPayloadAsJson()
};
this.WriteObject(psCloudToDeviceMethodResult);
}
}
public override void ExecuteCmdlet()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectTestRouteParameterSet) || ParameterSetName.Equals(InputObjectTestAllRouteParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdTestRouteParameterSet) || ParameterSetName.Equals(ResourceIdTestAllRouteParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
RoutingMessage routingMessage = new RoutingMessage(this.Body, this.AppProperty != null ? this.AppProperty.Cast <DictionaryEntry>().ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value) : null, this.SystemProperty != null ? this.SystemProperty.Cast <DictionaryEntry>().ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value) : null);
switch (ParameterSetName)
{
case InputObjectTestRouteParameterSet:
case ResourceIdTestRouteParameterSet:
case TestRouteParameterSet:
TestRouteInput testRouteInput = new TestRouteInput();
testRouteInput.Message = routingMessage;
testRouteInput.Route = iotHubDescription.Properties.Routing.Routes.FirstOrDefault(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase));
PSTestRouteResult psTestRouteResult = IotHubUtils.ToPSTestRouteResult(this.IotHubClient.IotHubResource.TestRoute(testRouteInput, this.Name, this.ResourceGroupName));
if (this.ShowError.IsPresent && psTestRouteResult.Details != null)
{
this.WriteObject(psTestRouteResult.Details.CompilationErrors, true);
}
else
{
this.WriteObject(psTestRouteResult, false);
}
break;
case InputObjectTestAllRouteParameterSet:
case ResourceIdTestAllRouteParameterSet:
case TestAllRouteParameterSet:
TestAllRoutesInput testAllRoutesInput = new TestAllRoutesInput();
testAllRoutesInput.RoutingSource = this.Source.ToString();
testAllRoutesInput.Message = routingMessage;
this.WriteObject(IotHubUtils.ToPSRouteProperties(this.IotHubClient.IotHubResource.TestAllRoutes(testAllRoutesInput, this.Name, this.ResourceGroupName).Routes), true);
break;
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.AddIotHubDevice))
{
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);
Device childDevice = registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult();
Device parentDevice = registryManager.GetDeviceAsync(this.ParentDeviceId).GetAwaiter().GetResult();
if (childDevice.Capabilities.IotEdge)
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" should be non-edge device.");
}
if (!parentDevice.Capabilities.IotEdge)
{
throw new ArgumentException($"The entered parent device \"{this.ParentDeviceId}\" should be edge device.");
}
if (!string.IsNullOrEmpty(childDevice.Scope) && !childDevice.Scope.Equals(parentDevice.Scope) && !this.Force.IsPresent)
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" already has a parent device, please use '-Force' to overwrite.");
}
childDevice.Scope = parentDevice.Scope;
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(registryManager.UpdateDeviceAsync(childDevice).GetAwaiter().GetResult()));
}
}
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.RegistryRead);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
if (this.DeviceId != null)
{
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult()));
}
else
{
IList <Device> devices = new List <Device>();
IEnumerable <string> deviceResults = registryManager.CreateQuery("Select * from Devices").GetNextAsJsonAsync().GetAwaiter().GetResult();
foreach (string deviceResult in deviceResults)
{
Device d = JsonConvert.DeserializeObject <Device>(deviceResult);
devices.Add(registryManager.GetDeviceAsync(d.Id).GetAwaiter().GetResult());
}
if (devices.Count == 1)
{
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(devices[0]));
}
else
{
this.WriteObject(IotHubDataPlaneUtils.ToPSDevices(devices), true);
}
}
}
public override void ExecuteCmdlet()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (ShouldProcess(RouteName, Properties.Resources.RemoveIotHubRoute))
{
if (string.IsNullOrEmpty(this.RouteName))
{
iotHubDescription.Properties.Routing.Routes = new List <RouteProperties>();
}
else
{
iotHubDescription.Properties.Routing.Routes = iotHubDescription.Properties.Routing.Routes.Where(x => x.Name.ToLowerInvariant() != this.RouteName.ToLowerInvariant()).ToList();
}
try
{
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.SendIotHubD2CMessage))
{
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);
Devices.Client.TransportType transportType = (Devices.Client.TransportType)Enum.Parse(typeof(Devices.Client.TransportType), this.TransportType.ToString());
Devices.Client.Message message = new Devices.Client.Message(new MemoryStream(Encoding.UTF8.GetBytes(this.Message)));
try
{
DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString, this.DeviceId, transportType);
deviceClient.SendEventAsync(message).GetAwaiter().GetResult();
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}
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.RegistryRead);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
Device device = registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult();
if (device != null)
{
List <Module> modules = registryManager.GetModulesOnDeviceAsync(this.DeviceId).GetAwaiter().GetResult().ToList();
if (this.ModuleId != null)
{
if (modules.Any(m => m.Id.Equals(this.ModuleId)))
{
this.WriteObject(GetModuleConnectionString(modules.FirstOrDefault(m => m.Id.Equals(this.ModuleId)), iotHubDescription.Properties.HostName));
}
}
else
{
IList <PSModuleConnectionString> psModuleConnectionStringCollection = new List <PSModuleConnectionString>();
foreach (Module module in modules)
{
psModuleConnectionStringCollection.Add(GetModuleConnectionString(module, iotHubDescription.Properties.HostName));
}
this.WriteObject(psModuleConnectionStringCollection, true);
}
}
}
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.RegistryRead);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
Device childDevice = registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult();
if (childDevice.Capabilities.IotEdge)
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" should be non-edge device.");
}
if (string.IsNullOrEmpty(childDevice.Scope))
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" doesn\'t support parent device functionality.");
}
string parentDeviceId = childDevice.Scope.Substring(Properties.Resources.DEVICE_DEVICESCOPE_PREFIX.Length, childDevice.Scope.LastIndexOf("-") - Properties.Resources.DEVICE_DEVICESCOPE_PREFIX.Length);
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(registryManager.GetDeviceAsync(parentDeviceId).GetAwaiter().GetResult()));
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.InvokeIotHubQuery))
{
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.RegistryRead);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
IQuery query;
if (this.IsParameterBound(c => c.Top))
{
query = registryManager.CreateQuery(this.Query, this.Top);
}
else
{
query = registryManager.CreateQuery(this.Query);
}
this.WriteObject(query.GetNextAsJsonAsync().GetAwaiter().GetResult(), true);
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.RouteName, Properties.Resources.AddIotHubRoute))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
iotHubDescription.Properties.Routing.Routes.Add(
new RouteProperties(
this.RouteName,
this.Source.ToString(),
new List <string>()
{
this.EndpointName
},
this.Enabled.IsPresent,
string.IsNullOrEmpty(this.Condition) ? null : this.Condition
));
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
IotHubDescription updatedIotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
this.WriteObject(IotHubUtils.ToPSRouteMetadata(updatedIotHubDescription.Properties.Routing.Routes.FirstOrDefault(x => x.Name.Equals(this.RouteName, StringComparison.OrdinalIgnoreCase))), false);
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.SetIotHubEdgeModules))
{
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);
PSConfigurationContent content = new PSConfigurationContent()
{
DeviceContent = null, ModulesContent = this.ModulesContent
};
registryManager.ApplyConfigurationContentOnDeviceAsync(this.DeviceId, IotHubUtils.ConvertObject <PSConfigurationContent, ConfigurationContent>(content)).GetAwaiter().GetResult();
this.WriteObject(IotHubDataPlaneUtils.ToPSModules(registryManager.GetModulesOnDeviceAsync(this.DeviceId).GetAwaiter().GetResult()), true);
}
}
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 override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.UpdateIotHubDevice))
{
IotHubDescription iotHubDescription = null;
switch (ParameterSetName)
{
case InputObjectParameterSetForAuth:
case InputObjectParameterSetForStatus:
case InputObjectParameterSetForEdgeEnabled:
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.IotHubName = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
break;
case ResourceIdParameterSetForAuth:
case ResourceIdParameterSetForStatus:
case ResourceIdParameterSetForEdgeEnabled:
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.IotHubName = IotHubUtils.GetIotHubName(this.ResourceId);
break;
}
if (iotHubDescription == null)
{
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);
PSDevice device = IotHubDataPlaneUtils.ToPSDevice(registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult());
switch (ParameterSetName)
{
case InputObjectParameterSetForAuth:
case ResourceIdParameterSetForAuth:
case ResourceParameterSetForAuth:
PSAuthenticationMechanism auth = new PSAuthenticationMechanism();
switch (this.AuthMethod)
{
case PSDeviceAuthType.x509_thumbprint:
auth.Type = PSAuthenticationType.SelfSigned;
auth.X509Thumbprint = new PSX509Thumbprint();
auth.X509Thumbprint.PrimaryThumbprint = this.authTypeDynamicParameter.PrimaryThumbprint;
auth.X509Thumbprint.SecondaryThumbprint = this.authTypeDynamicParameter.SecondaryThumbprint;
break;
case PSDeviceAuthType.x509_ca:
auth.Type = PSAuthenticationType.CertificateAuthority;
break;
default:
auth.SymmetricKey = new PSSymmetricKey();
auth.Type = PSAuthenticationType.Sas;
break;
}
device.Authentication = auth;
break;
case InputObjectParameterSetForStatus:
case ResourceIdParameterSetForStatus:
case ResourceParameterSetForStatus:
device.Status = this.Status;
device.StatusReason = this.StatusReason;
break;
case InputObjectParameterSetForEdgeEnabled:
case ResourceIdParameterSetForEdgeEnabled:
case ResourceParameterSetForEdgeEnabled:
device.Capabilities.IotEdge = this.EdgeEnabled;
break;
}
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(registryManager.UpdateDeviceAsync(IotHubDataPlaneUtils.ToDevice(device)).GetAwaiter().GetResult()));
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.IotHubName, Properties.Resources.NewIotHubSasToken))
{
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);
}
if (this.IsParameterBound(c => c.ModuleId) && !this.IsParameterBound(c => c.DeviceId))
{
throw new ArgumentException("You are unable to get sas token for module without device information.");
}
if (!this.IsParameterBound(c => c.Duration))
{
this.Duration = 3600;
}
string resourceUri = string.Empty;
string keyName = string.Empty;
string key = string.Empty;
if (this.IsParameterBound(c => c.DeviceId))
{
IEnumerable <SharedAccessSignatureAuthorizationRule> authPolicies = this.IotHubClient.IotHubResource.ListKeys(this.ResourceGroupName, this.IotHubName);
SharedAccessSignatureAuthorizationRule policy = IotHubUtils.GetPolicy(authPolicies, PSAccessRights.RegistryRead);
PSIotHubConnectionString psIotHubConnectionString = IotHubUtils.ToPSIotHubConnectionString(policy, iotHubDescription.Properties.HostName);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(psIotHubConnectionString.PrimaryConnectionString);
if (this.IsParameterBound(c => c.ModuleId))
{
Module module = registryManager.GetModuleAsync(this.DeviceId, this.ModuleId).GetAwaiter().GetResult();
if (module != null)
{
if (module.Authentication.Type.Equals(AuthenticationType.Sas))
{
resourceUri = string.Format("{0}/devices/{1}/modules/{2}", iotHubDescription.Properties.HostName, this.DeviceId, this.ModuleId);
key = this.KeyType.Equals(PSKeyType.primary) ? module.Authentication.SymmetricKey.PrimaryKey : module.Authentication.SymmetricKey.SecondaryKey;
}
else
{
throw new ArgumentException("This module does not support SAS auth.");
}
}
else
{
throw new ArgumentException($"The entered module \"{this.ModuleId}\" doesn't exist.");
}
}
else
{
Device device = registryManager.GetDeviceAsync(this.DeviceId).GetAwaiter().GetResult();
if (device != null)
{
if (device.Authentication.Type.Equals(AuthenticationType.Sas))
{
resourceUri = string.Format("{0}/devices/{1}", iotHubDescription.Properties.HostName, this.DeviceId);
key = this.KeyType.Equals(PSKeyType.primary) ? device.Authentication.SymmetricKey.PrimaryKey : device.Authentication.SymmetricKey.SecondaryKey;
}
else
{
throw new ArgumentException("This device does not support SAS auth.");
}
}
else
{
throw new ArgumentException($"The entered device \"{this.DeviceId}\" doesn't exist.");
}
}
}
else
{
if (!this.IsParameterBound(c => c.KeyName))
{
this.KeyName = "iothubowner";
}
SharedAccessSignatureAuthorizationRule authPolicy = this.IotHubClient.IotHubResource.GetKeysForKeyName(this.ResourceGroupName, this.IotHubName, this.KeyName);
resourceUri = iotHubDescription.Properties.HostName;
keyName = authPolicy.KeyName;
key = this.KeyType.Equals(PSKeyType.primary) ? authPolicy.PrimaryKey : authPolicy.SecondaryKey;
}
this.WriteObject(this.createToken(resourceUri, keyName, key, this.Duration));
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(EndpointName, Properties.Resources.AddIotHubRoutingEndpoint))
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
switch (this.EndpointType)
{
case PSEndpointType.EventHub:
iotHubDescription.Properties.Routing.Endpoints.EventHubs.Add(
new RoutingEventHubProperties()
{
Name = this.EndpointName,
ConnectionString = this.ConnectionString,
ResourceGroup = this.EndpointResourceGroup,
SubscriptionId = this.EndpointSubscriptionId
});
break;
case PSEndpointType.ServiceBusQueue:
iotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues.Add(
new RoutingServiceBusQueueEndpointProperties()
{
Name = this.EndpointName,
ConnectionString = this.ConnectionString,
ResourceGroup = this.EndpointResourceGroup,
SubscriptionId = this.EndpointSubscriptionId
});
break;
case PSEndpointType.ServiceBusTopic:
iotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics.Add(
new RoutingServiceBusTopicEndpointProperties()
{
Name = this.EndpointName,
ConnectionString = this.ConnectionString,
ResourceGroup = this.EndpointResourceGroup,
SubscriptionId = this.EndpointSubscriptionId
});
break;
case PSEndpointType.AzureStorageContainer:
iotHubDescription.Properties.Routing.Endpoints.StorageContainers.Add(
new RoutingStorageContainerProperties()
{
Name = this.EndpointName,
ConnectionString = this.ConnectionString,
ResourceGroup = this.EndpointResourceGroup,
SubscriptionId = this.EndpointSubscriptionId,
ContainerName = this.routingEndpointDynamicParameter.ContainerName,
Encoding = this.routingEndpointDynamicParameter.Encoding
});
break;
}
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
IotHubDescription updatedIotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
switch (this.EndpointType)
{
case PSEndpointType.EventHub:
this.WriteObject(IotHubUtils.ToPSRoutingEventHubEndpoint(updatedIotHubDescription.Properties.Routing.Endpoints.EventHubs.FirstOrDefault(x => x.Name.Equals(this.EndpointName, StringComparison.OrdinalIgnoreCase))), false);
break;
case PSEndpointType.ServiceBusQueue:
this.WriteObject(IotHubUtils.ToPSRoutingServiceBusQueueEndpoint(updatedIotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues.FirstOrDefault(x => x.Name.Equals(this.EndpointName, StringComparison.OrdinalIgnoreCase))), false);
break;
case PSEndpointType.ServiceBusTopic:
this.WriteObject(IotHubUtils.ToPSRoutingServiceBusTopicEndpoint(updatedIotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics.FirstOrDefault(x => x.Name.Equals(this.EndpointName, StringComparison.OrdinalIgnoreCase))), false);
break;
case PSEndpointType.AzureStorageContainer:
this.WriteObject(IotHubUtils.ToPSRoutingStorageContainerEndpoint(updatedIotHubDescription.Properties.Routing.Endpoints.StorageContainers.FirstOrDefault(x => x.Name.Equals(this.EndpointName, StringComparison.OrdinalIgnoreCase))), false);
break;
}
}
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DeviceId, Properties.Resources.AddIotHubDevice))
{
IotHubDescription iotHubDescription;
IList <Device> childDevices = null;
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);
PSDeviceCapabilities psDeviceCapabilities = new PSDeviceCapabilities();
psDeviceCapabilities.IotEdge = this.EdgeEnabled.IsPresent;
PSAuthenticationMechanism auth = new PSAuthenticationMechanism();
PSDevice device = new PSDevice();
device.Id = this.DeviceId;
switch (this.AuthMethod)
{
case PSDeviceAuthType.x509_thumbprint:
auth.Type = PSAuthenticationType.SelfSigned;
auth.X509Thumbprint = new PSX509Thumbprint();
auth.X509Thumbprint.PrimaryThumbprint = this.authTypeDynamicParameter.PrimaryThumbprint;
auth.X509Thumbprint.SecondaryThumbprint = this.authTypeDynamicParameter.SecondaryThumbprint;
break;
case PSDeviceAuthType.x509_ca:
auth.Type = PSAuthenticationType.CertificateAuthority;
break;
default:
auth.SymmetricKey = new PSSymmetricKey();
auth.Type = PSAuthenticationType.Sas;
break;
}
device.Authentication = auth;
device.Capabilities = psDeviceCapabilities;
device.Status = this.Status;
device.StatusReason = this.StatusReason;
if (this.EdgeEnabled.IsPresent)
{
if (this.Children != null)
{
childDevices = new List <Device>();
foreach (string childDeviceId in this.Children)
{
Device childDevice = registryManager.GetDeviceAsync(childDeviceId).GetAwaiter().GetResult();
if (childDevice == null)
{
throw new ArgumentException($"The entered children device \"{childDeviceId}\" doesn't exist.");
}
if (childDevice.Capabilities.IotEdge)
{
throw new ArgumentException($"The entered children device \"{childDeviceId}\" should be non-edge device.");
}
if (!string.IsNullOrEmpty(childDevice.Scope) && !this.Force.IsPresent)
{
throw new ArgumentException($"The entered children device \"{childDeviceId}\" already has a parent device, please use '-Force' to overwrite.");
}
childDevices.Add(childDevice);
}
}
}
else
{
if (this.ParentDeviceId != null)
{
Device parentDevice = registryManager.GetDeviceAsync(this.ParentDeviceId).GetAwaiter().GetResult();
if (parentDevice == null)
{
throw new ArgumentException($"The entered parent device \"{this.ParentDeviceId}\" doesn't exist.");
}
if (!parentDevice.Capabilities.IotEdge)
{
throw new ArgumentException($"The entered parent device \"{this.ParentDeviceId}\" should be an edge device.");
}
device.Scope = parentDevice.Scope;
}
}
Device newDevice = registryManager.AddDeviceAsync(IotHubDataPlaneUtils.ToDevice(device)).GetAwaiter().GetResult();
this.WriteObject(IotHubDataPlaneUtils.ToPSDevice(newDevice));
if (this.EdgeEnabled.IsPresent && childDevices != null)
{
foreach (Device childDevice in childDevices)
{
childDevice.Scope = newDevice.Scope;
registryManager.UpdateDeviceAsync(childDevice).GetAwaiter().GetResult();
}
}
}
}
public override void ExecuteCmdlet()
{
IotHubDescription iotHubDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.Resourcegroup;
this.Name = this.InputObject.Name;
iotHubDescription = IotHubUtils.ConvertObject <PSIotHub, IotHubDescription>(this.InputObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotHubUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotHubUtils.GetIotHubName(this.ResourceId);
}
iotHubDescription = this.IotHubClient.IotHubResource.Get(this.ResourceGroupName, this.Name);
}
if (ShouldProcess(EndpointName, Properties.Resources.RemoveIotHubRoutingEndpoint))
{
if (string.IsNullOrEmpty(this.EndpointName))
{
if (this.IsParameterBound(c => c.EndpointType))
{
switch (this.EndpointType)
{
case PSEndpointType.EventHub:
iotHubDescription.Properties.Routing.Endpoints.EventHubs = new List <RoutingEventHubProperties>();
break;
case PSEndpointType.ServiceBusQueue:
iotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues = new List <RoutingServiceBusQueueEndpointProperties>();
break;
case PSEndpointType.ServiceBusTopic:
iotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics = new List <RoutingServiceBusTopicEndpointProperties>();
break;
case PSEndpointType.AzureStorageContainer:
iotHubDescription.Properties.Routing.Endpoints.StorageContainers = new List <RoutingStorageContainerProperties>();
break;
}
}
else
{
iotHubDescription.Properties.Routing.Endpoints.EventHubs = new List <RoutingEventHubProperties>();
iotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues = new List <RoutingServiceBusQueueEndpointProperties>();
iotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics = new List <RoutingServiceBusTopicEndpointProperties>();
iotHubDescription.Properties.Routing.Endpoints.StorageContainers = new List <RoutingStorageContainerProperties>();
}
}
else
{
iotHubDescription.Properties.Routing.Endpoints.EventHubs = iotHubDescription.Properties.Routing.Endpoints.EventHubs.Where(x => x.Name.ToLowerInvariant() != this.EndpointName.ToLowerInvariant()).ToList();
iotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues = iotHubDescription.Properties.Routing.Endpoints.ServiceBusQueues.Where(x => x.Name.ToLowerInvariant() != this.EndpointName.ToLowerInvariant()).ToList();
iotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics = iotHubDescription.Properties.Routing.Endpoints.ServiceBusTopics.Where(x => x.Name.ToLowerInvariant() != this.EndpointName.ToLowerInvariant()).ToList();
iotHubDescription.Properties.Routing.Endpoints.StorageContainers = iotHubDescription.Properties.Routing.Endpoints.StorageContainers.Where(x => x.Name.ToLowerInvariant() != this.EndpointName.ToLowerInvariant()).ToList();
}
try
{
this.IotHubClient.IotHubResource.CreateOrUpdate(this.ResourceGroupName, this.Name, iotHubDescription);
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}