generate unmanage event and improve code coverage

Author: sudo87

api/src/main/java/org/apache/cloudstack/api/command/admin/vm/UnmanageVMInstanceCmd.java

@@ -69,7 +69,8 @@ public class UnmanageVMInstanceCmd extends BaseAsyncCmd {
 
     @Parameter(name = ApiConstants.HOST_ID, type = CommandType.UUID,
             entityType = HostResponse.class, required = false,
-            description = "ID of the host where domain XML is stored for stopped Instance",
+            description = "ID of the host which will be used for unmanaging the Instance. " +
+                    "Applicable only for KVM hypervisor and stopped Instances. Domain XML will be stored on this host.",
             since = "4.22.0")
     private Long hostId;
 

engine/orchestration/src/main/java/com/cloud/vm/VirtualMachineManagerImpl.java

@@ -2049,6 +2049,9 @@ public Boolean doInTransaction(TransactionStatus status) {
             throw new CloudRuntimeException("Unable to retrieve host with ID: " + agentHostId);
         }
         logger.debug("Selected host UUID: {} to unmanage Instance: {}.", host.getUuid(), vm.getName());
+        ActionEventUtils.onActionEvent(User.UID_SYSTEM, Account.ACCOUNT_ID_SYSTEM, Domain.ROOT_DOMAIN, EventTypes.EVENT_VM_UNMANAGE,
+                String.format("Successfully unmanaged Instance: %s (ID: %s) on host ID: %s", vm.getName(), vm.getUuid(), host.getUuid()),
+                vm.getId(), ApiCommandResourceType.VirtualMachine.toString());
         return new Pair<>(result, host.getUuid());
     }
 
@@ -2092,14 +2095,14 @@ Long persistDomainForKVM(VMInstanceVO vm, Long paramHostId) {
     /**
      * Clean up VM snapshots (if any) from DB
      */
-    private void unmanageVMSnapshots(VMInstanceVO vm) {
+    void unmanageVMSnapshots(VMInstanceVO vm) {
         _vmSnapshotMgr.deleteVMSnapshotsFromDB(vm.getId(), true);
     }
 
     /**
      * Clean up volumes for a VM to be unmanaged from CloudStack
      */
-    private void unmanageVMVolumes(VMInstanceVO vm) {
+    void unmanageVMVolumes(VMInstanceVO vm) {
         final Long hostId = vm.getHostId() != null ? vm.getHostId() : vm.getLastHostId();
         if (hostId != null) {
             volumeMgr.revokeAccess(vm.getId(), hostId);
@@ -2117,7 +2120,7 @@ private void unmanageVMVolumes(VMInstanceVO vm) {
      * - If 'unmanage.vm.preserve.nics' = true: then the NICs are not removed but still Allocated, to preserve MAC addresses
      * - If 'unmanage.vm.preserve.nics' = false: then the NICs are removed while unmanaging
      */
-    private void unmanageVMNics(VirtualMachineProfile profile, VMInstanceVO vm) {
+    void unmanageVMNics(VirtualMachineProfile profile, VMInstanceVO vm) {
         logger.debug("Cleaning up NICs of {}.", vm.toString());
         Boolean preserveNics = UnmanagedVMsManager.UnmanageVMPreserveNic.valueIn(vm.getDataCenterId());
         if (BooleanUtils.isTrue(preserveNics)) {

engine/orchestration/src/test/java/com/cloud/vm/VirtualMachineManagerImplTest.java

@@ -40,6 +40,8 @@
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -51,6 +53,10 @@
 import com.cloud.agent.api.UnmanageInstanceCommand;
 import com.cloud.agent.api.to.DataTO;
 import com.cloud.agent.api.to.DiskTO;
+import com.cloud.api.ApiDBUtils;
+import com.cloud.event.ActionEventUtils;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.ha.HighAvailabilityManager;
 import com.cloud.network.Network;
 import com.cloud.network.NetworkModel;
 import com.cloud.resource.ResourceManager;
@@ -64,6 +70,8 @@
 import org.apache.cloudstack.framework.extensions.dao.ExtensionDetailsDao;
 import org.apache.cloudstack.framework.extensions.manager.ExtensionsManager;
 import org.apache.cloudstack.framework.extensions.vo.ExtensionDetailsVO;
+import org.apache.cloudstack.framework.jobs.dao.VmWorkJobDao;
+import org.apache.cloudstack.framework.jobs.impl.VmWorkJobVO;
 import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
 import org.apache.cloudstack.storage.to.VolumeObjectTO;
@@ -180,6 +188,9 @@ public class VirtualMachineManagerImplTest {
     private PrimaryDataStoreDao storagePoolDaoMock;
     @Mock
     private VMInstanceVO vmInstanceMock;
+    @Mock
+    private VmWorkJobDao _workJobDao;
+
     private long vmInstanceVoMockId = 1L;
 
     @Mock
@@ -194,6 +205,9 @@ public class VirtualMachineManagerImplTest {
     private long hostMockId = 1L;
     private long clusterMockId = 2L;
     private long zoneMockId = 3L;
+    private final String vmMockUuid = UUID.randomUUID().toString();
+    private final String hostUuid = UUID.randomUUID().toString();
+
     @Mock
     private HostVO hostMock;
     @Mock
@@ -274,6 +288,10 @@ public class VirtualMachineManagerImplTest {
     VolumeDataFactory volumeDataFactoryMock;
     @Mock
     StorageManager storageManager;
+    @Mock
+    private HighAvailabilityManager _haMgr;
+    @Mock
+    VirtualMachineGuru guru;
 
     private ConfigDepotImpl configDepotImpl;
     private boolean updatedConfigKeyDepot = false;
@@ -1813,6 +1831,14 @@ public void testPersistDomainForKvmAgentUnavailable() throws AgentUnavailableExc
         assertEquals("Failed to send command to persist domain XML for Instance: " + vmName + " on host ID: " + hostMockId, exception.getMessage());
     }
 
+    @Test(expected = ConcurrentOperationException.class)
+    public void testUnmanagePendingHaWork() {
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        when(_workJobDao.listPendingWorkJobs(VirtualMachine.Type.Instance, vmInstanceVoMockId)).thenReturn(Collections.emptyList());
+        when(_haMgr.hasPendingHaWork(vmInstanceVoMockId)).thenReturn(true);
+        virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+    }
+
     @Test
     public void testPersistDomainForKvmOperationTimedOut() throws AgentUnavailableException, OperationTimedoutException {
         when(vmInstanceMock.getState()).thenReturn(VirtualMachine.State.Running);
@@ -1821,4 +1847,110 @@ public void testPersistDomainForKvmOperationTimedOut() throws AgentUnavailableEx
         CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> virtualMachineManagerImpl.persistDomainForKVM(vmInstanceMock, null));
         assertEquals("Failed to send command to persist domain XML for Instance: " + vmName + " on host ID: " + hostMockId, exception.getMessage());
     }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testUnmanageVmRemoved() {
+        when(vmInstanceMock.getRemoved()).thenReturn(new Date());
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+    }
+
+    @Test(expected = ConcurrentOperationException.class)
+    public void testUnmanagePendingWorkJobs() {
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        List<VmWorkJobVO> pendingJobs = new ArrayList<>();
+        VmWorkJobVO vmWorkJobVO = mock(VmWorkJobVO.class);
+        pendingJobs.add(vmWorkJobVO);
+        when(_workJobDao.listPendingWorkJobs(VirtualMachine.Type.Instance, vmInstanceVoMockId)).thenReturn(pendingJobs);
+        virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testUnmanageHostNotFoundAfterTransaction() {
+        when(vmInstanceMock.getHostId()).thenReturn(hostMockId);
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        when(_workJobDao.listPendingWorkJobs(any(), anyLong())).thenReturn(Collections.emptyList());
+        when(_haMgr.hasPendingHaWork(anyLong())).thenReturn(false);
+        doReturn(guru).when(virtualMachineManagerImpl).getVmGuru(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMSnapshots(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMNics(any(VirtualMachineProfile.class), any(VMInstanceVO.class));
+        doNothing().when(virtualMachineManagerImpl).unmanageVMVolumes(vmInstanceMock);
+        doNothing().when(guru).finalizeUnmanage(vmInstanceMock);
+        try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
+            when(ApiDBUtils.findHostById(hostMockId)).thenReturn(null);
+            virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+        }
+    }
+
+    @Test
+    public void testUnmanageSuccessNonKvm() {
+        when(vmInstanceMock.getHostId()).thenReturn(hostMockId);
+        when(hostMock.getUuid()).thenReturn(hostUuid);
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        when(_workJobDao.listPendingWorkJobs(any(), anyLong())).thenReturn(Collections.emptyList());
+        when(_haMgr.hasPendingHaWork(anyLong())).thenReturn(false);
+        doReturn(guru).when(virtualMachineManagerImpl).getVmGuru(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMSnapshots(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMNics(any(VirtualMachineProfile.class), any(VMInstanceVO.class));
+        doNothing().when(virtualMachineManagerImpl).unmanageVMVolumes(vmInstanceMock);
+        doNothing().when(guru).finalizeUnmanage(vmInstanceMock);
+        try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
+            when(ApiDBUtils.findHostById(hostMockId)).thenReturn(hostMock);
+            try (MockedStatic<ActionEventUtils> actionUtil = Mockito.mockStatic(ActionEventUtils.class)) {
+                actionUtil.when(() -> ActionEventUtils.onActionEvent(
+                        anyLong(), anyLong(), anyLong(),
+                        anyString(), anyString(),
+                        anyLong(), anyString()
+                )).thenReturn(1L);
+
+                Pair<Boolean, String> result = virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+                assertNotNull(result);
+                assertTrue(result.first());
+                assertEquals(hostUuid, result.second());
+
+                verify(virtualMachineManagerImpl, never()).persistDomainForKVM(any(VMInstanceVO.class), anyLong());
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMSnapshots(vmInstanceMock);
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMNics(any(VirtualMachineProfile.class), any(VMInstanceVO.class));
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMVolumes(vmInstanceMock);
+                verify(guru, times(1)).finalizeUnmanage(vmInstanceMock);
+            }
+        }
+    }
+
+    @Test
+    public void testUnmanageSuccessKvm() throws Exception {
+        when(vmInstanceMock.getHostId()).thenReturn(hostMockId);
+        when(hostMock.getUuid()).thenReturn(hostUuid);
+        when(vmInstanceMock.getHypervisorType()).thenReturn(HypervisorType.KVM);
+        when(vmInstanceDaoMock.findByUuid(vmMockUuid)).thenReturn(vmInstanceMock);
+        when(_workJobDao.listPendingWorkJobs(any(), anyLong())).thenReturn(Collections.emptyList());
+        when(_haMgr.hasPendingHaWork(anyLong())).thenReturn(false);
+        doReturn(guru).when(virtualMachineManagerImpl).getVmGuru(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMSnapshots(vmInstanceMock);
+        doNothing().when(virtualMachineManagerImpl).unmanageVMNics(any(VirtualMachineProfile.class), any(VMInstanceVO.class));
+        doNothing().when(virtualMachineManagerImpl).unmanageVMVolumes(vmInstanceMock);
+        doNothing().when(guru).finalizeUnmanage(vmInstanceMock);
+        try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
+            when(ApiDBUtils.findHostById(hostMockId)).thenReturn(hostMock);
+            try (MockedStatic<ActionEventUtils> actionUtil = Mockito.mockStatic(ActionEventUtils.class)) {
+                actionUtil.when(() -> ActionEventUtils.onActionEvent(
+                        anyLong(), anyLong(), anyLong(),
+                        anyString(), anyString(),
+                        anyLong(), anyString()
+                )).thenReturn(1L);
+                UnmanageInstanceAnswer successAnswer = new UnmanageInstanceAnswer(null, true, "success");
+                when(agentManagerMock.send(anyLong(), any(UnmanageInstanceCommand.class))).thenReturn(successAnswer);
+                Pair<Boolean, String> result = virtualMachineManagerImpl.unmanage(vmMockUuid, null);
+                assertNotNull(result);
+                assertTrue(result.first());
+                assertEquals(hostUuid, result.second());
+                verify(virtualMachineManagerImpl, times(1)).persistDomainForKVM(vmInstanceMock, null);
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMSnapshots(vmInstanceMock);
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMNics(any(VirtualMachineProfile.class), any(VMInstanceVO.class));
+                verify(virtualMachineManagerImpl, times(1)).unmanageVMVolumes(vmInstanceMock);
+                verify(guru, times(1)).finalizeUnmanage(vmInstanceMock);
+            }
+        }
+    }
+
 }

server/src/main/java/com/cloud/vm/UserVmManagerImpl.java

@@ -9671,20 +9671,20 @@ public UserVm restoreVMFromBackup(CreateVMFromBackupCmd cmd) throws ResourceUnav
     /*
         Generate usage events related to unmanaging a VM
      */
-    private void publishUnmanageVMUsageEvents(UserVmVO vm, List<VolumeVO> volumes) {
+    void publishUnmanageVMUsageEvents(UserVmVO vm, List<VolumeVO> volumes) {
         postProcessingUnmanageVMVolumes(volumes, vm);
         postProcessingUnmanageVM(vm);
     }
 
     /*
         Cleanup the VM from resources and groups
      */
-    private void cleanupUnmanageVMResources(UserVmVO vm) {
+    void cleanupUnmanageVMResources(UserVmVO vm) {
         cleanupVmResources(vm);
         removeVMFromAffinityGroups(vm.getId());
     }
 
-    private void unmanageVMFromDB(long vmId) {
+    void unmanageVMFromDB(long vmId) {
         VMInstanceVO vm = _vmInstanceDao.findById(vmId);
         vmInstanceDetailsDao.removeDetails(vmId);
         vm.setState(State.Expunging);
@@ -9746,15 +9746,15 @@ private void postProcessingUnmanageVMVolumes(List<VolumeVO> volumes, UserVmVO vm
         }
     }
 
-    private void checkUnmanagingVMOngoingVolumeSnapshots(UserVmVO vm) {
+    void checkUnmanagingVMOngoingVolumeSnapshots(UserVmVO vm) {
         logger.debug("Checking if there are any ongoing snapshots on the ROOT volumes associated with VM {}", vm);
         if (checkStatusOfVolumeSnapshots(vm, Volume.Type.ROOT)) {
             throw new CloudRuntimeException("There is/are unbacked up snapshot(s) on ROOT volume, vm unmanage is not permitted, please try again later.");
         }
         logger.debug("Found no ongoing snapshots on volume of type ROOT, for the vm {}", vm);
     }
 
-    private void checkUnmanagingVMVolumes(UserVmVO vm, List<VolumeVO> volumes) {
+    void checkUnmanagingVMVolumes(UserVmVO vm, List<VolumeVO> volumes) {
         for (VolumeVO volume : volumes) {
             if (volume.getInstanceId() == null || !volume.getInstanceId().equals(vm.getId())) {
                 throw new CloudRuntimeException(String.format("Invalid state for volume %s of VM %s: it is not attached to VM", volume, vm));