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