private VirtualMachineDscExtensionStatusContext GetDscExtensionStatusContext(
VirtualMachineExtension virtualMachineExtension, string resourceGroupName, string vmName)
{
var context = new VirtualMachineDscExtensionStatusContext
{
ResourceGroupName = resourceGroupName,
VmName = vmName,
Version = virtualMachineExtension.TypeHandlerVersion,
};
var instanceView = virtualMachineExtension.InstanceView;
if (instanceView == null) return context;
var statuses = instanceView.Statuses;
var substatuses = instanceView.SubStatuses;
if (statuses != null && statuses.Count > 0)
{
context.StatusCode = statuses[0].Code;
context.Status = statuses[0].DisplayStatus;
context.StatusMessage = statuses[0].Message;
context.Timestamp = statuses[0].Time == null ? DateTime.MinValue : statuses[0].Time.GetValueOrDefault();
}
if (substatuses != null && substatuses.Count > 0)
{
context.DscConfigurationLog = !string.Empty.Equals(substatuses[0].Message)
? substatuses[0].Message.Split(new[] {"\r\n", "\n"}, StringSplitOptions.None)
: new List<String>().ToArray();
}
return context;
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ExecuteClientAction(() =>
{
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineBGInfoExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = this.TypeHandlerVersion ?? VirtualMachineBGInfoExtensionContext.ExtensionDefaultVersion,
AutoUpgradeMinorVersion = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
});
}
/// <summary>
/// The operation to create or update the extension.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Compute.IVirtualMachineExtensionOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group.
/// </param>
/// <param name='vmName'>
/// Required. The name of the virtual machine where the extension
/// should be create or updated.
/// </param>
/// <param name='extensionParameters'>
/// Required. Parameters supplied to the Create Virtual Machine
/// Extension operation.
/// </param>
/// <returns>
/// The compute long running operation response.
/// </returns>
public static VirtualMachineExtensionCreateOrUpdateResponse BeginCreatingOrUpdating(this IVirtualMachineExtensionOperations operations, string resourceGroupName, string vmName, VirtualMachineExtension extensionParameters)
{
return Task.Factory.StartNew((object s) =>
{
return ((IVirtualMachineExtensionOperations)s).BeginCreatingOrUpdatingAsync(resourceGroupName, vmName, extensionParameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
private bool IsAzureDiskEncryptionExtension(VirtualMachineExtension vmExtension)
{
if ((vmExtension != null) &&
(vmExtension.Publisher != null) &&
(vmExtension.ExtensionType != null) &&
(vmExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase)) &&
(vmExtension.ExtensionType.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}
return false;
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(VirtualMachineAccessExtensionContext.ExtensionDefaultName, VerbsCommon.Set))
{
ExecuteClientAction(() =>
{
Hashtable publicSettings = new Hashtable();
publicSettings.Add(userNameKey, UserName ?? "");
Hashtable privateSettings = new Hashtable();
privateSettings.Add(passwordKey, Password ?? "");
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
VirtualMachineExtensionType = VirtualMachineAccessExtensionContext.ExtensionDefaultName,
Publisher = VirtualMachineAccessExtensionContext.ExtensionDefaultPublisher,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? VirtualMachineAccessExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = privateSettings,
AutoUpgradeMinorVersion = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
});
}
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters)
{
string SettingString = GetExtensionPublicSettings();
string ProtectedSettingString = GetExtensionProtectedSettings();
if (vmParameters == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "Set-AzureDiskEncryptionExtension can enable encryption only on a VM that was already created ")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
VirtualMachineExtension vmExtensionParameters = null;
if (string.Equals(currentOSType, "Windows", StringComparison.InvariantCultureIgnoreCase))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Publisher = AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher,
ExtensionType = AzureDiskEncryptionExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = ProtectedSettingString,
};
}
else if (string.Equals(currentOSType, "Linux", StringComparison.InvariantCultureIgnoreCase))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Publisher = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
ExtensionType = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = ProtectedSettingString,
};
}
return vmExtensionParameters;
}
private VirtualMachine SetAzureVMDiagnosticsExtensionC(VirtualMachine selectedVM, string storageAccountName, string storageAccountKey)
{
System.Xml.XmlDocument xpublicConfig = null;
var extensionName = AEMExtensionConstants.WADExtensionDefaultName[this.OSType];
var extTemp = this._Helper.GetExtension(selectedVM,
AEMExtensionConstants.WADExtensionType[this.OSType], AEMExtensionConstants.WADExtensionPublisher[OSType]);
object publicConf = null;
if (extTemp != null)
{
publicConf = extTemp.Settings;
extensionName = extTemp.Name;
}
if (publicConf != null)
{
var jpublicConf = publicConf as Newtonsoft.Json.Linq.JObject;
if (jpublicConf == null)
{
throw new ArgumentException();
}
var base64 = jpublicConf["xmlCfg"] as Newtonsoft.Json.Linq.JValue;
if (base64 == null)
{
throw new ArgumentException();
}
System.Xml.XmlDocument xDoc = new System.Xml.XmlDocument();
xDoc.LoadXml(Encoding.UTF8.GetString(System.Convert.FromBase64String(base64.Value.ToString())));
if (xDoc.SelectSingleNode("/WadCfg/DiagnosticMonitorConfiguration/PerformanceCounters") != null)
{
xDoc.SelectSingleNode("WadCfg/DiagnosticMonitorConfiguration").Attributes["overallQuotaInMB"].Value = "4096";
xDoc.SelectSingleNode("WadCfg/DiagnosticMonitorConfiguration/PerformanceCounters").Attributes["scheduledTransferPeriod"].Value = "PT1M";
xpublicConfig = xDoc;
}
}
if (xpublicConfig == null)
{
xpublicConfig = new System.Xml.XmlDocument();
xpublicConfig.LoadXml(AEMExtensionConstants.WADConfigXML);
}
foreach (var perfCounter in AEMExtensionConstants.PerformanceCounters[OSType])
{
var currentCounter = xpublicConfig.
SelectSingleNode("WadCfg/DiagnosticMonitorConfiguration/PerformanceCounters/PerformanceCounterConfiguration[@counterSpecifier = '" + perfCounter.counterSpecifier + "']");
if (currentCounter == null)
{
var node = xpublicConfig.CreateElement("PerformanceCounterConfiguration");
xpublicConfig.SelectSingleNode("WadCfg/DiagnosticMonitorConfiguration/PerformanceCounters").AppendChild(node);
node.SetAttribute("counterSpecifier", perfCounter.counterSpecifier);
node.SetAttribute("sampleRate", perfCounter.sampleRate);
}
}
var endpoint = this._Helper.GetCoreEndpoint(storageAccountName);
endpoint = "https://" + endpoint;
Newtonsoft.Json.Linq.JObject jPublicConfig = new Newtonsoft.Json.Linq.JObject();
jPublicConfig.Add("xmlCfg", new Newtonsoft.Json.Linq.JValue(System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(xpublicConfig.InnerXml))));
Newtonsoft.Json.Linq.JObject jPrivateConfig = new Newtonsoft.Json.Linq.JObject();
jPrivateConfig.Add("storageAccountName", new Newtonsoft.Json.Linq.JValue(storageAccountName));
jPrivateConfig.Add("storageAccountKey", new Newtonsoft.Json.Linq.JValue(storageAccountKey));
jPrivateConfig.Add("storageAccountEndPoint", new Newtonsoft.Json.Linq.JValue(endpoint));
WriteVerbose("Installing WAD extension");
VirtualMachineExtension vmExtParameters = new VirtualMachineExtension();
vmExtParameters.Publisher = AEMExtensionConstants.WADExtensionPublisher[this.OSType];
vmExtParameters.VirtualMachineExtensionType = AEMExtensionConstants.WADExtensionType[this.OSType];
vmExtParameters.TypeHandlerVersion = AEMExtensionConstants.WADExtensionVersion[this.OSType];
vmExtParameters.Settings = jPublicConfig;
vmExtParameters.ProtectedSettings = jPrivateConfig;
vmExtParameters.Location = selectedVM.Location;
this.VirtualMachineExtensionClient.CreateOrUpdate(ResourceGroupName, selectedVM.Name, extensionName, vmExtParameters);
return this.ComputeClient.ComputeManagementClient.VirtualMachines.Get(ResourceGroupName, selectedVM.Name);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (this.VM.DiagnosticsProfile == null)
{
var storageUri = GetOrCreateStorageAccountForBootDiagnostics();
if (storageUri != null)
{
this.VM.DiagnosticsProfile = new DiagnosticsProfile
{
BootDiagnostics = new BootDiagnostics
{
Enabled = true,
StorageUri = storageUri,
}
};
}
}
ExecuteClientAction(() =>
{
var parameters = new VirtualMachine
{
DiagnosticsProfile = this.VM.DiagnosticsProfile,
HardwareProfile = this.VM.HardwareProfile,
StorageProfile = this.VM.StorageProfile,
NetworkProfile = this.VM.NetworkProfile,
OSProfile = this.VM.OSProfile,
Plan = this.VM.Plan,
AvailabilitySetReference = this.VM.AvailabilitySetReference,
Location = !string.IsNullOrEmpty(this.Location) ? this.Location : this.VM.Location,
Name = this.VM.Name,
Tags = this.Tags != null ? this.Tags.ToDictionary() : this.VM.Tags
};
var op = this.VirtualMachineClient.CreateOrUpdate(this.ResourceGroupName, parameters);
var result = Mapper.Map<PSComputeLongRunningOperation>(op);
if (!(this.DisableBginfoExtension.IsPresent || IsLinuxOs()))
{
var currentBginfoVersion = GetBginfoExtension();
if (!string.IsNullOrEmpty(currentBginfoVersion))
{
var extensionParameters = new VirtualMachineExtension
{
Location = this.Location,
Name = VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineBGInfoExtensionContext.ExtensionDefaultPublisher,
ExtensionType = VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = currentBginfoVersion,
AutoUpgradeMinorVersion = true
};
op = ComputeClient.ComputeManagementClient.VirtualMachineExtensions.CreateOrUpdate(
this.ResourceGroupName, this.VM.Name, extensionParameters);
result = Mapper.Map<PSComputeLongRunningOperation>(op);
}
}
WriteObject(result);
});
}
private void ExecuteCommand()
{
ExecuteClientAction(() =>
{
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Settings = this.PublicConfiguration,
ProtectedSettings = this.PrivateConfiguration,
Publisher = ExtensionDefaultPublisher,
ExtensionType = this.Name,
TypeHandlerVersion = this.TypeHandlerVersion,
AutoUpgradeMinorVersion = this.AutoUpgradeMinorVersion
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
WriteObject(op);
});
}
internal void ExecuteCommand()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name,
Type = VirtualMachineExtension,
Settings = this.PublicConfiguration,
ProtectedSettings = this.PrivateConfiguration,
Publisher = ExtensionPublisher,
ExtensionType = IaaSDiagnosticsExtension,
TypeHandlerVersion = "1.4"
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
WriteObject(op);
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
Hashtable publicSettings = new Hashtable();
publicSettings.Add(userNameKey, UserName ?? "");
Hashtable privateSettings = new Hashtable();
privateSettings.Add(passwordKey, Password ?? "");
var SettingString = JsonConvert.SerializeObject(publicSettings);
var ProtectedSettingString = JsonConvert.SerializeObject(privateSettings);
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineAccessExtensionContext.ExtensionDefaultPublisher,
ExtensionType = VirtualMachineAccessExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? VirtualMachineAccessExtensionContext.ExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = ProtectedSettingString,
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
WriteObject(op);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (string.Equals(this.ParameterSetName, SetCustomScriptExtensionByContainerBlobsParamSetName))
{
this.StorageEndpointSuffix = string.IsNullOrEmpty(this.StorageEndpointSuffix) ?
DefaultProfile.Context.Environment.GetEndpoint(AzureEnvironment.Endpoint.StorageEndpointSuffix) : this.StorageEndpointSuffix;
var sName = string.IsNullOrEmpty(this.StorageAccountName) ? GetStorageName() : this.StorageAccountName;
var sKey = string.IsNullOrEmpty(this.StorageAccountKey) ? GetStorageKey(sName) : this.StorageAccountKey;
if (this.FileName != null && this.FileName.Any())
{
this.FileUri = (from blobName in this.FileName
select GetSasUrlStr(sName, sKey, this.ContainerName, blobName)).ToArray();
if (string.IsNullOrEmpty(this.Run))
{
WriteWarning(Microsoft.Azure.Commands.Compute.Properties.Resources.CustomScriptExtensionTryToUseTheFirstSpecifiedFileAsRunScript);
this.Run = this.FileName[0];
}
}
}
var policyStr = string.Format(policyFormatStr, defaultPolicyStr);
var commandToExecute = string.Format(poshCmdFormatStr, policyStr, this.Run, this.Argument);
var privateSettings = GetPrivateConfiguration();
var publicSettings = new Hashtable();
publicSettings.Add(fileUrisKey, FileUri ?? new string[] { });
if (this.SecureExecution.IsPresent)
{
if (privateSettings == null)
{
privateSettings = new Hashtable();
}
privateSettings.Add(commandToExecuteKey, commandToExecute ?? "");
}
else
{
publicSettings.Add(commandToExecuteKey, commandToExecute ?? "");
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? VirtualMachineCustomScriptExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = privateSettings,
AutoUpgradeMinorVersion = true
};
try
{
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
catch (Rest.Azure.CloudException ex)
{
var errorReturned = JsonConvert.DeserializeObject<ComputeLongRunningOperationError>(
ex.Response.Content);
WriteObject(errorReturned);
}
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
VirtualMachine vm = ComputeClient.ComputeManagementClient.VirtualMachines.Get(this.ResourceGroupName, this.VMName);
if (vm != null)
{
VirtualMachineExtension extension = vm.Resources.Where(x => x.Publisher.Equals(VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace)).FirstOrDefault();
if (extension != null)
{
this.Name = extension.Name;
this.Version = extension.TypeHandlerVersion;
}
this.Location = vm.Location;
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace,
VirtualMachineExtensionType = VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
TypeHandlerVersion = string.IsNullOrEmpty(this.Version) ? VirtualMachineSqlServerExtensionContext.ExtensionDefaultVersion : this.Version,
Settings = this.GetPublicConfiguration(),
ProtectedSettings = this.GetPrivateConfiguration(),
};
// Add retry logic due to CRP service restart known issue CRP bug: 3564713
// Similair approach taken in DSC cmdlet as well
var count = 1;
Rest.Azure.AzureOperationResponse<VirtualMachineExtension> op = null;
while (count <= 2)
{
try
{
op = VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
ResourceGroupName,
VMName,
Name ?? VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace + "." + VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
parameters).GetAwaiter().GetResult();
break;
}
catch (Rest.Azure.CloudException ex)
{
var errorReturned = JsonConvert.DeserializeObject<PSComputeLongRunningOperation>(ex.Response.Content);
if ("Failed".Equals(errorReturned.Status)
&& errorReturned.Error != null && "InternalExecutionError".Equals(errorReturned.Error.Code))
{
count++;
}
else
{
base.ThrowTerminatingError(new ErrorRecord(ex, "InvalidResult", ErrorCategory.InvalidResult, null));
}
}
}
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.ExtensionType, VerbsCommon.Set))
{
ExecuteClientAction(() =>
{
if (this.ParameterSetName.Equals(SettingStringParamSet))
{
this.Settings = string.IsNullOrEmpty(this.SettingString)
? null
: JsonConvert.DeserializeObject<Hashtable>(this.SettingString);
this.ProtectedSettings = string.IsNullOrEmpty(this.ProtectedSettingString)
? null
: JsonConvert.DeserializeObject<Hashtable>(this.ProtectedSettingString);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = this.Publisher,
VirtualMachineExtensionType = this.ExtensionType,
TypeHandlerVersion = this.TypeHandlerVersion,
Settings = this.Settings,
ProtectedSettings = this.ProtectedSettings,
AutoUpgradeMinorVersion = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
});
}
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters)
{
Hashtable SettingString = GetExtensionPublicSettings();
Hashtable ProtectedSettingString = GetExtensionProtectedSettings();
if (vmParameters == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "Set-AzureDiskEncryptionExtension can enable encryption only on a VM that was already created ")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
VirtualMachineExtension vmExtensionParameters = null;
if (OperatingSystemTypes.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = ProtectedSettingString,
AutoUpgradeMinorVersion = !DisableAutoUpgradeMinorVersion.IsPresent
};
}
else if (OperatingSystemTypes.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = ProtectedSettingString,
AutoUpgradeMinorVersion = !DisableAutoUpgradeMinorVersion.IsPresent
};
}
return vmExtensionParameters;
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(VirtualMachineADDomainExtensionContext.ExtensionDefaultName, VerbsCommon.Set))
{
ExecuteClientAction(() =>
{
Hashtable publicSettings = new Hashtable();
publicSettings.Add(nameKey, this.DomainName);
if (this.OUPath != null)
{
publicSettings.Add(ouPathKey, this.OUPath);
}
if (this.JoinOption != null)
{
publicSettings.Add(optionKey, this.JoinOption);
}
publicSettings.Add(restartKey, Restart.IsPresent);
Hashtable privateSettings = new Hashtable();
if (Credential != null)
{
publicSettings.Add(userKey, Credential.UserName);
privateSettings.Add(passwordKey, SecureStringExtensions.ConvertToString(this.Credential.Password));
}
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineADDomainExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = VirtualMachineADDomainExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = this.TypeHandlerVersion ?? VirtualMachineADDomainExtensionContext.ExtensionDefaultVersion,
AutoUpgradeMinorVersion = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun,
Settings = publicSettings,
ProtectedSettings = privateSettings
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name ?? VirtualMachineADDomainExtensionContext.ExtensionDefaultName,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
});
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = Name ?? VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace + "." + VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace,
ExtensionType = VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
TypeHandlerVersion = string.IsNullOrEmpty(this.Version) ? VirtualMachineSqlServerExtensionContext.ExtensionDefaultVersion : this.Version,
Settings = this.GetPublicConfiguration(),
ProtectedSettings = this.GetPrivateConfiguration(),
};
// Add retry logic due to CRP service restart known issue CRP bug: 3564713
// Similair approach taken in DSC cmdlet as well
var count = 1;
ComputeLongRunningOperationResponse op = null;
while (count <= 2)
{
op = VirtualMachineExtensionClient.CreateOrUpdate(
ResourceGroupName,
VMName,
parameters);
if (ComputeOperationStatus.Failed.Equals(op.Status) && op.Error != null && "InternalExecutionError".Equals(op.Error.Code))
{
count++;
}
else
{
break;
}
}
var result = Mapper.Map<PSComputeLongRunningOperation>(op);
WriteObject(result);
}
private bool IsAzureDiskEncryptionExtension(OSType osType, VirtualMachineExtension vmExtension)
{
switch (osType)
{
case OSType.Windows:
if ((vmExtension != null) &&
(vmExtension.Publisher != null) &&
(vmExtension.VirtualMachineExtensionType != null) &&
(vmExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase)) &&
(vmExtension.VirtualMachineExtensionType.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}
return false;
case OSType.Linux:
if ((vmExtension != null) &&
(vmExtension.Publisher != null) &&
(vmExtension.VirtualMachineExtensionType != null) &&
(vmExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase)) &&
(vmExtension.VirtualMachineExtensionType.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}
return false;
case OSType.Unknown:
return false;
default:
return false;
}
}
/// <summary>
/// we only support the Linux box now, if it's a windows, one AzureVMBackupException would be thrown.
/// </summary>
/// <param name="resourceGroupName"></param>
/// <param name="vmName"></param>
/// <param name="virtualMachineExtensionType"></param>
/// <param name="location"></param>
/// <param name="virtualMachineResponse"></param>
/// <param name="snapshotTag"></param>
/// <param name="virtualMachineExtensionBaseCmdlet"></param>
public void CreateSnapshotForDisks(AzureVMBackupConfig vmConfig, string snapshotTag, VirtualMachineExtensionBaseCmdlet virtualMachineExtensionBaseCmdlet)
{
var virtualMachine = virtualMachineExtensionBaseCmdlet.ComputeClient.ComputeManagementClient.VirtualMachines.GetWithInstanceView(
vmConfig.ResourceGroupName,
vmConfig.VMName);
StorageManagementClient storageClient = AzureSession.ClientFactory.CreateClient<StorageManagementClient>(virtualMachineExtensionBaseCmdlet.DefaultProfile.Context, AzureEnvironment.Endpoint.ResourceManager);
StorageCredentialsFactory storageCredentialsFactory = new StorageCredentialsFactory(vmConfig.ResourceGroupName, storageClient, virtualMachineExtensionBaseCmdlet.DefaultProfile.Context.Subscription);
CloudPageBlobObjectFactory cloudPageBlobObjectFactory = new CloudPageBlobObjectFactory(storageCredentialsFactory, TimeSpan.FromMinutes(1));
List<string> vmPageBlobUris = this.GetDiskBlobUris(virtualMachine.Body);
AzureVMBackupBlobSasUris blobSASUris = this.GenerateBlobSasUris(vmPageBlobUris, cloudPageBlobObjectFactory);
string taskId = Guid.NewGuid().ToString();
AzureVMBackupExtensionProtectedSettings privateConfig = new AzureVMBackupExtensionProtectedSettings();
privateConfig.logsBlobUri = string.Empty;
privateConfig.objectStr = this.GetBase64Encoding(blobSASUris);
AzureVMBackupExtensionPublicSettings publicConfig = new AzureVMBackupExtensionPublicSettings();
publicConfig.commandToExecute = backupSnapshotCommand;
publicConfig.locale = backupDefaultLocale;
publicConfig.commandStartTimeUTCTicks = DateTimeOffset.UtcNow.Ticks.ToString();
publicConfig.taskId = taskId;
AzureVMBackupMetadata backupMetadata = new AzureVMBackupMetadata();
AzureVMBackupMetadataItem tagMetadataItem = new AzureVMBackupMetadataItem();
tagMetadataItem.Key = backupExtensionMetadataName;
tagMetadataItem.Value = snapshotTag;
AzureVMBackupMetadataItem taskIdMetadataItem = new AzureVMBackupMetadataItem();
taskIdMetadataItem.Key = backupExtensionIdentityMetadataName;
taskIdMetadataItem.Value = taskId;
backupMetadata.backupMetadata.Add(tagMetadataItem);
backupMetadata.backupMetadata.Add(taskIdMetadataItem);
publicConfig.objectStr = this.GetBase64Encoding(backupMetadata);
VirtualMachineExtension vmExtensionParameters = new VirtualMachineExtension
{
Location = virtualMachine.Body.Location,
Publisher = extensionPublisher,
VirtualMachineExtensionType = extensionType,
TypeHandlerVersion = extensionDefaultVersion,
Settings = publicConfig,
ProtectedSettings = privateConfig,
};
var vmBackupOperation = virtualMachineExtensionBaseCmdlet.VirtualMachineExtensionClient.CreateOrUpdate(
vmConfig.ResourceGroupName,
vmConfig.VMName,
vmConfig.ExtensionName ?? backupExtensionName,
vmExtensionParameters);
// check the snapshots with the task id are all created.
int timePeriod = 5000;
int loopingTimes = ((int)TimeSpan.FromMinutes(10).TotalMilliseconds / timePeriod);
Dictionary<string, string> snapshotQuery = new Dictionary<string, string>();
snapshotQuery.Add(backupExtensionMetadataName, snapshotTag);
snapshotQuery.Add(backupExtensionIdentityMetadataName, taskId);
int i = 0;
for (; i < loopingTimes; i++)
{
List<CloudPageBlob> snapshotsFound = this.FindSnapshot(vmPageBlobUris, snapshotQuery, storageCredentialsFactory);
if (snapshotsFound.Count == vmPageBlobUris.Count)
{
break;
}
else
{
Thread.Sleep(timePeriod);
}
}
if (i == loopingTimes)
{
throw new AzureVMBackupException(AzureVMBackupErrorCodes.TimeOut, "snapshot not created, or not found in time.");
}
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters, OSType currentOSType)
{
Hashtable publicSettings = new Hashtable();
Hashtable protectedSettings = new Hashtable();
publicSettings.Add(AzureDiskEncryptionExtensionConstants.encryptionOperationKey, AzureDiskEncryptionExtensionConstants.queryEncryptionStatusOperation);
publicSettings.Add(AzureDiskEncryptionExtensionConstants.sequenceVersionKey, Guid.NewGuid().ToString());
if (vmParameters == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "Get-AzureDiskEncryptionExtension can enable encryption only on a VM that was already created ")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
VirtualMachineExtension vmExtensionParameters = null;
if (OSType.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
else if (OSType.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
return vmExtensionParameters;
}
private void CreateConfiguration()
{
var publicSettings = new DscExtensionPublicSettings();
var privateSettings = new DscExtensionPrivateSettings();
publicSettings.WmfVersion = string.IsNullOrEmpty(WmfVersion) ? "latest" : WmfVersion;
if (!string.IsNullOrEmpty(ArchiveBlobName))
{
ConfigurationUris configurationUris = UploadConfigurationDataToBlob();
publicSettings.SasToken = configurationUris.SasToken;
publicSettings.ModulesUrl = configurationUris.ModulesUrl;
publicSettings.ConfigurationFunction = string.Format(
CultureInfo.InvariantCulture,
"{0}\\{1}",
Path.GetFileNameWithoutExtension(ArchiveBlobName),
ConfigurationName);
Tuple<DscExtensionPublicSettings.Property[], Hashtable> settings =
DscExtensionSettingsSerializer.SeparatePrivateItems(ConfigurationArgument);
publicSettings.Properties = settings.Item1;
privateSettings.Items = settings.Item2;
privateSettings.DataBlobUri = configurationUris.DataBlobUri;
}
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = Name ?? DscExtensionCmdletConstants.ExtensionPublishedNamespace + "." + DscExtensionCmdletConstants.ExtensionPublishedName,
Type = VirtualMachineExtensionType,
Publisher = DscExtensionCmdletConstants.ExtensionPublishedNamespace,
ExtensionType = DscExtensionCmdletConstants.ExtensionPublishedName,
TypeHandlerVersion = Version,
// Define the public and private property bags that will be passed to the extension.
Settings = DscExtensionSettingsSerializer.SerializePublicSettings(publicSettings),
//PrivateConfuguration contains sensitive data in a plain text
ProtectedSettings = DscExtensionSettingsSerializer.SerializePrivateSettings(privateSettings),
AutoUpgradeMinorVersion = AutoUpdate.IsPresent
};
//Add retry logic due to CRP service restart known issue CRP bug: 3564713
var count = 1;
ComputeLongRunningOperationResponse op = null;
while (count <= 2)
{
op = VirtualMachineExtensionClient.CreateOrUpdate(
ResourceGroupName,
VMName,
parameters);
if (ComputeOperationStatus.Failed.Equals(op.Status) && op.Error != null && "InternalExecutionError".Equals(op.Error.Code))
{
count++;
}
else
{
break;
}
}
var result = Mapper.Map<PSComputeLongRunningOperation>(op);
WriteObject(result);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (string.Equals(this.ParameterSetName, SetCustomScriptExtensionByContainerBlobsParamSetName))
{
this.StorageEndpointSuffix = string.IsNullOrEmpty(this.StorageEndpointSuffix) ?
DefaultProfile.Context.Environment.GetEndpoint(AzureEnvironment.Endpoint.StorageEndpointSuffix) : this.StorageEndpointSuffix;
var sName = string.IsNullOrEmpty(this.StorageAccountName) ? GetStorageName() : this.StorageAccountName;
var sKey = string.IsNullOrEmpty(this.StorageAccountKey) ? GetStorageKey(sName) : this.StorageAccountKey;
if (this.FileName != null && this.FileName.Any())
{
this.FileUri = (from blobName in this.FileName
select GetSasUrlStr(sName, sKey, this.ContainerName, blobName)).ToArray();
if (string.IsNullOrEmpty(this.Run))
{
WriteWarning(Microsoft.Azure.Commands.Compute.Properties.Resources.CustomScriptExtensionTryToUseTheFirstSpecifiedFileAsRunScript);
this.Run = this.FileName[0];
}
}
}
var policyStr = string.Format(policyFormatStr, defaultPolicyStr);
var commandToExecute = string.Format(poshCmdFormatStr, policyStr, this.Run, this.Argument);
Hashtable publicSettings = new Hashtable();
publicSettings.Add(commandToExecuteKey, commandToExecute ?? "");
publicSettings.Add(fileUrisKey, FileUri ?? new string[] { });
var SettingString = JsonConvert.SerializeObject(publicSettings);
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultPublisher,
ExtensionType = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? VirtualMachineCustomScriptExtensionContext.ExtensionDefaultVersion,
Settings = SettingString,
ProtectedSettings = GetPrivateConfiguration(),
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
WriteObject(op);
});
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ExecuteClientAction(() =>
{
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name ?? VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
Type = VirtualMachineExtensionType,
Publisher = VirtualMachineBGInfoExtensionContext.ExtensionDefaultPublisher,
ExtensionType = VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = this.TypeHandlerVersion ?? VirtualMachineBGInfoExtensionContext.ExtensionDefaultVersion,
AutoUpgradeMinorVersion = !DisableAutoUpgradeMinorVersion.IsPresent
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
var result = Mapper.Map<PSComputeLongRunningOperation>(op);
WriteObject(result);
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (this.VM.DiagnosticsProfile == null)
{
var storageUri = GetOrCreateStorageAccountForBootDiagnostics();
if (storageUri != null)
{
this.VM.DiagnosticsProfile = new DiagnosticsProfile
{
BootDiagnostics = new BootDiagnostics
{
Enabled = true,
StorageUri = storageUri.ToString(),
}
};
}
}
ExecuteClientAction(() =>
{
var parameters = new VirtualMachine
{
DiagnosticsProfile = this.VM.DiagnosticsProfile,
HardwareProfile = this.VM.HardwareProfile,
StorageProfile = this.VM.StorageProfile,
NetworkProfile = this.VM.NetworkProfile,
OsProfile = this.VM.OSProfile,
Plan = this.VM.Plan,
LicenseType = this.LicenseType,
AvailabilitySet = this.VM.AvailabilitySetReference,
Location = !string.IsNullOrEmpty(this.Location) ? this.Location : this.VM.Location,
Tags = this.Tags != null ? this.Tags.ToDictionary() : this.VM.Tags
};
var op = this.VirtualMachineClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VM.Name,
parameters);
var wait = op.GetAwaiter();
var resultop = wait.GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(resultop);
if (!(this.DisableBginfoExtension.IsPresent || IsLinuxOs()))
{
var currentBginfoVersion = GetBginfoExtension();
if (!string.IsNullOrEmpty(currentBginfoVersion))
{
var extensionParameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineBGInfoExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = currentBginfoVersion,
AutoUpgradeMinorVersion = true,
};
typeof(Resource).GetRuntimeProperty("Name").SetValue(extensionParameters, VirtualMachineBGInfoExtensionContext.ExtensionDefaultName);
typeof(Resource).GetRuntimeProperty("Type")
.SetValue(extensionParameters, VirtualMachineExtensionType);
var op2 = ComputeClient.ComputeManagementClient.VirtualMachineExtensions.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VM.Name,
VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
extensionParameters).GetAwaiter().GetResult();
result = Mapper.Map<PSAzureOperationResponse>(op2);
}
}
WriteObject(result);
});
}
private void ValidateVMExtension(VirtualMachineExtension vmExtExpected, VirtualMachineExtension vmExtReturned)
{
Assert.NotNull(vmExtReturned);
Assert.True(!string.IsNullOrEmpty(vmExtReturned.ProvisioningState));
Assert.True(vmExtExpected.Publisher == vmExtReturned.Publisher);
Assert.True(vmExtExpected.ExtensionType == vmExtReturned.ExtensionType);
Assert.True(vmExtExpected.AutoUpgradeMinorVersion == vmExtReturned.AutoUpgradeMinorVersion);
Assert.True(vmExtExpected.TypeHandlerVersion == vmExtReturned.TypeHandlerVersion);
Assert.True(vmExtExpected.Settings == vmExtReturned.Settings);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (this.Settings != null)
{
this.SettingString = JsonConvert.SerializeObject(Settings);
this.ProtectedSettingString = JsonConvert.SerializeObject(ProtectedSettings);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Name = this.Name,
Type = VirtualMachineExtensionType,
Publisher = this.Publisher,
ExtensionType = this.ExtensionType,
TypeHandlerVersion = this.TypeHandlerVersion,
Settings = this.SettingString,
ProtectedSettings = this.ProtectedSettingString,
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMName,
parameters);
var result = Mapper.Map<PSComputeLongRunningOperation>(op);
WriteObject(result);
}
private void ExecuteCommand()
{
ConfirmAction("Set Chef Extension", this.VMName,
() => {
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Settings = this.PublicConfiguration,
ProtectedSettings = this.PrivateConfiguration,
Publisher = ExtensionDefaultPublisher,
VirtualMachineExtensionType = this.Name,
TypeHandlerVersion = this.TypeHandlerVersion,
AutoUpgradeMinorVersion = this.AutoUpgradeMinorVersion
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace,
VirtualMachineExtensionType = VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
TypeHandlerVersion = string.IsNullOrEmpty(this.Version) ? VirtualMachineSqlServerExtensionContext.ExtensionDefaultVersion : this.Version,
Settings = this.GetPublicConfiguration(),
ProtectedSettings = this.GetPrivateConfiguration(),
};
// Add retry logic due to CRP service restart known issue CRP bug: 3564713
// Similair approach taken in DSC cmdlet as well
var count = 1;
Rest.Azure.AzureOperationResponse<VirtualMachineExtension> op = null;
while (count <= 2)
{
try
{
op = VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
ResourceGroupName,
VMName,
Name ?? VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace + "." + VirtualMachineSqlServerExtensionContext.ExtensionPublishedName,
parameters).GetAwaiter().GetResult();
}
catch (Rest.Azure.CloudException ex)
{
var errorReturned = JsonConvert.DeserializeObject<ComputeLongRunningOperationError>(ex.Response.Content.ReadAsStringAsync().Result);
if (ComputeOperationStatus.Failed.Equals(errorReturned.Status)
&& errorReturned.Error != null && "InternalExecutionError".Equals(errorReturned.Error.Code))
{
count++;
}
else
{
break;
}
}
}
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
private void CreateConfiguration()
{
var publicSettings = new DscExtensionPublicSettings();
var privateSettings = new DscExtensionPrivateSettings();
if (!string.IsNullOrEmpty(ArchiveBlobName))
{
ConfigurationUris configurationUris = UploadConfigurationDataToBlob();
publicSettings.SasToken = configurationUris.SasToken;
publicSettings.ModulesUrl = configurationUris.ModulesUrl;
Hashtable privacySetting = new Hashtable();
privacySetting.Add("DataCollection", DataCollection);
publicSettings.Privacy = privacySetting;
publicSettings.ConfigurationFunction = string.Format(
CultureInfo.InvariantCulture,
"{0}\\{1}",
Path.GetFileNameWithoutExtension(ArchiveBlobName),
ConfigurationName);
Tuple<DscExtensionPublicSettings.Property[], Hashtable> settings =
DscExtensionSettingsSerializer.SeparatePrivateItems(ConfigurationArgument);
publicSettings.Properties = settings.Item1;
privateSettings.Items = settings.Item2;
privateSettings.DataBlobUri = configurationUris.DataBlobUri;
if (!string.IsNullOrEmpty(WmfVersion))
{
publicSettings.WmfVersion = WmfVersion;
}
}
if (string.IsNullOrEmpty(this.Location))
{
this.Location = GetLocationFromVm(this.ResourceGroupName, this.VMName);
}
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = DscExtensionCmdletConstants.ExtensionPublishedNamespace,
VirtualMachineExtensionType = DscExtensionCmdletConstants.ExtensionPublishedName,
TypeHandlerVersion = Version,
// Define the public and private property bags that will be passed to the extension.
Settings = publicSettings,
//PrivateConfuguration contains sensitive data in a plain text
ProtectedSettings = privateSettings,
AutoUpgradeMinorVersion = AutoUpdate.IsPresent
};
//Add retry logic due to CRP service restart known issue CRP bug: 3564713
var count = 1;
Rest.Azure.AzureOperationResponse<VirtualMachineExtension> op = null;
while (true)
{
try
{
op = VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
ResourceGroupName,
VMName,
Name ?? DscExtensionCmdletConstants.ExtensionPublishedNamespace + "." + DscExtensionCmdletConstants.ExtensionPublishedName,
parameters).GetAwaiter().GetResult();
break;
}
catch (Rest.Azure.CloudException ex)
{
var errorReturned = JsonConvert.DeserializeObject<ComputeLongRunningOperationError>(
ex.Response.Content);
if (ComputeOperationStatus.Failed.Equals(errorReturned.Status)
&& errorReturned.Error != null && "InternalExecutionError".Equals(errorReturned.Error.Code))
{
count++;
if (count <= 2)
{
continue;
}
}
ThrowTerminatingError(new ErrorRecord(ex, "InvalidResult", ErrorCategory.InvalidResult, null));
}
}
var result = Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
VirtualMachineExtension GetTestVMExtension()
{
var vmExtension = new VirtualMachineExtension
{
Name = "vmext01",
Location = ComputeManagementTestUtilities.DefaultLocation,
Tags = new Dictionary<string, string>() { { "extensionTag1", "1" }, { "extensionTag2", "2" } },
Type = "Microsoft.Compute/virtualMachines/extensions",
Publisher = "Microsoft.Compute",
ExtensionType = "VMAccessAgent",
TypeHandlerVersion = "2.0",
AutoUpgradeMinorVersion = true,
Settings = "{}",
ProtectedSettings = "{}"
};
return vmExtension;
}
