protected VirtualMachineScaleSetVM GenerateVMScaleSetVMModel(VirtualMachineScaleSet inputVMScaleSet, string instanceId, bool hasManagedDisks = false)
{
var OsProfile = new OSProfile()
{
AdminPassword = inputVMScaleSet.VirtualMachineProfile.OsProfile.AdminPassword,
AdminUsername = inputVMScaleSet.VirtualMachineProfile.OsProfile.AdminUsername,
CustomData = inputVMScaleSet.VirtualMachineProfile.OsProfile.CustomData,
ComputerName = inputVMScaleSet.VirtualMachineProfile.OsProfile.ComputerNamePrefix + "-" + instanceId
};
var StorageProfile = new StorageProfile()
{
ImageReference = inputVMScaleSet.VirtualMachineProfile.StorageProfile.ImageReference,
OsDisk = hasManagedDisks ? null : new OSDisk(inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.OsType, null, inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Name, null, inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image, inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Caching, null, null, inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.CreateOption, null, null)
};
VirtualMachineScaleSetVM expectedVirtualMachineScaleSetVM = new VirtualMachineScaleSetVM(null, null, null, null, null, null, null, null, null, null, null, null, null, null, StorageProfile, null, OsProfile, null, null, null, null, null, null, null, null);
{
/*InstanceId = instanceId,
* Sku = new Sku()
* {
* Name = inputVMScaleSet.Sku.Name
* },*/
};
if (hasManagedDisks && inputVMScaleSet.VirtualMachineProfile.StorageProfile.DataDisks != null)
{
expectedVirtualMachineScaleSetVM.StorageProfile.DataDisks = new List <DataDisk>();
foreach (var dataDisk in inputVMScaleSet.VirtualMachineProfile.StorageProfile.DataDisks)
{
expectedVirtualMachineScaleSetVM.StorageProfile.DataDisks.Add(new DataDisk(dataDisk.Lun, null, null, null, null, null, dataDisk.CreateOption, dataDisk.DiskSizeGB, null, null, null, null));
}
}
return(expectedVirtualMachineScaleSetVM);
}
private void AttachDataDiskToVMScaleSetVM(VirtualMachineScaleSetVM vmssVM, VirtualMachineScaleSetVM vmModel, int lun)
{
if (vmssVM.StorageProfile.DataDisks == null)
{
vmssVM.StorageProfile.DataDisks = new List <DataDisk>();
}
if (vmModel.StorageProfile.DataDisks == null)
{
vmModel.StorageProfile.DataDisks = new List <DataDisk>();
}
var diskName = TestPrefix + "dataDisk" + lun;
var disk = CreateDataDisk(diskName);
var dd = new DataDisk
{
CreateOption = DiskCreateOptionTypes.Attach,
Lun = lun,
Name = diskName,
ManagedDisk = new ManagedDiskParameters()
{
Id = disk.Id,
StorageAccountType = disk.Sku.Name
}
};
vmssVM.StorageProfile.DataDisks.Add(dd);
// Add the data disk to the model for validation later
vmModel.StorageProfile.DataDisks.Add(CreateModelDataDisk(disk));
}
private async Task AttachDataDiskToVMScaleSetVM(VirtualMachineScaleSetVM vmssVM, VirtualMachineScaleSetVM vmModel, int lun)
{
if (vmssVM.StorageProfile.DataDisks == null)
{
vmssVM.StorageProfile.DataDisks = new List <DataDisk>();
}
if (vmModel.StorageProfile.DataDisks == null)
{
vmModel.StorageProfile.DataDisks = new List <DataDisk>();
}
var diskName = TestPrefix + "dataDisk" + lun;
var disk = await CreateDataDisk(diskName);
var dd = new DataDisk(lun, DiskCreateOptionTypes.Attach)
{
Name = diskName,
ManagedDisk = new ManagedDiskParameters()
{
Id = disk.Id,
StorageAccountType = changeType(disk.Sku.Name)
}
};
//(lun, diskName, null, null, null, DiskCreateOptionTypes.Attach, null, new ManagedDiskParameters(disk.Id,disk.Sku.Name,null), null, null, null);
vmssVM.StorageProfile.DataDisks.Add(dd);
// Add the data disk to the model for validation later
vmModel.StorageProfile.DataDisks.Add(CreateModelDataDisk(disk));
}
protected VirtualMachineScaleSetVM GenerateVMScaleSetVMModel(VirtualMachineScaleSet inputVMScaleSet, string instanceId)
{
VirtualMachineScaleSetVM expectedVirtualMachineScaleSetVM = new VirtualMachineScaleSetVM()
{
/*InstanceId = instanceId,
* Sku = new Sku()
* {
* Name = inputVMScaleSet.Sku.Name
* },*/
OsProfile = new OSProfile()
{
AdminPassword = inputVMScaleSet.VirtualMachineProfile.OsProfile.AdminPassword,
AdminUsername = inputVMScaleSet.VirtualMachineProfile.OsProfile.AdminUsername,
CustomData = inputVMScaleSet.VirtualMachineProfile.OsProfile.CustomData,
ComputerName = inputVMScaleSet.VirtualMachineProfile.OsProfile.ComputerNamePrefix + "-" + instanceId
},
StorageProfile = new StorageProfile()
{
ImageReference = inputVMScaleSet.VirtualMachineProfile.StorageProfile.ImageReference,
OsDisk = new OSDisk()
{
Name = inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Name,
Caching = inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Caching,
CreateOption = inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.CreateOption,
OsType = inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.OsType,
Image = inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image,
}
},
};
return(expectedVirtualMachineScaleSetVM);
}
public async Task TestVMScaleSetVMOperations_Put()
{
bool passed = false;
EnsureClientsInitialized("westus2");
InitializeCommon();
instanceId = "0";
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(
rgName, vmssName, storageAccountOutput, imageRef, createWithManagedDisks : true, machineSizeType : VirtualMachineSizeTypes.StandardA1V2.ToString());
VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
VirtualMachineScaleSetVM vmssVM = await VirtualMachineScaleSetVMsOperations.GetAsync(rgName, vmScaleSet.Name, instanceId);
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks: true);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, vmssVM, hasManagedDisks: true);
await AttachDataDiskToVMScaleSetVM(vmssVM, vmScaleSetVMModel, 2);
VirtualMachineScaleSetVM vmssVMReturned = (await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartUpdateAsync(rgName, vmScaleSet.Name, vmssVM.InstanceId, vmssVM))).Value;
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, vmssVMReturned, hasManagedDisks: true);
passed = true;
Assert.True(passed);
}
protected void ValidateVMScaleSetVM(VirtualMachineScaleSetVM vmScaleSetVM, string skuName, VirtualMachineScaleSetVM vmScaleSetVMOut, bool hasManagedDisks = false)
{
Assert.True(!string.IsNullOrEmpty(vmScaleSetVMOut.ProvisioningState));
Assert.True(skuName
== vmScaleSetVMOut.Sku.Name);
Assert.NotNull(vmScaleSetVMOut.StorageProfile.OsDisk);
if (hasManagedDisks)
{
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.ManagedDisk != null);
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.ManagedDisk.Id != null);
if (vmScaleSetVM.StorageProfile.DataDisks != null)
{
Assert.AreEqual(vmScaleSetVM.StorageProfile.DataDisks.Count,
vmScaleSetVMOut.StorageProfile.DataDisks.Count);
foreach (var dataDiskOut in vmScaleSetVM.StorageProfile.DataDisks)
{
var dataDisk =
vmScaleSetVM.StorageProfile.DataDisks.FirstOrDefault(d => d.Lun == dataDiskOut.Lun);
Assert.AreEqual(dataDisk.CreateOption, dataDiskOut.CreateOption);
Assert.AreEqual(dataDisk.DiskSizeGB, dataDiskOut.DiskSizeGB);
}
}
}
else
{
if (vmScaleSetVM.StorageProfile.OsDisk.Image != null)
{
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.Image.Uri
== vmScaleSetVM.StorageProfile.OsDisk.Image.Uri);
}
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.Caching
== vmScaleSetVM.StorageProfile.OsDisk.Caching);
}
if (vmScaleSetVM.OsProfile.Secrets != null &&
vmScaleSetVM.OsProfile.Secrets.Any())
{
foreach (var secret in vmScaleSetVM.OsProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmScaleSetVMOut.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
}
protected void ExecuteVirtualMachineScaleSetVMUpdateMethod(object[] invokeMethodInputParameters)
{
string resourceGroupName = (string)ParseParameter(invokeMethodInputParameters[0]);
string vmScaleSetName = (string)ParseParameter(invokeMethodInputParameters[1]);
string instanceId = (string)ParseParameter(invokeMethodInputParameters[2]);
VirtualMachineScaleSetVM parameters = (VirtualMachineScaleSetVM)ParseParameter(invokeMethodInputParameters[3]);
var result = VirtualMachineScaleSetVMsClient.Update(resourceGroupName, vmScaleSetName, instanceId, parameters);
WriteObject(result);
}
protected PSArgument[] CreateVirtualMachineScaleSetVMUpdateParameters()
{
string resourceGroupName = string.Empty;
string vmScaleSetName = string.Empty;
string instanceId = string.Empty;
VirtualMachineScaleSetVM parameters = new VirtualMachineScaleSetVM();
return(ConvertFromObjectsToArguments(
new string[] { "ResourceGroupName", "VMScaleSetName", "InstanceId", "Parameters" },
new object[] { resourceGroupName, vmScaleSetName, instanceId, parameters }));
}
protected void ValidateVMScaleSetVM(VirtualMachineScaleSet vmScaleSet, string instanceId, VirtualMachineScaleSetVM vmScaleSetVMOut, bool hasManagedDisks = false)
{
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, vmScaleSetVMOut, hasManagedDisks);
// Validate Zones.
// The zone of the VM should be one of zones specified in the scaleset.
if (vmScaleSet.Zones != null)
{
Assert.NotNull(vmScaleSetVMOut.Zones);
Assert.AreEqual(1, vmScaleSetVMOut.Zones.Count);
//Assert.Contains(vmScaleSet.Zones, vmssZone => vmssZone == vmScaleSetVMOut.Zones.First());
}
}
public void TestVMScaleSetVMOperations_UserData()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
instanceId = "0";
try
{
InitializeCommon(context);
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
// Create VMSS with UserData
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(rgName, vmssName,
storageAccountOutput, imageRef, out inputVMScaleSet, createWithManagedDisks: true,
faultDomainCount: 1, bootDiagnosticsProfile: GetManagedDiagnosticsProfile(), userData: DummyUserData1);
// Validate Get VMSS with $expand=UserData returns the UserData
var getVmssResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmScaleSet.Name, expand: "userData");
Assert.Equal(DummyUserData1, getVmssResponse.VirtualMachineProfile.UserData);
// Validate Get VMSS VM with $expand=UserData returns the UserData
var getVmssVMResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId,
expand: InstanceViewTypes.UserData);
Assert.Equal(DummyUserData1, getVmssVMResponse.UserData);
// Update VMSS with new UserData
inputVMScaleSet.VirtualMachineProfile.UserData = DummyUserData2;
UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet);
// Validate Get VMSS with $expand=UserData returns the new UserData
getVmssResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmScaleSet.Name, expand: "userData");
Assert.Equal(DummyUserData2, getVmssResponse.VirtualMachineProfile.UserData);
// Update VMSS VM with new UserData
getVmssVMResponse.UserData = DummyUserData2;
VirtualMachineScaleSetVM vmssVMReturned = m_CrpClient.VirtualMachineScaleSetVMs.Update(rgName, vmScaleSet.Name, instanceId, getVmssVMResponse);
// Validate Get VMSS VM with $expand=UserData returns the new UserData
getVmssVMResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name,
instanceId, InstanceViewTypes.UserData);
Assert.Equal(DummyUserData2, getVmssResponse.VirtualMachineProfile.UserData);
}
finally
{
m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName);
}
}
}
protected void SetOSType(VirtualMachineScaleSetVM vmProfile)
{
if (vmProfile.StorageProfile != null &&
vmProfile.StorageProfile.OsDisk != null &&
vmProfile.StorageProfile.OsDisk.OsType != null)
{
this.CurrentOSType = vmProfile.StorageProfile.OsDisk.OsType.Value;
}
else if (vmProfile.OsProfile != null &&
vmProfile.OsProfile.LinuxConfiguration != null)
{
this.CurrentOSType = OperatingSystemTypes.Linux;
}
else
{
this.CurrentOSType = OperatingSystemTypes.Windows;
}
}
public void TestVMScaleSetVMOperations_Put()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION");
bool passed = false;
InitializeCommon(context);
try
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "westus2");
instanceId = "0";
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet, createWithManagedDisks: true, machineSizeType: VirtualMachineSizeTypes.StandardA1V2);
VirtualMachineScaleSetVM vmssVM = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId);
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks: true);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, vmssVM, hasManagedDisks: true);
AttachDataDiskToVMScaleSetVM(vmssVM, vmScaleSetVMModel, 2);
VirtualMachineScaleSetVM vmssVMReturned = m_CrpClient.VirtualMachineScaleSetVMs.Update(rgName, vmScaleSet.Name, vmssVM.InstanceId, vmssVM);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, vmssVMReturned, hasManagedDisks: true);
passed = true;
}
finally
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation);
// Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose
// of the test to cover deletion. CSM does persistent retrying over all RG resources.
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
Assert.True(passed);
}
}
private async Task TestVMScaleSetVMOperationsInternal(bool hasManagedDisks = false)
{
InitializeCommon();
instanceId = "0";
bool passed = false;
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(
rgName, vmssName, storageAccountOutput, imageRef,
createWithManagedDisks : hasManagedDisks);
VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
var getResponse = (await VirtualMachineScaleSetVMsOperations.GetAsync(rgName, vmScaleSet.Name, instanceId)).Value;
var imageReference = getResponse.StorageProfile.ImageReference;
Assert.NotNull(imageReference?.ExactVersion);
Assert.AreEqual(imageReference.Version, imageReference.ExactVersion);
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, getResponse, hasManagedDisks);
var getInstanceViewResponse = await VirtualMachineScaleSetVMsOperations.GetInstanceViewAsync(rgName,
vmScaleSet.Name, instanceId);
Assert.True(getInstanceViewResponse != null, "VMScaleSetVM not returned.");
ValidateVMScaleSetVMInstanceView(getInstanceViewResponse, hasManagedDisks);
//var query = new Microsoft.Rest.Azure.OData.ODataQuery<VirtualMachineScaleSetVM>();
//query.SetFilter(vm => vm.LatestModelApplied == true);
var query = "properties/latestModelApplied eq true";
var listResponse = await(VirtualMachineScaleSetVMsOperations.ListAsync(rgName, vmssName, query)).ToEnumerableAsync();
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
query = null;
//query.Filter = null;
//query.Expand = "instanceView";
listResponse = await(VirtualMachineScaleSetVMsOperations.ListAsync(rgName, vmssName, query, null, "instanceView")).ToEnumerableAsync();
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartStartAsync(rgName, vmScaleSet.Name, instanceId));
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartReimageAsync(rgName, vmScaleSet.Name, instanceId));
if (hasManagedDisks)
{
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartReimageAllAsync(rgName, vmScaleSet.Name, instanceId));
}
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartRestartAsync(rgName, vmScaleSet.Name, instanceId));
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartPowerOffAsync(rgName, vmScaleSet.Name, instanceId));
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartDeallocateAsync(rgName, vmScaleSet.Name, instanceId));
await WaitForCompletionAsync(await VirtualMachineScaleSetVMsOperations.StartDeleteAsync(rgName, vmScaleSet.Name, instanceId));
passed = true;
Assert.True(passed);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.VMScaleSetName, VerbsData.Update))
{
string resourceGroupName;
string vmScaleSetName;
string instanceId;
switch (this.ParameterSetName)
{
case ResourceIdParameterSet:
resourceGroupName = GetResourceGroupName(this.ResourceId);
vmScaleSetName = GetResourceName(this.ResourceId, "Microsoft.Compute/virtualMachineScaleSets", "virtualMachines");
instanceId = GetInstanceId(this.ResourceId, "Microsoft.Compute/virtualMachineScaleSets", "virtualMachines");
break;
case ObjectParameterSet:
resourceGroupName = GetResourceGroupName(this.VirtualMachineScaleSetVM.Id);
vmScaleSetName = GetResourceName(this.VirtualMachineScaleSetVM.Id, "Microsoft.Compute/virtualMachineScaleSets", "virtualMachines");
instanceId = GetInstanceId(this.VirtualMachineScaleSetVM.Id, "Microsoft.Compute/virtualMachineScaleSets", "virtualMachines");
break;
default:
resourceGroupName = this.ResourceGroupName;
vmScaleSetName = this.VMScaleSetName;
instanceId = this.InstanceId;
break;
}
VirtualMachineScaleSetVM parameters = new VirtualMachineScaleSetVM();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSVirtualMachineScaleSetVM, VirtualMachineScaleSetVM>(this.VirtualMachineScaleSetVM, parameters);
if (this.IsParameterBound(c => c.UserData))
{
parameters = VirtualMachineScaleSetVMsClient.Get(resourceGroupName, vmScaleSetName, instanceId, UserDataExpand);
}
else if (this.ParameterSetName != ObjectParameterSet)
{
parameters = VirtualMachineScaleSetVMsClient.Get(resourceGroupName, vmScaleSetName, instanceId);
}
if (this.DataDisk != null)
{
if (parameters.StorageProfile == null)
{
parameters.StorageProfile = new StorageProfile();
}
if (parameters.StorageProfile.DataDisks == null)
{
parameters.StorageProfile.DataDisks = new List <DataDisk>();
}
foreach (var d in this.DataDisk)
{
parameters.StorageProfile.DataDisks.Add(d);
}
}
if (this.IsParameterBound(c => c.ProtectFromScaleIn))
{
if (parameters.ProtectionPolicy == null)
{
parameters.ProtectionPolicy = new VirtualMachineScaleSetVMProtectionPolicy();
}
parameters.ProtectionPolicy.ProtectFromScaleIn = this.ProtectFromScaleIn;
}
if (this.IsParameterBound(c => c.ProtectFromScaleSetAction))
{
if (parameters.ProtectionPolicy == null)
{
parameters.ProtectionPolicy = new VirtualMachineScaleSetVMProtectionPolicy();
}
parameters.ProtectionPolicy.ProtectFromScaleSetActions = this.ProtectFromScaleSetAction;
}
if (this.IsParameterBound(c => c.UserData))
{
if (!ValidateBase64EncodedString.ValidateStringIsBase64Encoded(this.UserData))
{
this.UserData = ValidateBase64EncodedString.EncodeStringToBase64(this.UserData);
this.WriteInformation(ValidateBase64EncodedString.UserDataEncodeNotification, new string[] { "PSHOST" });
}
parameters.UserData = this.UserData;
}
var result = VirtualMachineScaleSetVMsClient.Update(resourceGroupName, vmScaleSetName, instanceId, parameters);
var psObject = new PSVirtualMachineScaleSetVM();
ComputeAutomationAutoMapperProfile.Mapper.Map <VirtualMachineScaleSetVM, PSVirtualMachineScaleSetVM>(result, psObject);
WriteObject(psObject);
}
});
}
private void TestVMScaleSetVMOperationsInternal(MockContext context, bool hasManagedDisks = false)
{
InitializeCommon(context);
instanceId = "0";
bool passed = false;
try
{
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet,
createWithManagedDisks: hasManagedDisks);
var getResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId);
var imageReference = getResponse.StorageProfile.ImageReference;
Assert.NotNull(imageReference?.ExactVersion);
Assert.Equal(imageReference.Version, imageReference.ExactVersion);
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, getResponse, hasManagedDisks);
var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName,
vmScaleSet.Name, instanceId);
Assert.True(getInstanceViewResponse != null, "VMScaleSetVM not returned.");
ValidateVMScaleSetVMInstanceView(getInstanceViewResponse, hasManagedDisks);
var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
query.SetFilter(vm => vm.LatestModelApplied == true);
var listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query);
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
query.Filter = null;
query.Expand = "instanceView";
listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query, "instanceView");
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
m_CrpClient.VirtualMachineScaleSetVMs.Start(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Reimage(rgName, vmScaleSet.Name, instanceId, tempDisk: null);
if (hasManagedDisks)
{
m_CrpClient.VirtualMachineScaleSetVMs.ReimageAll(rgName, vmScaleSet.Name, instanceId);
}
m_CrpClient.VirtualMachineScaleSetVMs.Restart(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.PowerOff(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Deallocate(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Delete(rgName, vmScaleSet.Name, instanceId);
passed = true;
}
finally
{
// Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose
// of the test to cover deletion. CSM does persistent retrying over all RG resources.
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
Assert.True(passed);
}
public static VirtualMachineScaleSetVM GetVirtualMachineScaleSetVM(this ArmClient armClient, ResourceIdentifier id)
{
VirtualMachineScaleSetVM.ValidateResourceId(id);
return(armClient.UseClientContext((uri, credential, clientOptions, pipeline) => new VirtualMachineScaleSetVM(clientOptions, credential, uri, pipeline, id)));
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.VMScaleSetName, VerbsData.Update))
{
string resourceGroupName;
string vmScaleSetName;
string instanceId;
switch (this.ParameterSetName)
{
case "ResourceIdParameter":
resourceGroupName = GetResourceGroupName(this.ResourceId);
vmScaleSetName = GetResourceName(this.ResourceId, "Microsoft.Compute/VirtualMachineScaleSets", "virtualMachines");
instanceId = GetInstanceId(this.ResourceId, "Microsoft.Compute/VirtualMachineScaleSets", "virtualMachines");
break;
case "ObjectParameter":
resourceGroupName = GetResourceGroupName(this.VirtualMachineScaleSetVM.Id);
vmScaleSetName = GetResourceName(this.VirtualMachineScaleSetVM.Id, "Microsoft.Compute/VirtualMachineScaleSets", "virtualMachines");
instanceId = GetInstanceId(this.VirtualMachineScaleSetVM.Id, "Microsoft.Compute/VirtualMachineScaleSets", "virtualMachines");
break;
default:
resourceGroupName = this.ResourceGroupName;
vmScaleSetName = this.VMScaleSetName;
instanceId = this.InstanceId;
break;
}
VirtualMachineScaleSetVM parameters = new VirtualMachineScaleSetVM();
ComputeAutomationAutoMapperProfile.Mapper.Map <PSVirtualMachineScaleSetVM, VirtualMachineScaleSetVM>(this.VirtualMachineScaleSetVM, parameters);
if (this.ParameterSetName != "ObjectParameter")
{
parameters = VirtualMachineScaleSetVMsClient.Get(resourceGroupName, vmScaleSetName, instanceId);
}
if (this.DataDisk != null)
{
if (parameters.StorageProfile == null)
{
parameters.StorageProfile = new StorageProfile();
}
if (parameters.StorageProfile.DataDisks == null)
{
parameters.StorageProfile.DataDisks = new List <DataDisk>();
}
foreach (var d in this.DataDisk)
{
parameters.StorageProfile.DataDisks.Add(d);
}
}
var result = VirtualMachineScaleSetVMsClient.Update(resourceGroupName, vmScaleSetName, instanceId, parameters);
var psObject = new PSVirtualMachineScaleSetVM();
ComputeAutomationAutoMapperProfile.Mapper.Map <VirtualMachineScaleSetVM, PSVirtualMachineScaleSetVM>(result, psObject);
WriteObject(psObject);
}
});
}
public void TestVMScaleSetVMOperations()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
EnsureClientsInitialized(context);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
// Create resource group
string rgName = TestUtilities.GenerateName(TestPrefix) + 1;
string vmssName = TestUtilities.GenerateName("vmss");
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
const string instanceId = "0";
VirtualMachineScaleSet inputVMScaleSet;
bool passed = false;
try
{
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet);
var getResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId);
VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId);
ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, getResponse);
var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmScaleSet.Name, instanceId);
Assert.True(getInstanceViewResponse != null, "VMScaleSetVM not returned.");
ValidateVMScaleSetVMInstanceView(getInstanceViewResponse);
var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
query.SetFilter(vm => vm.LatestModelApplied == true);
var listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query);
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
query.Filter = null;
query.Expand = "instanceView";
listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query, "instanceView");
Assert.False(listResponse == null, "VMScaleSetVMs not returned");
Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity);
m_CrpClient.VirtualMachineScaleSetVMs.Start(rgName, vmScaleSet.Name, instanceId);
// TODO: Re-enable the test once GA
//m_CrpClient.VirtualMachineScaleSetVMs.Reimage(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Restart(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.PowerOff(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Deallocate(rgName, vmScaleSet.Name, instanceId);
m_CrpClient.VirtualMachineScaleSetVMs.Delete(rgName, vmScaleSet.Name, instanceId);
passed = true;
}
finally
{
// Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose
// of the test to cover deletion. CSM does persistent retrying over all RG resources.
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
Assert.True(passed);
}
}
