rescontruct vmspec to unmanage Stopped VM

Author: sudo87

core/src/main/java/com/cloud/agent/api/UnmanageInstanceCommand.java

@@ -19,11 +19,14 @@
 
 package com.cloud.agent.api;
 
+import com.cloud.agent.api.to.VirtualMachineTO;
+
 /**
  */
 public class UnmanageInstanceCommand extends Command {
     String instanceName;
     boolean executeInSequence = false;
+    VirtualMachineTO vm;
 
     @Override
     public boolean executeInSequence() {
@@ -34,12 +37,20 @@ public boolean executeInSequence() {
         return executeInSequence;
     }
 
-    public UnmanageInstanceCommand(String instanceName,  boolean executeInSequence) {
+    public UnmanageInstanceCommand(VirtualMachineTO vm) {
+        this.vm = vm;
+        this.instanceName = vm.getName();
+    }
+
+    public UnmanageInstanceCommand(String instanceName) {
         this.instanceName = instanceName;
-        this.executeInSequence = executeInSequence;
     }
 
     public String getInstanceName() {
         return instanceName;
     }
+
+    public VirtualMachineTO getVm() {
+        return vm;
+    }
 }

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

@@ -70,6 +70,7 @@
 import org.apache.cloudstack.engine.subsystem.api.storage.PrimaryDataStoreDriver;
 import org.apache.cloudstack.engine.subsystem.api.storage.StoragePoolAllocator;
 import org.apache.cloudstack.engine.subsystem.api.storage.VolumeDataFactory;
+import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
 import org.apache.cloudstack.framework.ca.Certificate;
 import org.apache.cloudstack.framework.config.ConfigKey;
 import org.apache.cloudstack.framework.config.Configurable;
@@ -156,6 +157,7 @@
 import com.cloud.agent.api.VmNetworkStatsEntry;
 import com.cloud.agent.api.VmStatsEntry;
 import com.cloud.agent.api.routing.NetworkElementCommand;
+import com.cloud.agent.api.to.DataTO;
 import com.cloud.agent.api.to.DiskTO;
 import com.cloud.agent.api.to.DpdkTO;
 import com.cloud.agent.api.to.GPUDeviceTO;
@@ -2020,9 +2022,16 @@ public boolean unmanage(String vmUuid) {
         boolean isDomainXMLPreserved = true;
         // persist domain for kvm host
         if (HypervisorType.KVM.equals(vm.getHypervisorType())) {
-            final UnmanageInstanceCommand unmanageInstanceCommand = new UnmanageInstanceCommand(vm.getName(), false);
+            long hostId = vm.getHostId();
+            UnmanageInstanceCommand unmanageInstanceCommand;
+            if (State.Stopped.equals(vm.getState())) {
+                hostId = vm.getLastHostId();
+                unmanageInstanceCommand = new UnmanageInstanceCommand(prepareVmTO(vm.getId(), hostId)); // reconstruct vmSpec
+            } else {
+                unmanageInstanceCommand = new UnmanageInstanceCommand(vm.getName());
+            }
             try {
-                Answer answer = _agentMgr.send(vm.getHostId(), unmanageInstanceCommand);
+                Answer answer = _agentMgr.send(hostId, unmanageInstanceCommand);
                 isDomainXMLPreserved = (answer instanceof UnmanageInstanceAnswer && answer.getResult());
             } catch (Exception ex) {
                 isDomainXMLPreserved = false;
@@ -4021,6 +4030,39 @@ private void checkAndSetEnterSetupMode(VirtualMachineTO vmTo, Map<VirtualMachine
         vmTo.setEnterHardwareSetup(enterSetup == null ? false : enterSetup);
     }
 
+    protected VirtualMachineTO prepareVmTO(Long vmId, Long hostId) {
+        final VMInstanceVO vm = _vmDao.findById(vmId);
+        final Account owner = _entityMgr.findById(Account.class, vm.getAccountId());
+        final ServiceOfferingVO offering = _offeringDao.findById(vm.getId(), vm.getServiceOfferingId());
+        final VirtualMachineTemplate template = _entityMgr.findByIdIncludingRemoved(VirtualMachineTemplate.class, vm.getTemplateId());
+        Host host = _hostDao.findById(hostId);
+        VirtualMachineProfileImpl vmProfile = new VirtualMachineProfileImpl(vm, template, offering, owner, null);
+        updateOverCommitRatioForVmProfile(vmProfile, host.getClusterId());
+        final List<NicVO> nics = _nicsDao.listByVmId(vmProfile.getId());
+        Collections.sort(nics, (nic1, nic2) -> {
+            Long nicId1 = Long.valueOf(nic1.getDeviceId());
+            Long nicId2 = Long.valueOf(nic2.getDeviceId());
+            return nicId1.compareTo(nicId2);
+        });
+
+        for (final NicVO nic : nics) {
+            final Network network = _networkModel.getNetwork(nic.getNetworkId());
+            final NicProfile nicProfile =
+                    new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), null, _networkModel.isSecurityGroupSupportedInNetwork(network),
+                            _networkModel.getNetworkTag(vmProfile.getHypervisorType(), network));
+            vmProfile.addNic(nicProfile);
+        }
+
+        List<VolumeVO> volumes = _volsDao.findUsableVolumesForInstance(vmId);
+        for (VolumeVO vol: volumes) {
+            VolumeInfo volumeInfo = volumeDataFactory.getVolume(vol.getId());
+            DataTO volTO = volumeInfo.getTO();
+            DiskTO disk = storageMgr.getDiskWithThrottling(volTO, vol.getVolumeType(), vol.getDeviceId(), vol.getPath(), vm.getServiceOfferingId(), vol.getDiskOfferingId());
+            vmProfile.addDisk(disk);
+        }
+        return toVmTO(vmProfile);
+    }
+
     protected VirtualMachineTO getVmTO(Long vmId) {
         final VMInstanceVO vm = _vmDao.findById(vmId);
         final VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);

plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtUnmanageInstanceCommandWrapper.java

@@ -19,14 +19,20 @@
 
 package com.cloud.hypervisor.kvm.resource.wrapper;
 
+import java.net.URISyntaxException;
+
 import org.libvirt.Connect;
 import org.libvirt.Domain;
 import org.libvirt.LibvirtException;
 
 import com.cloud.agent.api.Answer;
 import com.cloud.agent.api.UnmanageInstanceAnswer;
 import com.cloud.agent.api.UnmanageInstanceCommand;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.exception.InternalErrorException;
 import com.cloud.hypervisor.kvm.resource.LibvirtComputingResource;
+import com.cloud.hypervisor.kvm.resource.LibvirtKvmAgentHook;
+import com.cloud.hypervisor.kvm.resource.LibvirtVMDef;
 import com.cloud.resource.CommandWrapper;
 import com.cloud.resource.ResourceWrapper;
 
@@ -37,18 +43,60 @@ public final class LibvirtUnmanageInstanceCommandWrapper extends CommandWrapper<
     @Override
     public Answer execute(final UnmanageInstanceCommand command, final LibvirtComputingResource libvirtComputingResource) {
         String instanceName = command.getInstanceName();
+        VirtualMachineTO vmSpec = command.getVm();
         final LibvirtUtilitiesHelper libvirtUtilitiesHelper = libvirtComputingResource.getLibvirtUtilitiesHelper();
-        logger.debug("Unmanaging KVM instance: {}", instanceName);
+        logger.debug("Attempting to unmanage KVM instance: {}", instanceName);
+        Domain dom = null;
+        Connect conn = null;
         try {
-            Connect conn = libvirtUtilitiesHelper.getConnectionByVmName(instanceName);
-            Domain dom = conn.domainLookupByName(instanceName);
-            String domainXML = dom.getXMLDesc(1);
-            conn.domainDefineXML(domainXML);
+            if (vmSpec == null) {
+                conn = libvirtUtilitiesHelper.getConnectionByVmName(instanceName);
+                dom = conn.domainLookupByName(instanceName);
+                String domainXML = dom.getXMLDesc(1);
+                conn.domainDefineXML(domainXML).free();
+            } else {
+                // define domain using reconstructed vmSpec
+                logger.debug("Unmanaging Stopped KVM instance: {}", instanceName);
+                LibvirtVMDef vm = libvirtComputingResource.createVMFromSpec(vmSpec);
+                libvirtComputingResource.createVbd(conn, vmSpec, instanceName, vm);
+                conn = libvirtUtilitiesHelper.getConnectionByType(vm.getHvsType());
+                String vmInitialSpecification = vm.toString();
+                String vmFinalSpecification = performXmlTransformHook(vmInitialSpecification, libvirtComputingResource);
+                conn.domainDefineXML(vmFinalSpecification).free();
+            }
             logger.debug("Successfully unmanaged KVM instance: {}", instanceName);
             return new UnmanageInstanceAnswer(command, true, "Successfully unmanaged");
-        } catch (final LibvirtException ex) {
-            logger.warn("LibvirtException occurred during unmanaging instance: {} ", instanceName, ex);
-            return new UnmanageInstanceAnswer(command, false, ex.getMessage());
+        } catch (final LibvirtException e) {
+            logger.warn("LibvirtException occurred during unmanaging instance: {} ", instanceName, e);
+            return new UnmanageInstanceAnswer(command, false, e.getMessage());
+        } catch (final URISyntaxException | InternalErrorException e) {
+            logger.warn("URISyntaxException ", e);
+            return new UnmanageInstanceAnswer(command, false, e.getMessage());
+        } finally {
+            if (dom != null) {
+                try {
+                    dom.free();
+                } catch (LibvirtException e) {
+                    logger.error("Ignore libvirt error on free.", e);
+                }
+            }
+        }
+    }
+
+    private String performXmlTransformHook(String vmInitialSpecification, final LibvirtComputingResource libvirtComputingResource) {
+        String vmFinalSpecification;
+        try {
+            // if transformer fails, everything must go as it's just skipped.
+            LibvirtKvmAgentHook t = libvirtComputingResource.getTransformer();
+            vmFinalSpecification = (String) t.handle(vmInitialSpecification);
+            if (null == vmFinalSpecification) {
+                logger.warn("Libvirt XML transformer returned NULL, will use XML specification unchanged.");
+                vmFinalSpecification = vmInitialSpecification;
+            }
+        } catch(Exception e) {
+            logger.warn("Exception occurred when handling LibVirt XML transformer hook: {}", e);
+            vmFinalSpecification = vmInitialSpecification;
         }
+        return vmFinalSpecification;
     }
 }

server/src/main/java/org/apache/cloudstack/vm/UnmanagedVMsManagerImpl.java

@@ -2287,10 +2287,11 @@ public boolean unmanageVMInstance(long vmId) {
 
         performUnmanageVMInstancePrechecks(vmVO);
 
-        Long hostId = findSuitableHostId(vmVO);
+        boolean isVMStopped = VirtualMachine.State.Stopped.equals(vmVO.getState());
+        Long hostId = isVMStopped ? vmVO.getLastHostId() : findSuitableHostId(vmVO);
         String instanceName = vmVO.getInstanceName();
 
-        if (!existsVMToUnmanage(instanceName, hostId)) {
+        if (!isVMStopped && !existsVMToUnmanage(instanceName, hostId)) {
             throw new CloudRuntimeException(String.format("VM %s is not found in the hypervisor", vmVO));
         }