Use forced true to unmanage instance with config drive

Author: sudo87

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

@@ -42,6 +42,7 @@
 import org.apache.cloudstack.api.response.UserVmResponse;
 import org.apache.cloudstack.context.CallContext;
 import org.apache.cloudstack.vm.UnmanagedVMsManager;
+import org.apache.commons.lang3.BooleanUtils;
 
 import javax.inject.Inject;
 
@@ -74,6 +75,13 @@ public class UnmanageVMInstanceCmd extends BaseAsyncCmd {
             since = "4.22.0")
     private Long hostId;
 
+    @Parameter(name = ApiConstants.FORCED,
+            type = CommandType.BOOLEAN,
+            required = false,
+            description = "Force unmanaging Instance with config drive. Applicable only for KVM Hypervisor.",
+            since = "4.22.0")
+    private Boolean forced;
+
     /////////////////////////////////////////////////////
     /////////////////// Accessors ///////////////////////
     /////////////////////////////////////////////////////
@@ -100,6 +108,10 @@ public void setHostId(Long hostId) {
         this.hostId = hostId;
     }
 
+    public Boolean isForced() {
+        return BooleanUtils.isTrue(forced);
+    }
+
     /////////////////////////////////////////////////////
     /////////////// API Implementation///////////////////
     /////////////////////////////////////////////////////
@@ -110,7 +122,7 @@ public void execute() throws ResourceUnavailableException, InsufficientCapacityE
         UnmanageVMInstanceResponse response = new UnmanageVMInstanceResponse();
         try {
             CallContext.current().setEventDetails("VM ID = " + vmId);
-            Pair<Boolean, String> result = unmanagedVMsManager.unmanageVMInstance(vmId, hostId);
+            Pair<Boolean, String> result = unmanagedVMsManager.unmanageVMInstance(vmId, hostId, isForced());
             if (result.first()) {
                 response.setSuccess(true);
                 response.setHostId(result.second());

api/src/main/java/org/apache/cloudstack/vm/UnmanageVMService.java

@@ -26,5 +26,5 @@ public interface UnmanageVMService {
      *
      * @return (true if successful, false if not, hostUuid) if the VM is successfully unmanaged.
      */
-    Pair<Boolean, String> unmanageVMInstance(long vmId, Long paramHostId);
+    Pair<Boolean, String> unmanageVMInstance(long vmId, Long paramHostId, boolean isForced);
 }

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

@@ -27,6 +27,7 @@ public class UnmanageInstanceCommand extends Command {
     String instanceName;
     boolean executeInSequence = false;
     VirtualMachineTO vm;
+    boolean isConfigDriveAttached;
 
     @Override
     public boolean executeInSequence() {
@@ -49,4 +50,12 @@ public String getInstanceName() {
     public VirtualMachineTO getVm() {
         return vm;
     }
+
+    public boolean isConfigDriveAttached() {
+        return isConfigDriveAttached;
+    }
+
+    public void setConfigDriveAttached(boolean configDriveAttached) {
+        isConfigDriveAttached = configDriveAttached;
+    }
 }

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

@@ -2089,6 +2089,7 @@ Long persistDomainForKVM(VMInstanceVO vm, Long paramHostId) {
             unmanageInstanceCommand = new UnmanageInstanceCommand(prepVmSpecForUnmanageCmd(vm.getId(), agentHostId)); // reconstruct vmSpec for stopped instance
         } else {
             unmanageInstanceCommand = new UnmanageInstanceCommand(vmName);
+            unmanageInstanceCommand.setConfigDriveAttached(vmInstanceDetailsDao.findDetail(vm.getId(), VmDetailConstants.CONFIG_DRIVE_LOCATION) != null);
         }
 
         logger.debug("Selected host ID: {} to persist domain XML for Instance: {}.", agentHostId, vmName);

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

@@ -19,11 +19,34 @@
 
 package com.cloud.hypervisor.kvm.resource.wrapper;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
 import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.apache.cloudstack.utils.security.ParserUtils;
+import org.apache.commons.io.IOUtils;
 import org.libvirt.Connect;
 import org.libvirt.Domain;
 import org.libvirt.LibvirtException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
 
 import com.cloud.agent.api.Answer;
 import com.cloud.agent.api.UnmanageInstanceAnswer;
@@ -48,29 +71,39 @@ public Answer execute(final UnmanageInstanceCommand command, final LibvirtComput
         logger.debug("Attempting to unmanage KVM instance: {}", instanceName);
         Domain dom = null;
         Connect conn = null;
+        String vmFinalSpecification;
         try {
             if (vmSpec == null) {
                 conn = libvirtUtilitiesHelper.getConnectionByVmName(instanceName);
                 dom = conn.domainLookupByName(instanceName);
-                String domainXML = dom.getXMLDesc(1);
-                conn.domainDefineXML(domainXML).free();
+                vmFinalSpecification = dom.getXMLDesc(1);
+                if (command.isConfigDriveAttached()) {
+                    vmFinalSpecification = cleanupConfigDrive(vmFinalSpecification, instanceName);
+                }
             } 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();
+                vmFinalSpecification = performXmlTransformHook(vmInitialSpecification, libvirtComputingResource);
             }
-            logger.debug("Successfully unmanaged KVM instance: {}", instanceName);
+            conn.domainDefineXML(vmFinalSpecification).free();
+            logger.debug("Successfully unmanaged KVM instance: {} with domain XML: {}", instanceName, vmFinalSpecification);
             return new UnmanageInstanceAnswer(command, true, "Successfully unmanaged");
         } catch (final LibvirtException e) {
-            logger.warn("LibvirtException occurred during unmanaging instance: {} ", instanceName, e);
+            logger.error("LibvirtException occurred during unmanaging instance: {} ", instanceName, e);
             return new UnmanageInstanceAnswer(command, false, e.getMessage());
-        } catch (final URISyntaxException | InternalErrorException e) {
-            logger.warn("URISyntaxException ", e);
+        } catch (final IOException
+                       | ParserConfigurationException
+                       | SAXException
+                       | TransformerException
+                       | XPathExpressionException
+                       | InternalErrorException
+                       | URISyntaxException e) {
+
+            logger.error("Failed to unmanage Instance: {}.", instanceName, e);
             return new UnmanageInstanceAnswer(command, false, e.getMessage());
         } finally {
             if (dom != null) {
@@ -83,6 +116,45 @@ public Answer execute(final UnmanageInstanceCommand command, final LibvirtComput
         }
     }
 
+    String cleanupConfigDrive(String domainXML, String instanceName) throws ParserConfigurationException, IOException, SAXException, XPathExpressionException, TransformerException {
+        String isoName = "/" + instanceName + ".iso";
+        DocumentBuilderFactory docFactory = ParserUtils.getSaferDocumentBuilderFactory();
+        DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
+        Document document;
+        try (InputStream inputStream = IOUtils.toInputStream(domainXML, StandardCharsets.UTF_8)) {
+            document = docBuilder.parse(inputStream);
+        }
+        XPathFactory xPathFactory = XPathFactory.newInstance();
+        XPath xpath = xPathFactory.newXPath();
+
+        // Find all <disk device='cdrom'> elements with source file containing instanceName.iso
+        String expression = String.format("//disk[@device='cdrom'][source/@file[contains(., '%s')]]", isoName);
+        NodeList cdromDisks = (NodeList) xpath.evaluate(expression, document, XPathConstants.NODESET);
+
+        // If nothing matched, return original XML
+        if (cdromDisks == null || cdromDisks.getLength() == 0) {
+            logger.debug("No config drive found in domain XML for Instance: {}", instanceName);
+            return domainXML;
+        }
+
+        // Remove all matched config drive disks
+        for (int i = 0; i < cdromDisks.getLength(); i++) {
+            Node diskNode = cdromDisks.item(i);
+            if (diskNode != null && diskNode.getParentNode() != null) {
+                diskNode.getParentNode().removeChild(diskNode);
+            }
+        }
+        logger.debug("Removed {} config drive ISO CD-ROM entries for instance: {}", cdromDisks.getLength(), instanceName);
+
+        TransformerFactory transformerFactory = ParserUtils.getSaferTransformerFactory();
+        Transformer transformer = transformerFactory.newTransformer();
+        DOMSource source = new DOMSource(document);
+        StringWriter output = new StringWriter();
+        StreamResult result = new StreamResult(output);
+        transformer.transform(source, result);
+        return output.toString();
+    }
+
     private String performXmlTransformHook(String vmInitialSpecification, final LibvirtComputingResource libvirtComputingResource) {
         String vmFinalSpecification;
         try {