private void GetProfiles(
out VirtualMachineScaleSetExtensionProfile vmExtProfile,
out VirtualMachineScaleSetOSProfile osProfile,
out VirtualMachineScaleSetStorageProfile storageProfile,
out VirtualMachineScaleSetNetworkProfile networkProfile)
{
vmExtProfile = null;
osProfile = null;
storageProfile = null;
networkProfile = null;
VirtualMachineScaleSetExtension existingFabircExtension = null;
VirtualMachineScaleSetExtension diagnosticsVmExt = null;
VirtualMachineScaleSetStorageProfile existingStorageProfile = null;
VirtualMachineScaleSetNetworkProfile existingNetworkProfile = null;
var vms = ComputeClient.VirtualMachineScaleSets.List(this.ResourceGroupName);
if (vms != null)
{
foreach (var vm in vms)
{
var ext = vm.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(
e =>
string.Equals(
e.Type,
Constants.ServiceFabricWindowsNodeExtName,
StringComparison.OrdinalIgnoreCase));
// Try to get Linux ext
if (ext == null)
{
ext = vm.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(
e =>
e.Type.Equals(
Constants.ServiceFabricLinuxNodeExtName,
StringComparison.OrdinalIgnoreCase));
}
if (ext != null)
{
existingFabircExtension = ext;
osProfile = vm.VirtualMachineProfile.OsProfile;
existingStorageProfile = vm.VirtualMachineProfile.StorageProfile;
existingNetworkProfile = vm.VirtualMachineProfile.NetworkProfile;
}
ext = vm.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(
e =>
e.Type.Equals(Constants.IaaSDiagnostics, StringComparison.OrdinalIgnoreCase));
if (ext != null)
{
diagnosticsVmExt = ext;
break;
}
}
}
if (existingFabircExtension == null || existingStorageProfile == null || existingNetworkProfile == null)
{
throw new NotSupportedException("The resource group should have at least one valid vmext for service fabric");
}
osProfile = GetOsProfile(osProfile);
storageProfile = GetStorageProfile(existingStorageProfile);
networkProfile = CreateNetworkResource(existingNetworkProfile.NetworkInterfaceConfigurations.FirstOrDefault());
existingFabircExtension.Name = string.Format("{0}_ServiceFabricNode", this.NodeType);
existingFabircExtension = GetFabriExtension(existingFabircExtension);
if (diagnosticsVmExt != null)
{
diagnosticsVmExt.Name = string.Format("{0}_VMDiagnosticsVmExt", this.NodeType);
diagnosticsVmExt = GetDiagnosticsExtension(diagnosticsVmExt);
vmExtProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new[] { existingFabircExtension, diagnosticsVmExt }
};
}
else
{
vmExtProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new[] { existingFabircExtension }
};
}
}
protected void ValidateVmssExtension(VirtualMachineScaleSetExtension vmssExtension, VirtualMachineScaleSetExtension vmssExtensionOut)
{
Assert.NotNull(vmssExtensionOut);
Assert.True(!string.IsNullOrEmpty(vmssExtensionOut.ProvisioningState));
Assert.True(vmssExtension.Publisher == vmssExtensionOut.Publisher);
Assert.True(vmssExtension.Type == vmssExtensionOut.Type);
Assert.True(vmssExtension.AutoUpgradeMinorVersion == vmssExtensionOut.AutoUpgradeMinorVersion);
Assert.True(vmssExtension.TypeHandlerVersion == vmssExtensionOut.TypeHandlerVersion);
Assert.True(vmssExtension.Settings.ToString() == vmssExtensionOut.Settings.ToString());
Assert.True(vmssExtension.ForceUpdateTag == vmssExtensionOut.ForceUpdateTag);
if (vmssExtension.ProvisionAfterExtensions != null)
{
Assert.True(vmssExtension.ProvisionAfterExtensions.Count == vmssExtensionOut.ProvisionAfterExtensions.Count);
for (int i = 0; i < vmssExtension.ProvisionAfterExtensions.Count; i++)
{
Assert.True(vmssExtension.ProvisionAfterExtensions[i] == vmssExtensionOut.ProvisionAfterExtensions[i]);
}
}
}
public void TestVMScaleSetExtensionSequencing()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create resource group
string rgName = TestUtilities.GenerateName(TestPrefix) + 1;
var vmssName = TestUtilities.GenerateName("vmss");
VirtualMachineScaleSet inputVMScaleSet;
try
{
EnsureClientsInitialized(context);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: false);
VirtualMachineScaleSetExtensionProfile vmssExtProfile = GetTestVmssExtensionProfile();
// Set extension sequencing (ext2 is provisioned after ext1)
vmssExtProfile.Extensions[1].ProvisionAfterExtensions = new List <string> {
vmssExtProfile.Extensions[0].Name
};
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName,
vmssName,
null,
imageRef,
out inputVMScaleSet,
extensionProfile: vmssExtProfile,
createWithManagedDisks: true);
// Perform a Get operation on each extension
VirtualMachineScaleSetExtension getVmssExtResponse = null;
for (int i = 0; i < vmssExtProfile.Extensions.Count; i++)
{
getVmssExtResponse = m_CrpClient.VirtualMachineScaleSetExtensions.Get(rgName, vmssName, vmssExtProfile.Extensions[i].Name);
ValidateVmssExtension(vmssExtProfile.Extensions[i], getVmssExtResponse);
}
// Add a new extension to the VMSS (ext3 is provisioned after ext2)
VirtualMachineScaleSetExtension vmssExtension = GetTestVMSSVMExtension(name: "3", publisher: "Microsoft.CPlat.Core", type: "NullLinux", version: "4.0");
vmssExtension.ProvisionAfterExtensions = new List <string> {
vmssExtProfile.Extensions[1].Name
};
var response = m_CrpClient.VirtualMachineScaleSetExtensions.CreateOrUpdate(rgName, vmssName, vmssExtension.Name, vmssExtension);
ValidateVmssExtension(vmssExtension, response);
// Perform a Get operation on the extension
getVmssExtResponse = m_CrpClient.VirtualMachineScaleSetExtensions.Get(rgName, vmssName, vmssExtension.Name);
ValidateVmssExtension(vmssExtension, getVmssExtResponse);
// Clear the sequencing in ext3
vmssExtension.ProvisionAfterExtensions.Clear();
var patchVmssExtsResponse = m_CrpClient.VirtualMachineScaleSetExtensions.CreateOrUpdate(rgName, vmssName, vmssExtension.Name, vmssExtension);
ValidateVmssExtension(vmssExtension, patchVmssExtsResponse);
// Perform a List operation on vmss extensions
var listVmssExtsResponse = m_CrpClient.VirtualMachineScaleSetExtensions.List(rgName, vmssName);
int installedExtensionsCount = listVmssExtsResponse.Count();
Assert.Equal(3, installedExtensionsCount);
VirtualMachineScaleSetExtension expectedVmssExt = null;
for (int i = 0; i < installedExtensionsCount; i++)
{
if (i < installedExtensionsCount - 1)
{
expectedVmssExt = vmssExtProfile.Extensions[i];
}
else
{
expectedVmssExt = vmssExtension;
}
ValidateVmssExtension(expectedVmssExt, listVmssExtsResponse.ElementAt(i));
}
}
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);
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (this.ShouldProcess(VMScaleSetName, Properties.Resources.RemoveDiskEncryptionAction) &&
(this.Force.IsPresent ||
this.ShouldContinue(Properties.Resources.VirtualMachineExtensionRemovalConfirmation, Properties.Resources.VirtualMachineExtensionRemovalCaption)))
{
VirtualMachineScaleSet vmss = this.VirtualMachineScaleSetClient.Get(this.ResourceGroupName, this.VMScaleSetName);
if (vmss == null || vmss.VirtualMachineProfile == null)
{
ThrowTerminatingError(new ErrorRecord(
new ArgumentException("The given VM Scale Set does not exist."),
"InvalidArgument",
ErrorCategory.InvalidArgument,
null));
}
SetOSType(vmss.VirtualMachineProfile);
if (OperatingSystemTypes.Windows.Equals(this.CurrentOSType))
{
this.ExtensionName = this.ExtensionName ?? AzureVmssDiskEncryptionExtensionContext.ExtensionDefaultName;
}
else if (OperatingSystemTypes.Linux.Equals(this.CurrentOSType))
{
this.ExtensionName = this.ExtensionName ?? AzureVmssDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
}
this.VolumeType = GetVolumeType(this.VolumeType, vmss.VirtualMachineProfile.StorageProfile);
if (vmss.VirtualMachineProfile.ExtensionProfile == null ||
vmss.VirtualMachineProfile.ExtensionProfile.Extensions == null ||
vmss.VirtualMachineProfile.ExtensionProfile.Extensions.Count == 0)
{
ThrowTerminatingError(new ErrorRecord(
new ArgumentException("Disk Encryption extension is not installed in the VM Scale Set."),
"InvalidArgument",
ErrorCategory.InvalidArgument,
null));
}
foreach (var ext in vmss.VirtualMachineProfile.ExtensionProfile.Extensions)
{
if (ext.Name.Equals(this.ExtensionName))
{
ext.Settings = GetDisalbeEncryptionSetting();
ext.ProtectedSettings = null;
ext.ForceUpdateTag = this.ForceUpdate.IsPresent ? Guid.NewGuid().ToString() : null;
VirtualMachineScaleSetExtension result = this.VirtualMachineScaleSetExtensionsClient.CreateOrUpdate(
this.ResourceGroupName,
this.VMScaleSetName,
this.ExtensionName,
ext);
var psResult = result.ToPSVirtualMachineScaleSetExtension(this.ResourceGroupName, this.VMScaleSetName);
WriteObject(psResult);
break;
}
ThrowTerminatingError(new ErrorRecord(
new ArgumentException(string.Format("Extension, {0}, is not installed in the VM Scale Set.", this.ExtensionName)),
"InvalidArgument",
ErrorCategory.InvalidArgument,
null));
}
}
});
}
/// <summary>
/// Check if a VMSS extension is diagnostics extension.
/// </summary>
/// <param name="extension">VMSS extension</param>
/// <returns>Whether the VMSS extension is diagnostics extension</returns>
public static bool IsDiagnosticsExtension(VirtualMachineScaleSetExtension extension)
{
return(extension.Publisher.Equals(DiagnosticsExtensionConstants.ExtensionPublisher, StringComparison.InvariantCultureIgnoreCase) &&
extension.Type.Equals(DiagnosticsExtensionConstants.ExtensionType, StringComparison.InvariantCultureIgnoreCase));
}
internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string vmScaleSetName, string vmssExtensionName, VirtualMachineScaleSetExtension 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("/extensions/", false);
uri.AppendPath(vmssExtensionName, 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 bool TryGetFabricVmExt(IList <VirtualMachineScaleSetExtension> extensions, out VirtualMachineScaleSetExtension sfExtension)
{
var extConfigs = extensions.Where(
e => e.Type.Equals(
Constants.ServiceFabricWindowsNodeExtName, StringComparison.OrdinalIgnoreCase));
if (!extConfigs.Any())
{
extConfigs = extensions.Where(
e => e.Type.Equals(Constants.ServiceFabricLinuxNodeExtName, StringComparison.OrdinalIgnoreCase));
sfExtension = null;
return(false);
}
sfExtension = extConfigs.First();
return(true);
}
internal string GetSettingFromExtension(VirtualMachineScaleSetExtension sfExtension, string settingName)
{
JObject extSettings = sfExtension.Settings as JObject;
return((string)extSettings.SelectToken(settingName));
}
private bool IsSFExtension(VirtualMachineScaleSetExtension vmssExt)
{
return(vmssExt.Type.Equals(Constants.ServiceFabricWindowsNodeExtName, StringComparison.OrdinalIgnoreCase) ||
vmssExt.Type.Equals(Constants.ServiceFabricLinuxNodeExtName, StringComparison.OrdinalIgnoreCase) ||
(vmssExt.Type.Contains(Constants.ServiceFabricExtNamePrefix) && vmssExt.Type.Contains(Constants.ServiceFabricExtNameSuffix)));
}
public string GetNodeTypeRefFromExtension(VirtualMachineScaleSetExtension sfExtension)
{
return(GetSettingFromExtension(sfExtension, "nodeTypeRef"));
}
public string GetDurabilityLevelFromExtension(VirtualMachineScaleSetExtension sfExtension)
{
return(GetSettingFromExtension(sfExtension, "durabilityLevel"));
}
public bool TryGetFabricVmExt(IList <VirtualMachineScaleSetExtension> extensions, out VirtualMachineScaleSetExtension sfExtension)
{
if (extensions == null)
{
sfExtension = null;
return(false);
}
sfExtension = extensions.FirstOrDefault(ext => IsSFExtension(ext));
return(sfExtension != null);
}
internal void GetProfiles(
string clusterId,
out VirtualMachineScaleSetExtensionProfile vmExtProfile,
out VirtualMachineScaleSetOSProfile osProfile,
out VirtualMachineScaleSetStorageProfile storageProfile,
out VirtualMachineScaleSetNetworkProfile networkProfile)
{
vmExtProfile = null;
osProfile = null;
storageProfile = null;
networkProfile = null;
VirtualMachineScaleSetExtension existingFabricExtension = null;
VirtualMachineScaleSetExtension diagnosticsVmExt = null;
VirtualMachineScaleSetStorageProfile existingStorageProfile = null;
VirtualMachineScaleSetNetworkProfile existingNetworkProfile = null;
var vmssPages = ComputeClient.VirtualMachineScaleSets.List(this.ResourceGroupName);
if (vmssPages == null || !vmssPages.Any())
{
throw new PSArgumentException(string.Format(
ServiceFabricProperties.Resources.NoVMSSFoundInRG,
this.ResourceGroupName));
}
do
{
if (!vmssPages.Any())
{
break;
}
foreach (var vmss in vmssPages)
{
VirtualMachineScaleSetExtension sfExtension;
// Future: For hybrid clusters, would need to make extension retrieval specifically Windows/Linux-targeted /w override for initial creation.
// New node type for OS that is not yet in the cluster should be created using defaults from one of the sample templates.
if (TryGetFabricVmExt(vmss.VirtualMachineProfile.ExtensionProfile?.Extensions, out sfExtension))
{
if (string.Equals(GetClusterIdFromExtension(sfExtension), clusterId, StringComparison.OrdinalIgnoreCase))
{
WriteVerboseWithTimestamp(string.Format("GetProfiles: Found vmss {0} that corresponds to cluster id {1}", vmss.Id, clusterId));
osProfile = vmss.VirtualMachineProfile.OsProfile;
existingStorageProfile = vmss.VirtualMachineProfile.StorageProfile;
existingNetworkProfile = vmss.VirtualMachineProfile.NetworkProfile;
if (existingStorageProfile == null || existingNetworkProfile == null)
{
WriteVerboseWithTimestamp(string.Format("GetProfiles: Unable to get storageProfile and/or NetworkProfile from vmss id: {0}", vmss.Id));
continue;
}
existingFabricExtension = sfExtension;
diagnosticsVmExt = vmss.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(
e =>
e.Type.Equals(Constants.IaaSDiagnostics, StringComparison.OrdinalIgnoreCase) || e.Type.Equals(Constants.LinuxDiagnostic, StringComparison.OrdinalIgnoreCase));
break;
}
}
}
} while (existingFabricExtension == null && !string.IsNullOrEmpty(vmssPages.NextPageLink) &&
(vmssPages = this.ComputeClient.VirtualMachineScaleSets.ListNext(vmssPages.NextPageLink)) != null);
if (existingFabricExtension == null)
{
throw new InvalidOperationException(string.Format(ServiceFabricProperties.Resources.VmExtensionNotFound, ResourceGroupName, clusterId));
}
osProfile = GetOsProfile(osProfile);
storageProfile = GetStorageProfile(existingStorageProfile);
networkProfile = CreateNetworkResource(existingNetworkProfile.NetworkInterfaceConfigurations.FirstOrDefault());
existingFabricExtension.Name = string.Format("{0}_ServiceFabricNode", this.NodeType);
existingFabricExtension = GetFabricExtension(existingFabricExtension);
if (diagnosticsVmExt != null)
{
diagnosticsVmExt.Name = string.Format("{0}_VMDiagnosticsVmExt", this.NodeType);
diagnosticsVmExt = GetDiagnosticsExtension(diagnosticsVmExt);
vmExtProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new[] { existingFabricExtension, diagnosticsVmExt }
};
}
else
{
vmExtProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new[] { existingFabricExtension }
};
}
}
public virtual VirtualMachineScaleSetExtensionsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string vmScaleSetName, string vmssExtensionName, VirtualMachineScaleSetExtension extensionParameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (vmScaleSetName == null)
{
throw new ArgumentNullException(nameof(vmScaleSetName));
}
if (vmssExtensionName == null)
{
throw new ArgumentNullException(nameof(vmssExtensionName));
}
if (extensionParameters == null)
{
throw new ArgumentNullException(nameof(extensionParameters));
}
using var scope = _clientDiagnostics.CreateScope("VirtualMachineScaleSetExtensionsClient.StartCreateOrUpdate");
scope.Start();
try
{
var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, vmScaleSetName, vmssExtensionName, extensionParameters, cancellationToken);
return(new VirtualMachineScaleSetExtensionsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, vmScaleSetName, vmssExtensionName, extensionParameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
protected override void ProcessRecord()
{
if (ShouldProcess(this.VirtualMachineScaleSet.Name, Properties.Resources.AddVmssDiagnosticsExtensionAction))
{
// VirtualMachineProfile
if (this.VirtualMachineScaleSet.VirtualMachineProfile == null)
{
this.VirtualMachineScaleSet.VirtualMachineProfile = new VirtualMachineScaleSetVMProfile();
}
// ExtensionProfile
if (this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile == null)
{
this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile = new VirtualMachineScaleSetExtensionProfile();
}
// Extensions
if (this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions == null)
{
this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions = new List <VirtualMachineScaleSetExtension>();
}
bool shouldContinue = true;
// Warning if there's already a diagnostics extension.
var extensions = this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions;
if (extensions.Any(DiagnosticsHelper.IsDiagnosticsExtension))
{
if (Force.IsPresent ||
ShouldContinue(Properties.Resources.DiagnosticsExtensionOverwrittingConfirmation, Properties.Resources.DiagnosticsExtensionOverwrittingCaption))
{
WriteWarning(Properties.Resources.DiagnosticsExtensionOverwriting);
// Remove all existing diagnostics extensions
this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions = extensions.Where(extension => !DiagnosticsHelper.IsDiagnosticsExtension(extension)).ToList();
}
else
{
shouldContinue = false;
}
}
if (shouldContinue)
{
var storageClient = AzureSession.Instance.ClientFactory.CreateArmClient <StorageManagementClient>(DefaultProfile.DefaultContext, AzureEnvironment.Endpoint.ResourceManager);
// Parse configs, and auto fill incomplete parts
Tuple <Hashtable, Hashtable> settings = DiagnosticsHelper.GetConfigurationsFromFiles(this.SettingFilePath, this.ProtectedSettingFilePath, this.VirtualMachineScaleSet.Id, this, storageClient);
var newDiagnosticsExtension = new VirtualMachineScaleSetExtension();
newDiagnosticsExtension.Name = this.Name;
newDiagnosticsExtension.Publisher = DiagnosticsExtensionConstants.ExtensionPublisher;
newDiagnosticsExtension.Type = DiagnosticsExtensionConstants.ExtensionType;
newDiagnosticsExtension.TypeHandlerVersion = this.TypeHandlerVersion;
newDiagnosticsExtension.AutoUpgradeMinorVersion = this.AutoUpgradeMinorVersion;
newDiagnosticsExtension.Settings = settings.Item1;
newDiagnosticsExtension.ProtectedSettings = settings.Item2;
this.VirtualMachineScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions.Add(newDiagnosticsExtension);
}
}
WriteObject(ComputeAutomationAutoMapperProfile.Mapper.Map <PSVirtualMachineScaleSet>(this.VirtualMachineScaleSet));
}
/// <summary>
/// The operation to create or update an extension.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='vmScaleSetName'>
/// The name of the VM scale set where the extension should be create or
/// updated.
/// </param>
/// <param name='vmssExtensionName'>
/// The name of the VM scale set extension.
/// </param>
/// <param name='extensionParameters'>
/// Parameters supplied to the Create VM scale set Extension operation.
/// </param>
public static VirtualMachineScaleSetExtension CreateOrUpdate(this IVirtualMachineScaleSetExtensionsOperations operations, string resourceGroupName, string vmScaleSetName, string vmssExtensionName, VirtualMachineScaleSetExtension extensionParameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, vmScaleSetName, vmssExtensionName, extensionParameters).GetAwaiter().GetResult());
}
public Response CreateOrUpdate(string resourceGroupName, string vmScaleSetName, string vmssExtensionName, VirtualMachineScaleSetExtension extensionParameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (vmScaleSetName == null)
{
throw new ArgumentNullException(nameof(vmScaleSetName));
}
if (vmssExtensionName == null)
{
throw new ArgumentNullException(nameof(vmssExtensionName));
}
if (extensionParameters == null)
{
throw new ArgumentNullException(nameof(extensionParameters));
}
using var message = CreateCreateOrUpdateRequest(resourceGroupName, vmScaleSetName, vmssExtensionName, extensionParameters);
_pipeline.Send(message, cancellationToken);
switch (message.Response.Status)
{
case 200:
case 201:
return(message.Response);
default:
throw _clientDiagnostics.CreateRequestFailedException(message.Response);
}
}
/// <summary>
/// The operation to create or update an extension.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='vmScaleSetName'>
/// The name of the VM scale set where the extension should be create or
/// updated.
/// </param>
/// <param name='vmssExtensionName'>
/// The name of the VM scale set extension.
/// </param>
/// <param name='extensionParameters'>
/// Parameters supplied to the Create VM scale set Extension operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <VirtualMachineScaleSetExtension> CreateOrUpdateAsync(this IVirtualMachineScaleSetExtensionsOperations operations, string resourceGroupName, string vmScaleSetName, string vmssExtensionName, VirtualMachineScaleSetExtension extensionParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, vmScaleSetName, vmssExtensionName, extensionParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Check if a VMSS extension is diagnostics extension.
/// </summary>
/// <param name="extension">VMSS extension</param>
/// <returns>Whether the VMSS extension is diagnostics extension</returns>
public static bool IsDiagnosticsExtension(VirtualMachineScaleSetExtension extension)
{
return extension.Publisher.Equals(DiagnosticsExtensionConstants.ExtensionPublisher, StringComparison.InvariantCultureIgnoreCase) &&
extension.Type.Equals(DiagnosticsExtensionConstants.ExtensionType, StringComparison.InvariantCultureIgnoreCase);
}
public async Task TestVMScaleSetExtensionSequencing()
{
EnsureClientsInitialized(DefaultLocation);
// Create resource group
string rgName = Recording.GenerateAssetName(TestPrefix) + 1;
var vmssName = Recording.GenerateAssetName("vmss");
VirtualMachineScaleSet inputVMScaleSet;
ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : false);
VirtualMachineScaleSetExtensionProfile vmssExtProfile = GetTestVmssExtensionProfile();
// Set extension sequencing (ext2 is provisioned after ext1)
vmssExtProfile.Extensions[1].ProvisionAfterExtensions.Add(vmssExtProfile.Extensions[0].Name);
var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(
rgName,
vmssName,
null,
imageRef,
extensionProfile : vmssExtProfile,
createWithManagedDisks : true);
VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
// Perform a Get operation on each extension
VirtualMachineScaleSetExtension getVmssExtResponse = null;
for (int i = 0; i < vmssExtProfile.Extensions.Count; i++)
{
getVmssExtResponse = await VirtualMachineScaleSetExtensionsOperations.GetAsync(rgName, vmssName, vmssExtProfile.Extensions[i].Name);
ValidateVmssExtension(vmssExtProfile.Extensions[i], getVmssExtResponse);
}
// Add a new extension to the VMSS (ext3 is provisioned after ext2)
VirtualMachineScaleSetExtension vmssExtension = GetTestVMSSVMExtension(name: "3", publisher: "Microsoft.CPlat.Core", type: "NullLinux", version: "4.0");
vmssExtension.ProvisionAfterExtensions.Add(vmssExtProfile.Extensions[1].Name);
var response = await WaitForCompletionAsync(await VirtualMachineScaleSetExtensionsOperations.StartCreateOrUpdateAsync(rgName, vmssName, vmssExtension.Name, vmssExtension));
ValidateVmssExtension(vmssExtension, response.Value);
// Perform a Get operation on the extension
getVmssExtResponse = await VirtualMachineScaleSetExtensionsOperations.GetAsync(rgName, vmssName, vmssExtension.Name);
ValidateVmssExtension(vmssExtension, getVmssExtResponse);
// Clear the sequencing in ext3
vmssExtension.ProvisionAfterExtensions.Clear();
var patchVmssExtsResponse = await WaitForCompletionAsync(await VirtualMachineScaleSetExtensionsOperations.StartCreateOrUpdateAsync(rgName, vmssName, vmssExtension.Name, vmssExtension));
ValidateVmssExtension(vmssExtension, patchVmssExtsResponse.Value);
// Perform a List operation on vmss extensions
var listVmssExts = VirtualMachineScaleSetExtensionsOperations.ListAsync(rgName, vmssName);
var listVmssExtsResponse = await listVmssExts.ToEnumerableAsync();
int installedExtensionsCount = listVmssExtsResponse.Count();
Assert.AreEqual(3, installedExtensionsCount);
VirtualMachineScaleSetExtension expectedVmssExt = null;
for (int i = 0; i < installedExtensionsCount; i++)
{
if (i < installedExtensionsCount - 1)
{
expectedVmssExt = vmssExtProfile.Extensions[i];
}
else
{
expectedVmssExt = vmssExtension;
}
ValidateVmssExtension(expectedVmssExt, listVmssExtsResponse.ElementAt(i));
}
}