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, new UserAssignedIdentity());
var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input);
VirtualMachineResource virtualMachine = lro.Value;
Assert.AreEqual(vmName, virtualMachine.Data.Name);
Assert.AreEqual(ManagedServiceIdentityType.SystemAssignedUserAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType);
Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 1);
Assert.NotNull(virtualMachine.Data.Identity.PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id].PrincipalId);
var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.None);
var updateOptions = new VirtualMachinePatch()
{
Identity = identity
};
lro = await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions);
VirtualMachineResource 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(WaitUntil.Completed);
var update = new VirtualMachinePatch()
{
HardwareProfile = new HardwareProfile
{
VmSize = VirtualMachineSizeTypes.StandardF1
}
};
var lro = await vm.UpdateAsync(WaitUntil.Completed, update);
VirtualMachineResource updatedVM = lro.Value;
Assert.AreEqual(VirtualMachineSizeTypes.StandardF1, updatedVM.Data.HardwareProfile.VmSize);
}
public async Task BootDiagnostic()
{
string vmName = Recording.GenerateAssetName("testVM-");
VirtualMachineResource virtualMachine = await CreateVirtualMachineAsync(vmName);
Assert.IsNull(virtualMachine.Data.BootDiagnostics);
VirtualMachinePatch updateOptions = new VirtualMachinePatch();
updateOptions.BootDiagnostics = new BootDiagnostics();
updateOptions.BootDiagnostics.Enabled = true;
virtualMachine = (await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions)).Value;
Assert.AreEqual(true, virtualMachine.Data.BootDiagnostics.Enabled);
updateOptions.BootDiagnostics = null;
virtualMachine = (await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions)).Value;
var originalBootDiag = virtualMachine.Data.BootDiagnostics;
var originalEnabled = virtualMachine.Data.BootDiagnostics?.Enabled;
string vmName2 = Recording.GenerateAssetName("testVM-");
VirtualMachineResource virtualMachine2 = await CreateVirtualMachineAsync(vmName2);
Assert.IsNull(virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics);
VirtualMachinePatch updateOptions2 = new VirtualMachinePatch();
updateOptions2.DiagnosticsProfile = new DiagnosticsProfile();
updateOptions2.DiagnosticsProfile.BootDiagnostics = new BootDiagnostics();
updateOptions2.DiagnosticsProfile.BootDiagnostics.Enabled = true;
virtualMachine2 = (await virtualMachine2.UpdateAsync(WaitUntil.Completed, updateOptions2)).Value;
Assert.AreEqual(true, virtualMachine2.Data.DiagnosticsProfile.BootDiagnostics.Enabled);
updateOptions2.DiagnosticsProfile.BootDiagnostics = null;
virtualMachine2 = (await virtualMachine2.UpdateAsync(WaitUntil.Completed, 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(WaitUntil.Completed, 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, new UserAssignedIdentity());
var userAssignedIdentity2 = await CreateUserAssignedIdentityAsync();
input.Identity.UserAssignedIdentities.Add(userAssignedIdentity2.Id, new UserAssignedIdentity());
var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input);
VirtualMachineResource virtualMachine = lro.Value;
Assert.AreEqual(vmName, virtualMachine.Data.Name);
Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType);
Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 2);
Assert.Null(virtualMachine.Data.Identity.PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity1.Id].PrincipalId);
Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id].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, null);
var updateOptions = new VirtualMachinePatch()
{
Identity = identity
};
lro = await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions);
VirtualMachineResource updatedVM = lro.Value;
Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, updatedVM.Data.Identity.ManagedServiceIdentityType);
Assert.AreEqual(updatedVM.Data.Identity.UserAssignedIdentities.Count, 1);
Assert.Null(updatedVM.Data.Identity.PrincipalId);
Assert.IsFalse(updatedVM.Data.Identity.UserAssignedIdentities.ContainsKey(userAssignedIdentity1.Id));
Assert.NotNull(updatedVM.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id].PrincipalId);
}
public virtual ArmOperation <VirtualMachineResource> Update(WaitUntil waitUntil, VirtualMachinePatch patch, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(patch, nameof(patch));
using var scope = _virtualMachineClientDiagnostics.CreateScope("VirtualMachineResource.Update");
scope.Start();
try
{
var response = _virtualMachineRestClient.Update(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, patch, cancellationToken);
var operation = new ConnectedVMwarevSphereArmOperation <VirtualMachineResource>(new VirtualMachineOperationSource(Client), _virtualMachineClientDiagnostics, Pipeline, _virtualMachineRestClient.CreateUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, patch).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
