private VirtualMachineScaleSet CreateVMScaleSetAndGetOperationResponse(
string rgName,
string vmssName,
StorageAccount storageAccount,
ImageReference imageRef,
out VirtualMachineScaleSet inputVMScaleSet,
VirtualMachineScaleSetExtensionProfile extensionProfile = null,
Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null,
bool createWithPublicIpAddress = false,
bool createWithManagedDisks = false,
bool hasDiffDisks = false,
bool createWithHealthProbe = false,
Subnet subnet = null,
IList <string> zones = null,
int?osDiskSizeInGB = null,
string ppgId = null,
string machineSizeType = null,
bool?enableUltraSSD = false,
string diskEncryptionSetId = null,
AutomaticRepairsPolicy automaticRepairsPolicy = null,
bool?encryptionAtHostEnabled = null,
bool singlePlacementGroup = true,
DiagnosticsProfile bootDiagnosticsProfile = null,
int?faultDomainCount = null,
int?capacity = null,
string dedicatedHostGroupReferenceId = null,
string dedicatedHostGroupName = null,
string dedicatedHostName = null,
string userData = null,
string capacityReservationGroupReferenceId = null,
VirtualMachineScaleSetHardwareProfile hardwareProfile = null)
{
// Create the resource Group, it might have been already created during StorageAccount creation.
var resourceGroup = m_ResourcesClient.ResourceGroups.CreateOrUpdate(
rgName,
new ResourceGroup
{
Location = m_location
});
var getPublicIpAddressResponse = createWithPublicIpAddress ? null : CreatePublicIP(rgName);
var subnetResponse = subnet ?? CreateVNET(rgName);
var nicResponse = CreateNIC(
rgName,
subnetResponse,
getPublicIpAddressResponse != null ? getPublicIpAddressResponse.IpAddress : null);
var loadBalancer = (getPublicIpAddressResponse != null && createWithHealthProbe) ?
CreatePublicLoadBalancerWithProbe(rgName, getPublicIpAddressResponse) : null;
Assert.True(createWithManagedDisks || storageAccount != null);
inputVMScaleSet = CreateDefaultVMScaleSetInput(rgName, storageAccount?.Name, imageRef, subnetResponse.Id, hasManagedDisks: createWithManagedDisks,
healthProbeId: loadBalancer?.Probes?.FirstOrDefault()?.Id,
loadBalancerBackendPoolId: loadBalancer?.BackendAddressPools?.FirstOrDefault()?.Id, zones: zones, osDiskSizeInGB: osDiskSizeInGB,
machineSizeType: machineSizeType, enableUltraSSD: enableUltraSSD, diskEncryptionSetId: diskEncryptionSetId, automaticRepairsPolicy: automaticRepairsPolicy,
bootDiagnosticsProfile: bootDiagnosticsProfile, faultDomainCount: faultDomainCount, capacity: capacity, hardwareProfile: hardwareProfile);
if (vmScaleSetCustomizer != null)
{
vmScaleSetCustomizer(inputVMScaleSet);
}
if (encryptionAtHostEnabled != null)
{
inputVMScaleSet.VirtualMachineProfile.SecurityProfile = new SecurityProfile
{
EncryptionAtHost = encryptionAtHostEnabled.Value
};
}
inputVMScaleSet.VirtualMachineProfile.UserData = userData;
if (hasDiffDisks)
{
VirtualMachineScaleSetOSDisk osDisk = new VirtualMachineScaleSetOSDisk();
osDisk.Caching = CachingTypes.ReadOnly;
osDisk.CreateOption = DiskCreateOptionTypes.FromImage;
osDisk.DiffDiskSettings = new DiffDiskSettings {
Option = DiffDiskOptions.Local,
Placement = DiffDiskPlacement.CacheDisk
};
inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk = osDisk;
}
inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile;
if (ppgId != null)
{
inputVMScaleSet.ProximityPlacementGroup = new Microsoft.Azure.Management.Compute.Models.SubResource()
{
Id = ppgId
};
}
if (dedicatedHostGroupReferenceId != null)
{
CreateDedicatedHostGroup(rgName, dedicatedHostGroupName, availabilityZone: null);
CreateDedicatedHost(rgName, dedicatedHostGroupName, dedicatedHostName, "DSv3-Type1");
inputVMScaleSet.HostGroup = new CM.SubResource()
{
Id = dedicatedHostGroupReferenceId
};
}
if (!string.IsNullOrEmpty(capacityReservationGroupReferenceId))
{
inputVMScaleSet.VirtualMachineProfile.CapacityReservation = new CapacityReservationProfile
{
CapacityReservationGroup = new CM.SubResource
{
Id = capacityReservationGroupReferenceId
}
};
}
inputVMScaleSet.SinglePlacementGroup = singlePlacementGroup ? (bool?)null : false;
VirtualMachineScaleSet createOrUpdateResponse = null;
try
{
createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.CreateOrUpdate(rgName, vmssName, inputVMScaleSet);
Assert.True(createOrUpdateResponse.Name == vmssName);
Assert.True(createOrUpdateResponse.Location.ToLower() == inputVMScaleSet.Location.ToLower().Replace(" ", ""));
}
catch (CloudException e)
{
if (e.Message.Contains("the allotted time"))
{
createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName);
}
else
{
throw;
}
}
ValidateVMScaleSet(inputVMScaleSet, createOrUpdateResponse, createWithManagedDisks, ppgId: ppgId, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId);
return(createOrUpdateResponse);
}
protected VirtualMachineScaleSet CreateDefaultVMScaleSetInput(
string rgName,
string storageAccountName,
ImageReference imageRef,
string subnetId,
bool hasManagedDisks = false,
string healthProbeId = null,
string loadBalancerBackendPoolId = null,
IList <string> zones = null,
int?osDiskSizeInGB = null,
string machineSizeType = null,
bool?enableUltraSSD = false,
string diskEncryptionSetId = null,
AutomaticRepairsPolicy automaticRepairsPolicy = null,
DiagnosticsProfile bootDiagnosticsProfile = null,
int?faultDomainCount = null,
int?capacity = null,
VirtualMachineScaleSetHardwareProfile hardwareProfile = null)
{
// Generate Container name to hold disk VHds
string containerName = TestUtilities.GenerateName(TestPrefix);
var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName;
var vmssName = TestUtilities.GenerateName("vmss");
bool createOSDisk = !hasManagedDisks || osDiskSizeInGB != null;
string vmSize = zones == null ? VirtualMachineSizeTypes.StandardA1V2 : VirtualMachineSizeTypes.StandardA1V2;
var vmScaleSet = new VirtualMachineScaleSet()
{
Location = m_location,
Tags = new Dictionary <string, string>()
{
{ "RG", "rg" }, { "testTag", "1" }
},
Sku = new CM.Sku()
{
Capacity = capacity ?? 2,
Name = machineSizeType == null ? vmSize : machineSizeType
},
Zones = zones,
Overprovision = false,
UpgradePolicy = new UpgradePolicy()
{
Mode = UpgradeMode.Automatic
},
VirtualMachineProfile = new VirtualMachineScaleSetVMProfile()
{
StorageProfile = new VirtualMachineScaleSetStorageProfile()
{
ImageReference = imageRef,
OsDisk = !createOSDisk ? null : new VirtualMachineScaleSetOSDisk
{
Caching = CachingTypes.None,
CreateOption = DiskCreateOptionTypes.FromImage,
Name = hasManagedDisks ? null : "test",
VhdContainers = hasManagedDisks ? null : new List <string> {
vhdContainer
},
DiskSizeGB = osDiskSizeInGB,
ManagedDisk = diskEncryptionSetId == null ? null: new VirtualMachineScaleSetManagedDiskParameters()
{
StorageAccountType = StorageAccountTypes.StandardLRS,
DiskEncryptionSet = new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
}
}
},
DataDisks = !hasManagedDisks ? null : new List <VirtualMachineScaleSetDataDisk>
{
new VirtualMachineScaleSetDataDisk
{
Lun = 1,
CreateOption = DiskCreateOptionTypes.Empty,
DiskSizeGB = 128,
ManagedDisk = diskEncryptionSetId == null ? null: new VirtualMachineScaleSetManagedDiskParameters()
{
StorageAccountType = StorageAccountTypes.StandardLRS,
DiskEncryptionSet = new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
}
}
}
}
},
HardwareProfile = hardwareProfile,
OsProfile = new VirtualMachineScaleSetOSProfile()
{
ComputerNamePrefix = "test",
AdminUsername = "******",
AdminPassword = PLACEHOLDER,
CustomData = Convert.ToBase64String(Encoding.UTF8.GetBytes("Custom data"))
},
NetworkProfile = new VirtualMachineScaleSetNetworkProfile()
{
HealthProbe = healthProbeId == null ? null : new ApiEntityReference
{
Id = healthProbeId
},
NetworkInterfaceConfigurations = new List <VirtualMachineScaleSetNetworkConfiguration>()
{
new VirtualMachineScaleSetNetworkConfiguration()
{
Name = TestUtilities.GenerateName("vmsstestnetconfig"),
Primary = true,
IpConfigurations = new List <VirtualMachineScaleSetIPConfiguration>
{
new VirtualMachineScaleSetIPConfiguration()
{
Name = TestUtilities.GenerateName("vmsstestnetconfig"),
Subnet = new Microsoft.Azure.Management.Compute.Models.ApiEntityReference()
{
Id = subnetId
},
LoadBalancerBackendAddressPools = (loadBalancerBackendPoolId != null) ?
new List <Microsoft.Azure.Management.Compute.Models.SubResource> {
new Microsoft.Azure.Management.Compute.Models.SubResource(loadBalancerBackendPoolId)
} : null,
ApplicationGatewayBackendAddressPools = new List <Microsoft.Azure.Management.Compute.Models.SubResource>(),
}
}
}
}
},
ExtensionProfile = new VirtualMachineScaleSetExtensionProfile(),
},
AutomaticRepairsPolicy = automaticRepairsPolicy
};
if (bootDiagnosticsProfile != null)
{
vmScaleSet.VirtualMachineProfile.DiagnosticsProfile = bootDiagnosticsProfile;
}
if (faultDomainCount != null)
{
vmScaleSet.PlatformFaultDomainCount = faultDomainCount;
}
if (enableUltraSSD == true)
{
vmScaleSet.AdditionalCapabilities = new AdditionalCapabilities
{
UltraSSDEnabled = true
};
VirtualMachineScaleSetOSDisk osDisk = vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk;
osDisk.ManagedDisk = osDisk.ManagedDisk ?? new VirtualMachineScaleSetManagedDiskParameters();
osDisk.ManagedDisk.StorageAccountType = StorageAccountTypes.PremiumLRS;
foreach (VirtualMachineScaleSetDataDisk dataDisk in vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks)
{
dataDisk.ManagedDisk = dataDisk.ManagedDisk ?? new VirtualMachineScaleSetManagedDiskParameters();
dataDisk.ManagedDisk.StorageAccountType = StorageAccountTypes.UltraSSDLRS;
}
}
return(vmScaleSet);
}
public VirtualMachineScaleSet CreateVMScaleSet_NoAsyncTracking(
string rgName,
string vmssName,
StorageAccount storageAccount,
ImageReference imageRef,
out VirtualMachineScaleSet inputVMScaleSet,
VirtualMachineScaleSetExtensionProfile extensionProfile = null,
Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null,
bool createWithPublicIpAddress = false,
bool createWithManagedDisks = false,
bool hasDiffDisks = false,
bool createWithHealthProbe = false,
Subnet subnet = null,
IList <string> zones = null,
int?osDiskSizeInGB = null,
string ppgId = null,
string machineSizeType = null,
bool?enableUltraSSD = false,
string diskEncryptionSetId = null,
AutomaticRepairsPolicy automaticRepairsPolicy = null,
bool?encryptionAtHostEnabled = null,
bool singlePlacementGroup = true,
DiagnosticsProfile bootDiagnosticsProfile = null,
int?faultDomainCount = null,
int?capacity = null,
string dedicatedHostGroupReferenceId = null,
string dedicatedHostGroupName = null,
string dedicatedHostName = null,
string userData = null,
string capacityReservationGroupReferenceId = null,
VirtualMachineScaleSetHardwareProfile hardwareProfile = null)
{
try
{
var createOrUpdateResponse = CreateVMScaleSetAndGetOperationResponse(rgName,
vmssName,
storageAccount,
imageRef,
out inputVMScaleSet,
extensionProfile,
vmScaleSetCustomizer,
createWithPublicIpAddress,
createWithManagedDisks,
hasDiffDisks,
createWithHealthProbe,
subnet,
zones,
osDiskSizeInGB,
ppgId: ppgId,
machineSizeType: machineSizeType,
enableUltraSSD: enableUltraSSD,
diskEncryptionSetId: diskEncryptionSetId,
automaticRepairsPolicy: automaticRepairsPolicy,
encryptionAtHostEnabled: encryptionAtHostEnabled,
singlePlacementGroup: singlePlacementGroup,
bootDiagnosticsProfile: bootDiagnosticsProfile,
faultDomainCount: faultDomainCount,
capacity: capacity,
dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId,
dedicatedHostGroupName: dedicatedHostGroupName,
dedicatedHostName: dedicatedHostName,
userData: userData,
capacityReservationGroupReferenceId: capacityReservationGroupReferenceId,
hardwareProfile: hardwareProfile);
var getResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName);
return(getResponse);
}
catch
{
// TODO: It is better to issue Delete and forget.
m_ResourcesClient.ResourceGroups.Delete(rgName);
throw;
}
}
private void TestScaleSetOperationsInternal(MockContext context, string vmSize = null, bool hasManagedDisks = false, bool useVmssExtension = true,
bool hasDiffDisks = false, IList <string> zones = null, int?osDiskSizeInGB = null, bool isPpgScenario = false, bool?enableUltraSSD = false,
Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null, Action <VirtualMachineScaleSet> vmScaleSetValidator = null, string diskEncryptionSetId = null,
bool?encryptionAtHostEnabled = null, bool isAutomaticPlacementOnDedicatedHostGroupScenario = false,
int?faultDomainCount = null, int?capacity = null, bool shouldOverProvision = true, bool validateVmssVMInstanceView = false,
ImageReference imageReference = null, bool validateListSku = true, bool deleteAsPartOfTest = true,
bool associateWithCapacityReservationGroup = false, VirtualMachineScaleSetHardwareProfile hardwareProfile = null)
{
EnsureClientsInitialized(context);
ImageReference imageRef = imageReference ?? GetPlatformVMImage(useWindowsImage: true);
// Create resource group
var rgName = TestUtilities.GenerateName(TestPrefix);
var vmssName = TestUtilities.GenerateName("vmss");
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
VirtualMachineScaleSet inputVMScaleSet;
VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new List <VirtualMachineScaleSetExtension>()
{
GetTestVMSSVMExtension(autoUpdateMinorVersion: false),
}
};
try
{
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, "VMScaleSetDoesNotExist");
string ppgId = null;
string ppgName = null;
if (isPpgScenario)
{
ppgName = ComputeManagementTestUtilities.GenerateName("ppgtest");
ppgId = CreateProximityPlacementGroup(rgName, ppgName);
}
string dedicatedHostGroupName = null, dedicatedHostName = null, dedicatedHostGroupReferenceId = null, dedicatedHostReferenceId = null;
if (isAutomaticPlacementOnDedicatedHostGroupScenario)
{
dedicatedHostGroupName = ComputeManagementTestUtilities.GenerateName("dhgtest");
dedicatedHostName = ComputeManagementTestUtilities.GenerateName("dhtest");
dedicatedHostGroupReferenceId = Helpers.GetDedicatedHostGroupRef(m_subId, rgName, dedicatedHostGroupName);
dedicatedHostReferenceId = Helpers.GetDedicatedHostRef(m_subId, rgName, dedicatedHostGroupName, dedicatedHostName);
}
bool singlePlacementGroup = true;
string capacityReservationGroupName = null, capacityReservationGroupReferenceId = null, capacityReservationName = null;
if (associateWithCapacityReservationGroup)
{
capacityReservationGroupName = ComputeManagementTestUtilities.GenerateName("crgtest");
capacityReservationName = ComputeManagementTestUtilities.GenerateName("crtest");
CreateCapacityReservationGroup(rgName, capacityReservationGroupName);
CreateCapacityReservation(rgName, capacityReservationGroupName, capacityReservationName, VirtualMachineSizeTypes.StandardDS1V2, reservedCount: 1);
capacityReservationGroupReferenceId = Helpers.GetCapacityReservationGroupRef(m_subId, rgName, capacityReservationGroupName);
singlePlacementGroup = false;
}
VirtualMachineScaleSet getResponse = CreateVMScaleSet_NoAsyncTracking(
rgName,
vmssName,
storageAccountOutput,
imageRef,
out inputVMScaleSet,
useVmssExtension ? extensionProfile : null,
(vmScaleSet) => {
vmScaleSet.Overprovision = shouldOverProvision;
if (!String.IsNullOrEmpty(vmSize))
{
vmScaleSet.Sku.Name = vmSize;
}
vmScaleSetCustomizer?.Invoke(vmScaleSet);
},
createWithManagedDisks: hasManagedDisks,
hasDiffDisks: hasDiffDisks,
zones: zones,
osDiskSizeInGB: osDiskSizeInGB,
ppgId: ppgId,
enableUltraSSD: enableUltraSSD,
diskEncryptionSetId: diskEncryptionSetId,
encryptionAtHostEnabled: encryptionAtHostEnabled,
faultDomainCount: faultDomainCount,
capacity: capacity,
dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId,
dedicatedHostGroupName: dedicatedHostGroupName,
dedicatedHostName: dedicatedHostName,
capacityReservationGroupReferenceId: capacityReservationGroupReferenceId,
singlePlacementGroup: singlePlacementGroup,
hardwareProfile: hardwareProfile);
if (diskEncryptionSetId != null)
{
Assert.True(getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet != null, "OsDisk.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"OsDisk.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
Assert.Equal(1, getResponse.VirtualMachineProfile.StorageProfile.DataDisks.Count);
Assert.True(getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet != null, ".DataDisks.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"DataDisks.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
}
if (!string.IsNullOrEmpty(capacityReservationGroupReferenceId))
{
Assert.True(getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup != null, "CapacityReservation.CapacityReservationGroup is null");
Assert.True(string.Equals(capacityReservationGroupReferenceId, getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup.Id, StringComparison.OrdinalIgnoreCase),
"CapacityReservation.CapacityReservationGroup.Id is not matching with expected CapacityReservationGroup resource");
CapacityReservation capacityReservation =
m_CrpClient.CapacityReservations.Get(rgName, capacityReservationGroupName, capacityReservationName, CapacityReservationInstanceViewTypes.InstanceView);
var queryForVmssVM = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
queryForVmssVM.SetFilter(vm => vm.LatestModelApplied == true);
var listVmssVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, queryForVmssVM);
string expectedVMReferenceId = Helpers.GetVMScaleSetVMReferenceId(m_subId, rgName, vmssName, listVmssVMsResponse.First().InstanceId);
Assert.True(capacityReservation.VirtualMachinesAssociated.Any(), "capacityReservation.VirtualMachinesAssociated is not empty");
Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.VirtualMachinesAssociated.First().Id, StringComparison.OrdinalIgnoreCase),
"capacityReservation.VirtualMachinesAssociated are not matching");
/*
* Assert.True(capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.Any(), "InstanceView.UtilizationInfo.VirtualMachinesAllocated is empty");
* Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.First().Id),
* "InstanceView.UtilizationInfo.VirtualMachinesAllocated are not matching");
*/
}
if (encryptionAtHostEnabled != null)
{
Assert.True(getResponse.VirtualMachineProfile.SecurityProfile.EncryptionAtHost == encryptionAtHostEnabled.Value,
"SecurityProfile.EncryptionAtHost is not same as expected");
}
ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks, ppgId: ppgId, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId);
var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSets.GetInstanceView(rgName, vmssName);
Assert.NotNull(getInstanceViewResponse);
ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse);
if (isPpgScenario)
{
ProximityPlacementGroup outProximityPlacementGroup = m_CrpClient.ProximityPlacementGroups.Get(rgName, ppgName);
Assert.Equal(1, outProximityPlacementGroup.VirtualMachineScaleSets.Count);
string expectedVmssReferenceId = Helpers.GetVMScaleSetReferenceId(m_subId, rgName, vmssName);
Assert.Equal(expectedVmssReferenceId, outProximityPlacementGroup.VirtualMachineScaleSets.First().Id, StringComparer.OrdinalIgnoreCase);
}
var listResponse = m_CrpClient.VirtualMachineScaleSets.List(rgName);
ValidateVMScaleSet(inputVMScaleSet, listResponse.FirstOrDefault(x => x.Name == vmssName), hasManagedDisks);
if (validateListSku)
{
var listSkusResponse = m_CrpClient.VirtualMachineScaleSets.ListSkus(rgName, vmssName);
Assert.NotNull(listSkusResponse);
Assert.False(listSkusResponse.Count() == 0);
}
if (zones != null)
{
var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
query.SetFilter(vm => vm.LatestModelApplied == true);
var listVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query);
Assert.False(listVMsResponse == null, "VMScaleSetVMs not returned");
Assert.True(listVMsResponse.Count() == inputVMScaleSet.Sku.Capacity);
foreach (var vmScaleSetVM in listVMsResponse)
{
string instanceId = vmScaleSetVM.InstanceId;
var getVMResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmssName, instanceId);
ValidateVMScaleSetVM(inputVMScaleSet, instanceId, getVMResponse, hasManagedDisks);
}
}
if (validateVmssVMInstanceView)
{
VirtualMachineScaleSetVMInstanceView vmssVMInstanceView = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmssName, "0");
ValidateVMScaleSetVMInstanceView(vmssVMInstanceView, hasManagedDisks, dedicatedHostReferenceId);
}
vmScaleSetValidator?.Invoke(getResponse);
if (deleteAsPartOfTest)
{
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName);
}
}
finally
{
if (deleteAsPartOfTest)
{
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
else
{
// Fire and forget. No need to wait for RG deletion completion
m_ResourcesClient.ResourceGroups.BeginDelete(rgName);
}
}
}
