public async Task UpdateVmIdentityFromSystemUserToNone()
{
var collection = await GetVirtualMachineCollectionAsync();
var vmName = Recording.GenerateAssetName("testVM-");
var nic = await CreateBasicDependenciesOfVirtualMachineAsync();
var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id);
input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssignedUserAssigned);
var userAssignedIdentity = await CreateUserAssignedIdentityAsync();
input.Identity.UserAssignedIdentities.Add(userAssignedIdentity.Id.ToString(), new UserAssignedIdentity());
var lro = await collection.CreateOrUpdateAsync(true, vmName, input);
VirtualMachine virtualMachine = lro.Value;
Assert.AreEqual(vmName, virtualMachine.Data.Name);
Assert.AreEqual(ManagedServiceIdentityType.SystemAssignedUserAssigned, virtualMachine.Data.Identity.Type);
Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 1);
Assert.NotNull(virtualMachine.Data.Identity.PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id.ToString()].PrincipalId);
var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.None);
var updateOptions = new VirtualMachineUpdateOptions()
{
Identity = identity
};
lro = await virtualMachine.UpdateAsync(true, updateOptions);
VirtualMachine updatedVM = lro.Value;
Assert.Null(updatedVM.Data.Identity);
}
public async Task Update()
{
var vmName = Recording.GenerateAssetName("testVM-");
var vm = await CreateVirtualMachineAsync(vmName);
//// Create a PPG here and add this PPG to this virtual machine using Update
//var ppgName = Recording.GenerateAssetName("testPPG-");
//var ppgData = new ProximityPlacementGroupData(DefaultLocation) { };
//var ppgLRO = await _resourceGroup.GetProximityPlacementGroups().CreateOrUpdateAsync(ppgName, ppgData);
//var ppg = ppgLRO.Value;
// update PPG requires the VM to be deallocated
await vm.DeallocateAsync(true);
var update = new VirtualMachineUpdateOptions()
{
HardwareProfile = new HardwareProfile
{
VmSize = VirtualMachineSizeTypes.StandardF1
}
};
var lro = await vm.UpdateAsync(true, update);
VirtualMachine updatedVM = lro.Value;
Assert.AreEqual(VirtualMachineSizeTypes.StandardF1, updatedVM.Data.HardwareProfile.VmSize);
}
public async Task BootDiagnostic()
{
string vmName = Recording.GenerateAssetName("testVM-");
VirtualMachine virtualMachine = await CreateVirtualMachineAsync(vmName);
Assert.IsNull(virtualMachine.Data.BootDiagnostics);
VirtualMachineUpdateOptions updateOptions = new VirtualMachineUpdateOptions();
updateOptions.BootDiagnostics = new BootDiagnostics();
updateOptions.BootDiagnostics.Enabled = true;
virtualMachine = (await virtualMachine.UpdateAsync(true, updateOptions)).Value;
Assert.AreEqual(true, virtualMachine.Data.BootDiagnostics.Enabled);
updateOptions.BootDiagnostics = null;
virtualMachine = (await virtualMachine.UpdateAsync(true, updateOptions)).Value;
var originalBootDiag = virtualMachine.Data.BootDiagnostics;
var originalEnabled = virtualMachine.Data.BootDiagnostics?.Enabled;
string vmName2 = Recording.GenerateAssetName("testVM-");
VirtualMachine virtualMachine2 = await CreateVirtualMachineAsync(vmName2);
Assert.IsNull(virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics);
VirtualMachineUpdateOptions updateOptions2 = new VirtualMachineUpdateOptions();
updateOptions2.DiagnosticsProfile = new DiagnosticsProfile();
updateOptions2.DiagnosticsProfile.BootDiagnostics = new BootDiagnostics();
updateOptions2.DiagnosticsProfile.BootDiagnostics.Enabled = true;
virtualMachine2 = (await virtualMachine2.UpdateAsync(true, updateOptions2)).Value;
Assert.AreEqual(true, virtualMachine2.Data.DiagnosticsProfile.BootDiagnostics.Enabled);
updateOptions2.DiagnosticsProfile.BootDiagnostics = null;
virtualMachine2 = (await virtualMachine2.UpdateAsync(true, updateOptions2)).Value;
var newBootDiag = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics;
var newEnabled = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics?.Enabled;
Assert.AreEqual(originalBootDiag is null, newBootDiag is null);
Assert.AreEqual(originalEnabled, newEnabled);
updateOptions2.DiagnosticsProfile = null;
virtualMachine2 = (await virtualMachine2.UpdateAsync(true, updateOptions2)).Value;
newBootDiag = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics;
newEnabled = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics?.Enabled;
Assert.AreEqual(originalBootDiag is null, newBootDiag is null);
Assert.AreEqual(originalEnabled, newEnabled);
}
public async Task UpdateVmIdentityFromTwoUsersToOneUser()
{
var collection = await GetVirtualMachineCollectionAsync();
var vmName = Recording.GenerateAssetName("testVM-");
var nic = await CreateBasicDependenciesOfVirtualMachineAsync();
var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id);
input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned);
var userAssignedIdentity1 = await CreateUserAssignedIdentityAsync();
input.Identity.UserAssignedIdentities.Add(userAssignedIdentity1.Id.ToString(), new UserAssignedIdentity());
var userAssignedIdentity2 = await CreateUserAssignedIdentityAsync();
input.Identity.UserAssignedIdentities.Add(userAssignedIdentity2.Id.ToString(), new UserAssignedIdentity());
var lro = await collection.CreateOrUpdateAsync(true, vmName, input);
VirtualMachine virtualMachine = lro.Value;
Assert.AreEqual(vmName, virtualMachine.Data.Name);
Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, virtualMachine.Data.Identity.Type);
Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 2);
Assert.Null(virtualMachine.Data.Identity.PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity1.Id.ToString()].PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id.ToString()].PrincipalId);
// With JSON Merge Patch, we can use null to delete an identity from the dictionary.
var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned);
identity.UserAssignedIdentities.Add(userAssignedIdentity1.Id.ToString(), null);
var updateOptions = new VirtualMachineUpdateOptions()
{
Identity = identity
};
lro = await virtualMachine.UpdateAsync(true, updateOptions);
VirtualMachine updatedVM = lro.Value;
Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, updatedVM.Data.Identity.Type);
Assert.AreEqual(updatedVM.Data.Identity.UserAssignedIdentities.Count, 1);
Assert.Null(updatedVM.Data.Identity.PrincipalId);
Assert.IsFalse(updatedVM.Data.Identity.UserAssignedIdentities.ContainsKey(userAssignedIdentity1.Id.ToString()));
Assert.NotNull(updatedVM.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id.ToString()].PrincipalId);
}
public virtual ArmOperation <VirtualMachine> Update(bool waitForCompletion, VirtualMachineUpdateOptions options = null, CancellationToken cancellationToken = default)
{
using var scope = _virtualMachineClientDiagnostics.CreateScope("VirtualMachine.Update");
scope.Start();
try
{
var response = _virtualMachineRestClient.Update(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, options, cancellationToken);
var operation = new ConnectedVMwarevSphereArmOperation <VirtualMachine>(new VirtualMachineOperationSource(Client), _virtualMachineClientDiagnostics, Pipeline, _virtualMachineRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, options).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
