public async Task <Response <VirtualMachineExtension> > GetAsync(string resourceGroupName, string vmScaleSetName, string instanceId, string vmExtensionName, string expand = null, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (vmScaleSetName == null)
{
throw new ArgumentNullException(nameof(vmScaleSetName));
}
if (instanceId == null)
{
throw new ArgumentNullException(nameof(instanceId));
}
if (vmExtensionName == null)
{
throw new ArgumentNullException(nameof(vmExtensionName));
}
using var message = CreateGetRequest(resourceGroupName, vmScaleSetName, instanceId, vmExtensionName, expand);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
VirtualMachineExtension value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = VirtualMachineExtension.DeserializeVirtualMachineExtension(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
private void ExecuteCommand()
{
ExecuteClientAction(() =>
{
var parameters = new VirtualMachineExtension
{
Location = this.Location,
Settings = this.PublicConfiguration,
ProtectedSettings = this.PrivateConfiguration,
Publisher = DiagnosticsExtensionConstants.ExtensionPublisher,
VirtualMachineExtensionType = DiagnosticsExtensionConstants.ExtensionType,
TypeHandlerVersion = this.TypeHandlerVersion,
AutoUpgradeMinorVersion = this.AutoUpgradeMinorVersion
};
if (NoWait.IsPresent)
{
var op = this.VirtualMachineExtensionClient.BeginCreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(op);
WriteObject(result);
}
else
{
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(op);
WriteObject(result);
}
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
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);
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (String.IsNullOrEmpty(Name))
{
VirtualMachine vm = ComputeClient.ComputeManagementClient.VirtualMachines.Get(this.ResourceGroupName, this.VMName);
if (vm != null)
{
VirtualMachineExtension virtualMachineExtension = vm.Resources.Where(x => x.Publisher.Equals(VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace)).FirstOrDefault();
if (virtualMachineExtension != null)
{
this.Name = virtualMachineExtension.Name;
}
}
if (String.IsNullOrEmpty(Name))
{
Name = VirtualMachineSqlServerExtensionContext.ExtensionPublishedName;
}
}
var result = VirtualMachineExtensionClient.GetWithInstanceView(ResourceGroupName, VMName, Name);
var extension = result.ToPSVirtualMachineExtension(this.ResourceGroupName, this.VMName);
if (
extension.Publisher.Equals(VirtualMachineSqlServerExtensionContext.ExtensionPublishedNamespace,
StringComparison.InvariantCultureIgnoreCase) &&
extension.ExtensionType.Equals(VirtualMachineSqlServerExtensionContext.ExtensionPublishedType,
StringComparison.InvariantCultureIgnoreCase))
{
WriteObject(GetSqlServerExtensionContext(extension));
}
else
{
WriteObject(null);
}
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters)
{
Hashtable SettingString = GetExtensionPublicSettings();
Hashtable ProtectedSettingString = GetExtensionProtectedSettings();
if (vmParameters == null)
{
ThrowTerminatingError(
new ErrorRecord(
new ApplicationException(
string.Format(
CultureInfo.CurrentUICulture,
"Disable-AzureDiskEncryption can disable 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
};
}
return(vmExtensionParameters);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
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);
});
}
VirtualMachineExtension GetTestVMExtension()
{
var vmExtension = new VirtualMachineExtension
{
Location = ComputeManagementTestUtilities.DefaultLocation,
Tags = new Dictionary <string, string>()
{
{ "extensionTag1", "1" }, { "extensionTag2", "2" }
},
Publisher = "Microsoft.Compute",
VirtualMachineExtensionType = "VMAccessAgent",
TypeHandlerVersion = "2.0",
AutoUpgradeMinorVersion = false,
ForceUpdateTag = "RerunExtension",
Settings = "{}",
ProtectedSettings = "{}"
};
typeof(Resource).GetRuntimeProperty("Name").SetValue(vmExtension, "vmext01");
typeof(Resource).GetRuntimeProperty("Type").SetValue(vmExtension, "Microsoft.Compute/virtualMachines/extensions");
return(vmExtension);
}
VirtualMachineExtension GetHealthVMExtension()
{
var vmExtension = new VirtualMachineExtension
{
Location = ComputeManagementTestUtilities.DefaultLocation,
Tags = new Dictionary <string, string>()
{
{ "extensionTag1", "1" }, { "extensionTag2", "2" }
},
Publisher = "Microsoft.ManagedServices",
VirtualMachineExtensionType = "ApplicationHealthWindows",
TypeHandlerVersion = "1.0",
AutoUpgradeMinorVersion = true,
ForceUpdateTag = "RerunExtension",
Settings = new JRaw("{ \"port\": 3389, \"protocol\": \"tcp\" }"),
ProtectedSettings = "{}"
};
typeof(Resource).GetRuntimeProperty("Name").SetValue(vmExtension, "vmext01");
typeof(Resource).GetRuntimeProperty("Type").SetValue(vmExtension, "Microsoft.Compute/virtualMachines/extensions");
return(vmExtension);
}
public static PSVirtualMachineExtension ToPSVirtualMachineExtension(this VirtualMachineExtension ext, string rgName = null)
{
PSVirtualMachineExtension result = new PSVirtualMachineExtension
{
ResourceGroupName = rgName,
Name = ext.Name,
Location = ext.Location,
Etag = JsonConvert.SerializeObject(ext.Tags),
Publisher = ext.Publisher,
ExtensionType = ext.VirtualMachineExtensionType,
TypeHandlerVersion = ext.TypeHandlerVersion,
Id = ext.Id,
PublicSettings = ext.Settings == null ? null : ext.Settings.ToString(),
ProtectedSettings = ext.ProtectedSettings == null ? null : ext.ProtectedSettings.ToString(),
ProvisioningState = ext.ProvisioningState,
Statuses = ext.InstanceView == null ? null : ext.InstanceView.Statuses,
SubStatuses = ext.InstanceView == null ? null : ext.InstanceView.Substatuses,
AutoUpgradeMinorVersion = ext.AutoUpgradeMinorVersion,
ForceUpdateTag = ext.ForceUpdateTag
};
return(result);
}
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);
}
private EncryptionStatus AreWindowsDataVolumesEncryptedDualPass(VirtualMachine vmParameters)
{
VirtualMachineExtension vmExtension = this.FindEncryptionExtension(vmParameters);
if (vmExtension == null)
{
return(EncryptionStatus.Unknown);
}
AzureDiskEncryptionExtensionContext adeExtension =
new AzureDiskEncryptionExtensionContext(vmExtension.ToPSVirtualMachineExtension(this.ResourceGroupName, this.VMName));
if (DataVolumeInExtensionConfig(adeExtension))
{
if (adeExtension.EncryptionOperation.Equals(AzureDiskEncryptionExtensionConstants.enableEncryptionOperation, StringComparison.InvariantCultureIgnoreCase))
{
if (ExtensionProvisioningSucceeded(adeExtension))
{
return(EncryptionStatus.Encrypted);
}
}
}
return(EncryptionStatus.NotEncrypted);
}
internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string vmScaleSetName, string instanceId, string vmExtensionName, VirtualMachineExtension extensionParameters)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Put;
var uri = new RawRequestUriBuilder();
uri.Reset(endpoint);
uri.AppendPath("/subscriptions/", false);
uri.AppendPath(subscriptionId, true);
uri.AppendPath("/resourceGroups/", false);
uri.AppendPath(resourceGroupName, true);
uri.AppendPath("/providers/Microsoft.Compute/virtualMachineScaleSets/", false);
uri.AppendPath(vmScaleSetName, true);
uri.AppendPath("/virtualMachines/", false);
uri.AppendPath(instanceId, true);
uri.AppendPath("/extensions/", false);
uri.AppendPath(vmExtensionName, true);
uri.AppendQuery("api-version", "2019-12-01", true);
request.Uri = uri;
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(extensionParameters);
request.Content = content;
return(message);
}
public async Task <Response> CreateOrUpdateAsync(string resourceGroupName, string vmScaleSetName, string instanceId, string vmExtensionName, VirtualMachineExtension extensionParameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (vmScaleSetName == null)
{
throw new ArgumentNullException(nameof(vmScaleSetName));
}
if (instanceId == null)
{
throw new ArgumentNullException(nameof(instanceId));
}
if (vmExtensionName == null)
{
throw new ArgumentNullException(nameof(vmExtensionName));
}
if (extensionParameters == null)
{
throw new ArgumentNullException(nameof(extensionParameters));
}
using var message = CreateCreateOrUpdateRequest(resourceGroupName, vmScaleSetName, instanceId, vmExtensionName, extensionParameters);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 201:
return(message.Response);
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
public void DefaultExecuteCmdlet()
{
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(),
}
};
}
}
if (ShouldProcess(this.VM.Name, VerbsCommon.New))
{
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 ?? this.VM.LicenseType,
AvailabilitySet = this.VM.AvailabilitySetReference,
Location = this.Location ?? this.VM.Location,
Tags = this.Tag != null ? this.Tag.ToDictionary() : this.VM.Tags,
Identity = ComputeAutoMapperProfile.Mapper.Map <VirtualMachineIdentity>(this.VM.Identity),
Zones = this.Zone ?? this.VM.Zones,
ProximityPlacementGroup = this.VM.ProximityPlacementGroup,
Host = this.VM.Host,
VirtualMachineScaleSet = this.VM.VirtualMachineScaleSet,
AdditionalCapabilities = this.VM.AdditionalCapabilities,
Priority = this.VM.Priority,
EvictionPolicy = this.VM.EvictionPolicy,
BillingProfile = this.VM.BillingProfile
};
Dictionary <string, List <string> > auxAuthHeader = null;
if (!string.IsNullOrEmpty(parameters.StorageProfile?.ImageReference?.Id))
{
var resourceId = ResourceId.TryParse(parameters.StorageProfile.ImageReference.Id);
if (string.Equals(ComputeStrategy.Namespace, resourceId?.ResourceType?.Namespace, StringComparison.OrdinalIgnoreCase) &&
string.Equals("galleries", resourceId?.ResourceType?.Provider, StringComparison.OrdinalIgnoreCase) &&
!string.Equals(this.ComputeClient?.ComputeManagementClient?.SubscriptionId, resourceId?.SubscriptionId, StringComparison.OrdinalIgnoreCase))
{
List <string> resourceIds = new List <string>();
resourceIds.Add(parameters.StorageProfile.ImageReference.Id);
var auxHeaderDictionary = GetAuxilaryAuthHeaderFromResourceIds(resourceIds);
if (auxHeaderDictionary != null && auxHeaderDictionary.Count > 0)
{
auxAuthHeader = new Dictionary <string, List <string> >(auxHeaderDictionary);
}
}
}
var result = this.VirtualMachineClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VM.Name,
parameters,
auxAuthHeader).GetAwaiter().GetResult();
var psResult = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(result);
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(CM.Resource).GetRuntimeProperty("Name")
.SetValue(extensionParameters, VirtualMachineBGInfoExtensionContext.ExtensionDefaultName);
typeof(CM.Resource).GetRuntimeProperty("Type")
.SetValue(extensionParameters, VirtualMachineExtensionType);
var op2 = ComputeClient.ComputeManagementClient.VirtualMachineExtensions.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VM.Name,
VirtualMachineBGInfoExtensionContext.ExtensionDefaultName,
extensionParameters).GetAwaiter().GetResult();
psResult = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(op2);
}
}
WriteObject(psResult);
});
}
}
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(() =>
{
VirtualMachine vmParameters = (this.ComputeClient.ComputeManagementClient.VirtualMachines.Get(this.ResourceGroupName, this.VMName));
EncryptionStatus osVolumeEncrypted = IsOsVolumeEncrypted(vmParameters);
DiskEncryptionSettings osVolumeEncryptionSettings = GetOsVolumeEncryptionSettings(vmParameters);
EncryptionStatus dataVolumesEncrypted = AreDataVolumesEncrypted(vmParameters);
AzureDiskEncryptionStatusContext encryptionStatus = null;
string progressMessage = null;
OSType osType = GetOSType(vmParameters);
switch (osType)
{
case OSType.Windows:
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = osVolumeEncrypted,
DataVolumesEncrypted = dataVolumesEncrypted,
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = string.Format(CultureInfo.CurrentUICulture, "OsVolume: {0}, DataVolumes: {1}", osVolumeEncrypted, dataVolumesEncrypted)
};
WriteObject(encryptionStatus);
break;
case OSType.Linux:
if (!IsExtensionInstalled(osType))
{
VirtualMachine virtualMachineResponse = this.ComputeClient.ComputeManagementClient.VirtualMachines.GetWithInstanceView(
this.ResourceGroupName, VMName).Body;
VirtualMachineExtension parameters = GetVmExtensionParameters(virtualMachineResponse, osType);
this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
}
Dictionary <string, string> encryptionStatusParsed = null;
try
{
string encryptionStatusJson = GetExtensionStatusMessage(osType, returnSubstatusMessage: true);
encryptionStatusParsed = JsonConvert.DeserializeObject <Dictionary <string, string> >(encryptionStatusJson);
}
catch (KeyNotFoundException)
{
encryptionStatusParsed = new Dictionary <string, string>()
{
{ AzureDiskEncryptionExtensionConstants.encryptionResultOsKey, EncryptionStatus.Unknown.ToString() },
{ AzureDiskEncryptionExtensionConstants.encryptionResultDataKey, EncryptionStatus.Unknown.ToString() }
};
}
try
{
progressMessage = GetExtensionStatusMessage(osType);
}
catch (KeyNotFoundException)
{
progressMessage = string.Format(CultureInfo.CurrentUICulture, "Extension status not available on the VM");
}
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultOsKey]),
DataVolumesEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultDataKey]),
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = progressMessage
};
WriteObject(encryptionStatus);
break;
case OSType.Unknown:
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "OS type unknown.")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
break;
}
});
}
/// <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.CreateArmClient <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.");
}
}
/// <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 VirtualMachine SetAzureVMDiagnosticsExtensionC(VirtualMachine vm, VirtualMachineInstanceView vmStatus, string storageAccountName, string storageAccountKey)
{
System.Xml.XmlDocument xpublicConfig = null;
var extensionName = AEMExtensionConstants.WADExtensionDefaultName[this.OSType];
var extTemp = this._Helper.GetExtension(vm,
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");
Version wadVersion = this._Helper.GetExtensionVersion(vm, vmStatus, OSType,
AEMExtensionConstants.WADExtensionType[this.OSType], AEMExtensionConstants.WADExtensionPublisher[this.OSType]);
VirtualMachineExtension vmExtParameters = new VirtualMachineExtension();
vmExtParameters.Publisher = AEMExtensionConstants.WADExtensionPublisher[this.OSType];
vmExtParameters.VirtualMachineExtensionType = AEMExtensionConstants.WADExtensionType[this.OSType];
vmExtParameters.TypeHandlerVersion = wadVersion.ToString(2);
vmExtParameters.Settings = jPublicConfig;
vmExtParameters.ProtectedSettings = jPrivateConfig;
vmExtParameters.Location = vm.Location;
vmExtParameters.AutoUpgradeMinorVersion = true;
vmExtParameters.ForceUpdateTag = DateTime.Now.Ticks.ToString();
this.VirtualMachineExtensionClient.CreateOrUpdate(ResourceGroupName, vm.Name, extensionName, vmExtParameters);
return(this.ComputeClient.ComputeManagementClient.VirtualMachines.Get(ResourceGroupName, vm.Name));
}
private AzureDiskEncryptionStatusContext getStatusDualPass(VirtualMachine vm)
{
DiskEncryptionSettings osVolumeEncryptionSettings = GetOsVolumeEncryptionSettingsDualPass(vm);
AzureDiskEncryptionStatusContext encryptionStatus = null;
switch (vm.StorageProfile.OsDisk.OsType)
{
case OperatingSystemTypes.Windows:
EncryptionStatus osVolumeEncrypted = IsWindowsOsVolumeEncryptedDualPass(vm);
EncryptionStatus dataVolumesEncrypted = AreWindowsDataVolumesEncryptedDualPass(vm);
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = osVolumeEncrypted,
DataVolumesEncrypted = dataVolumesEncrypted,
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = string.Format(CultureInfo.CurrentUICulture, "OsVolume: {0}, DataVolumes: {1}", osVolumeEncrypted, dataVolumesEncrypted)
};
break;
case OperatingSystemTypes.Linux:
if (!this.IsExtensionInstalled(vm) && this.isVMRunning(vm))
{
VirtualMachineExtension parameters = GetDualPassQueryVmExtensionParameters(vm);
this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
}
Dictionary <string, string> encryptionStatusParsed = null;
try
{
string encryptionStatusJson = GetExtensionStatusMessage(vm, returnSubstatusMessage: true);
encryptionStatusParsed = JsonConvert.DeserializeObject <Dictionary <string, string> >(encryptionStatusJson);
}
catch (KeyNotFoundException)
{
encryptionStatusParsed = new Dictionary <string, string>()
{
{ AzureDiskEncryptionExtensionConstants.encryptionResultOsKey, EncryptionStatus.Unknown.ToString() },
{ AzureDiskEncryptionExtensionConstants.encryptionResultDataKey, EncryptionStatus.Unknown.ToString() }
};
}
string progressMessage = null;
try
{
progressMessage = GetExtensionStatusMessage(vm);
}
catch (KeyNotFoundException)
{
progressMessage = string.Format(CultureInfo.CurrentUICulture, "Extension status not available on the VM");
}
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultOsKey]),
DataVolumesEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultDataKey]),
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = progressMessage
};
break;
default:
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "OS type unknown.")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
break;
}
return(encryptionStatus);
}
/// <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 Task <VirtualMachineExtensionCreateOrUpdateResponse> BeginCreatingOrUpdatingAsync(this IVirtualMachineExtensionOperations operations, string resourceGroupName, string vmName, VirtualMachineExtension extensionParameters)
{
return(operations.BeginCreatingOrUpdatingAsync(resourceGroupName, vmName, extensionParameters, CancellationToken.None));
}
public void DeleteConnectionMonitorTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler3 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1, true);
var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
var computeManagementClient = NetworkManagementTestUtilities.GetComputeManagementClientWithHandler(context, handler3);
string location = "centraluseuap";
string resourceGroupName = TestUtilities.GenerateName();
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
string virtualMachineName = TestUtilities.GenerateName();
string networkInterfaceName = TestUtilities.GenerateName();
string networkSecurityGroupName = virtualMachineName + "-nsg";
//Deploy VM with a template
DeploymentUpdate.CreateVm(
resourcesClient: resourcesClient,
resourceGroupName: resourceGroupName,
location: location,
virtualMachineName: virtualMachineName,
storageAccountName: TestUtilities.GenerateName(),
networkInterfaceName: networkInterfaceName,
networkSecurityGroupName: networkSecurityGroupName,
diagnosticsStorageAccountName: TestUtilities.GenerateName(),
deploymentName: TestUtilities.GenerateName()
);
var getVm = computeManagementClient.VirtualMachines.Get(resourceGroupName, virtualMachineName);
//Deploy networkWatcherAgent on VM
VirtualMachineExtension parameters = new VirtualMachineExtension
{
Publisher = "Microsoft.Azure.NetworkWatcher",
TypeHandlerVersion = "1.4",
VirtualMachineExtensionType = "NetworkWatcherAgentWindows",
Location = location
};
var addExtension = computeManagementClient.VirtualMachineExtensions.CreateOrUpdate(resourceGroupName, getVm.Name, "NetworkWatcherAgent", parameters);
string networkWatcherName = TestUtilities.GenerateName();
NetworkWatcher properties = new NetworkWatcher
{
Location = location
};
//Create network Watcher
var createNetworkWatcher = networkManagementClient.NetworkWatchers.CreateOrUpdate(resourceGroupName, networkWatcherName, properties);
string connectionMonitorName1 = TestUtilities.GenerateName();
string connectionMonitorName2 = TestUtilities.GenerateName();
ConnectionMonitor cm = new ConnectionMonitor
{
Location = location,
Source = new ConnectionMonitorSource
{
ResourceId = getVm.Id
},
Destination = new ConnectionMonitorDestination
{
Address = "bing.com",
Port = 80
},
MonitoringIntervalInSeconds = 30,
AutoStart = false
};
var connectionMonitor1 = networkManagementClient.ConnectionMonitors.CreateOrUpdate(resourceGroupName, networkWatcherName, connectionMonitorName1, cm);
var connectionMonitor2 = networkManagementClient.ConnectionMonitors.CreateOrUpdate(resourceGroupName, networkWatcherName, connectionMonitorName2, cm);
var getConnectionMonitors1 = networkManagementClient.ConnectionMonitors.List(resourceGroupName, networkWatcherName);
Assert.Equal(2, getConnectionMonitors1.Count());
networkManagementClient.ConnectionMonitors.Delete(resourceGroupName, networkWatcherName, connectionMonitorName2);
var getConnectionMonitors2 = networkManagementClient.ConnectionMonitors.List(resourceGroupName, networkWatcherName);
Assert.Single(getConnectionMonitors2);
}
}
public virtual VirtualMachineExtensionsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string vmName, string vmExtensionName, VirtualMachineExtension extensionParameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (vmName == null)
{
throw new ArgumentNullException(nameof(vmName));
}
if (vmExtensionName == null)
{
throw new ArgumentNullException(nameof(vmExtensionName));
}
if (extensionParameters == null)
{
throw new ArgumentNullException(nameof(extensionParameters));
}
using var scope = _clientDiagnostics.CreateScope("VirtualMachineExtensionsClient.StartCreateOrUpdate");
scope.Start();
try
{
var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, vmName, vmExtensionName, extensionParameters, cancellationToken);
return(new VirtualMachineExtensionsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, vmName, vmExtensionName, extensionParameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
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 <PSComputeLongRunningOperation>(
ex.Response.Content);
if ("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 = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(op);
WriteObject(result);
}
public override void ExecuteCmdlet()
{
WriteWarning(Properties.Resources.TagFixWarningMessage);
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(),
}
};
}
}
if (ShouldProcess(this.VM.Name, VerbsCommon.New))
{
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 ?? this.VM.LicenseType,
AvailabilitySet = this.VM.AvailabilitySetReference,
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);
});
}
}
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();
ExecuteClientAction(() =>
{
VirtualMachine virtualMachineResponse = (this.ComputeClient.ComputeManagementClient.VirtualMachines.Get(this.ResourceGroupName, this.VMName));
if ((virtualMachineResponse == null) ||
(virtualMachineResponse.StorageProfile == null) ||
(virtualMachineResponse.StorageProfile.OsDisk == null))
{
// VM should have been created and have valid storageProfile and OSDisk by now
ThrowTerminatingError(
new ErrorRecord(
new ApplicationException(
string.Format(
CultureInfo.CurrentUICulture,
"Disable-AzureDiskEncryption can disable encryption only on a VM that was already created and has appropriate storageProfile and OS disk")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
currentOSType = virtualMachineResponse.StorageProfile.OsDisk.OsType;
if (OperatingSystemTypes.Linux.Equals(currentOSType) &&
!AzureDiskEncryptionExtensionContext.VolumeTypeData.Equals(VolumeType, StringComparison.InvariantCultureIgnoreCase))
{
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException(
string.Format(
CultureInfo.CurrentUICulture,
"Disabling encryption is only allowed on Data volumes for Linux VMs.")),
"InvalidType",
ErrorCategory.NotImplemented,
null));
}
if (this.ShouldProcess(VMName, Properties.Resources.DisableDiskEncryptionAction) &&
(this.Force.IsPresent ||
this.ShouldContinue(Properties.Resources.DisableAzureDiskEncryptionConfirmation, Properties.Resources.DisableAzureDiskEncryptionCaption)))
{
VirtualMachineExtension parameters = GetVmExtensionParameters(virtualMachineResponse);
var opExt = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
if (string.IsNullOrWhiteSpace(VolumeType) ||
VolumeType.Equals(AzureDiskEncryptionExtensionContext.VolumeTypeAll, StringComparison.InvariantCultureIgnoreCase) ||
VolumeType.Equals(AzureDiskEncryptionExtensionContext.VolumeTypeOS, StringComparison.InvariantCultureIgnoreCase))
{
var opVm = UpdateVmEncryptionSettings();
var result = Mapper.Map <PSAzureOperationResponse>(opVm);
WriteObject(result);
}
else
{
var result = Mapper.Map <PSAzureOperationResponse>(opExt);
WriteObject(result);
}
}
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(VirtualMachineCustomScriptExtensionContext.ExtensionDefaultName, VerbsCommon.Set))
{
ExecuteClientAction(() =>
{
if (string.Equals(this.ParameterSetName, SetCustomScriptExtensionByContainerBlobsParamSetName))
{
this.StorageEndpointSuffix = string.IsNullOrEmpty(this.StorageEndpointSuffix) ?
DefaultProfile.DefaultContext.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 = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun
};
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = ComputeAutoMapperProfile.Mapper.Map <PSAzureOperationResponse>(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 parameters = new VirtualMachineExtension
{
Location = this.Location,
Publisher = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = VirtualMachineCustomScriptExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = (this.TypeHandlerVersion) ?? VirtualMachineCustomScriptExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = GetPrivateConfiguration(),
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.ReadAsStringAsync().Result);
WriteObject(errorReturned);
}
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(VirtualMachineCustomScriptExtensionContext.ExtensionDefaultName, VerbsCommon.Set))
{
ExecuteClientAction(() =>
{
if (this.VMObject != null)
{
this.ResourceGroupName = this.VMObject.ResourceGroupName;
this.VMName = this.VMObject.Name;
}
if (this.InputObject != null)
{
this.ResourceGroupName = this.InputObject.ResourceGroupName;
this.VMName = this.InputObject.VMName;
this.Name = this.InputObject.Name;
this.Location = string.IsNullOrEmpty(this.Location) ? this.InputObject.Location : this.Location;
this.TypeHandlerVersion = string.IsNullOrEmpty(this.TypeHandlerVersion) ? this.InputObject.TypeHandlerVersion : this.TypeHandlerVersion;
this.FileUri = (this.FileUri == null || !this.FileUri.Any()) ? this.InputObject.Uri : this.FileUri;
string cmdToExe = this.InputObject.CommandToExecute;
int startIndexFile = cmdToExe.IndexOf("-file ");
if (startIndexFile > 0)
{
string cmdToExeFinal = cmdToExe.Substring(startIndexFile + 6);
string[] splits = cmdToExeFinal.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
this.Run = string.IsNullOrEmpty(this.Run) ? splits[0] : this.Run;
this.Argument = string.IsNullOrEmpty(this.Argument) ? string.Join(" ", splits.Skip(1)) : this.Argument;
}
}
if (!string.IsNullOrEmpty(this.ResourceId))
{
var identifier = new ResourceIdentifier(this.ResourceId);
this.ResourceGroupName = identifier.ResourceGroupName;
this.VMName = identifier.ParentResource.Split('/').Last();
this.Name = identifier.ResourceName;
}
if (this.ParameterSetName.Contains(WithContainerAndFileNamesParameterSet))
{
this.StorageEndpointSuffix = string.IsNullOrEmpty(this.StorageEndpointSuffix) ?
DefaultProfile.DefaultContext.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 = !this.DisableAutoUpgradeMinorVersion.IsPresent,
ForceUpdateTag = this.ForceRerun
};
if (NoWait.IsPresent)
{
var op = this.VirtualMachineExtensionClient.BeginCreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = ComputeAutoMapperProfile.Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
else
{
var op = this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
var result = ComputeAutoMapperProfile.Mapper.Map<PSAzureOperationResponse>(op);
WriteObject(result);
}
});
}
}
