Add GSOC2023 work to KVM ingestion

api/src/main/java/com/cloud/vm/VmDetailConstants.java

@@ -40,6 +40,8 @@ public interface VmDetailConstants {
     String KVM_VNC_PORT = "kvm.vnc.port";
     String KVM_VNC_ADDRESS = "kvm.vnc.address";
 
+    String KVM_VNC_PASSWORD = "kvm.vnc.password";
+
     // KVM specific, custom virtual GPU hardware
     String VIDEO_HARDWARE = "video.hardware";
     String VIDEO_RAM = "video.ram";

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

@@ -84,7 +84,7 @@ public class ImportUnmanagedInstanceCmd extends BaseAsyncCmd {
     @Parameter(name = ApiConstants.NAME,
             type = CommandType.STRING,
             required = true,
-            description = "the hypervisor name of the instance")
+            description = "the name of the instance as it is known to the hypervisor")
     private String name;
 
     @Parameter(name = ApiConstants.DISPLAY_NAME,

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

@@ -17,13 +17,20 @@
 
 package org.apache.cloudstack.vm;
 
+import com.cloud.hypervisor.Hypervisor;
 import com.cloud.utils.component.PluggableService;
 import org.apache.cloudstack.framework.config.ConfigKey;
 import org.apache.cloudstack.framework.config.Configurable;
+import static com.cloud.hypervisor.Hypervisor.HypervisorType.KVM;
+import static com.cloud.hypervisor.Hypervisor.HypervisorType.VMware;
 
 public interface UnmanagedVMsManager extends VmImportService, UnmanageVMService, PluggableService, Configurable {
 
     ConfigKey<Boolean> UnmanageVMPreserveNic = new ConfigKey<>("Advanced", Boolean.class, "unmanage.vm.preserve.nics", "false",
             "If set to true, do not remove VM nics (and its MAC addresses) when unmanaging a VM, leaving them allocated but not reserved. " +
                     "If set to false, nics are removed and MAC addresses can be reassigned", true, ConfigKey.Scope.Zone);
+
+    static boolean isSupported(Hypervisor.HypervisorType hypervisorType) {
+        return hypervisorType == VMware || hypervisorType == KVM;
+    }
 }

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

@@ -345,6 +345,14 @@ public boolean parseDomainXML(String domXML) {
                     period = "0";
                 }
 
+                if(bytes == null) {
+                    bytes = "0";
+                }
+
+                if(period == null) {
+                    period = "0";
+                }
+
                 if (StringUtils.isEmpty(backendModel)) {
                     def = new RngDef(path, Integer.parseInt(bytes), Integer.parseInt(period));
                 } else {

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

@@ -0,0 +1,223 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.cloud.hypervisor.kvm.resource.wrapper;
+
+import com.cloud.agent.api.GetUnmanagedInstancesAnswer;
+import com.cloud.agent.api.GetUnmanagedInstancesCommand;
+import com.cloud.hypervisor.kvm.resource.LibvirtComputingResource;
+import com.cloud.hypervisor.kvm.resource.LibvirtDomainXMLParser;
+import com.cloud.hypervisor.kvm.resource.LibvirtVMDef;
+import com.cloud.resource.CommandWrapper;
+import com.cloud.resource.ResourceWrapper;
+import com.cloud.utils.Pair;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.vm.VirtualMachine;
+import org.apache.cloudstack.utils.qemu.QemuImg;
+import org.apache.cloudstack.utils.qemu.QemuImgException;
+import org.apache.cloudstack.utils.qemu.QemuImgFile;
+import org.apache.cloudstack.vm.UnmanagedInstanceTO;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.log4j.Logger;
+import org.libvirt.Connect;
+import org.libvirt.Domain;
+import org.libvirt.LibvirtException;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@ResourceWrapper(handles=GetUnmanagedInstancesCommand.class)
+public final class LibvirtGetUnmanagedInstancesCommandWrapper extends CommandWrapper<GetUnmanagedInstancesCommand, GetUnmanagedInstancesAnswer, LibvirtComputingResource> {
+    private static final Logger LOGGER = Logger.getLogger(LibvirtPrepareUnmanageVMInstanceCommandWrapper.class);
+
+    @Override
+    public GetUnmanagedInstancesAnswer execute(GetUnmanagedInstancesCommand command, LibvirtComputingResource libvirtComputingResource) {
+        LOGGER.info("Fetching unmanaged instance on host");
+
+        HashMap<String, UnmanagedInstanceTO> unmanagedInstances = new HashMap<>();
+        try {
+            final LibvirtUtilitiesHelper libvirtUtilitiesHelper = libvirtComputingResource.getLibvirtUtilitiesHelper();
+            final Connect conn = libvirtUtilitiesHelper.getConnection();
+            final List<Domain> domains = getDomains(command, libvirtComputingResource, conn);
+
+            for (Domain domain : domains) {
+                UnmanagedInstanceTO instance = getUnmanagedInstance(libvirtComputingResource, domain, conn);
+                unmanagedInstances.put(instance.getName(), instance);
+                domain.free();
+            }
+        } catch (Exception e) {
+            LOGGER.error("GetUnmanagedInstancesCommand failed due to " + e.getMessage());
+            throw new CloudRuntimeException("GetUnmanagedInstancesCommand failed due to " + e.getMessage());
+        }
+
+        return new GetUnmanagedInstancesAnswer(command, "True", unmanagedInstances);
+    }
+
+    private List<Domain> getDomains(GetUnmanagedInstancesCommand command,
+                                    LibvirtComputingResource libvirtComputingResource,
+                                    Connect conn) throws LibvirtException, CloudRuntimeException {
+        final List<Domain> domains = new ArrayList<>();
+        final String vmNameCmd = command.getInstanceName();
+        if (StringUtils.isNotBlank(vmNameCmd)) {
+            final Domain domain = libvirtComputingResource.getDomain(conn, vmNameCmd);
+            if (domain == null) {
+                LOGGER.error("GetUnmanagedInstancesCommand: vm not found " + vmNameCmd);
+                throw new CloudRuntimeException("GetUnmanagedInstancesCommand: vm not found " + vmNameCmd);
+            }
+
+            checkIfVmExists(vmNameCmd,domain);
+            checkIfVmIsManaged(command,vmNameCmd,domain);
+
+            domains.add(domain);
+        } else {
+            final List<String> allVmNames = libvirtComputingResource.getAllVmNames(conn);
+            for (String name : allVmNames) {
+                if (!command.hasManagedInstance(name)) {
+                    final Domain domain = libvirtComputingResource.getDomain(conn, name);
+                    domains.add(domain);
+                }
+            }
+        }
+        return domains;
+    }
+
+    private void checkIfVmExists(String vmNameCmd,final Domain domain) throws LibvirtException {
+        if (StringUtils.isNotEmpty(vmNameCmd) &&
+                !vmNameCmd.equals(domain.getName())) {
+            LOGGER.error("GetUnmanagedInstancesCommand: exact vm name not found " + vmNameCmd);
+            throw new CloudRuntimeException("GetUnmanagedInstancesCommand: exact vm name not found " + vmNameCmd);
+        }
+    }
+
+    private void checkIfVmIsManaged(GetUnmanagedInstancesCommand command,String vmNameCmd,final Domain domain) throws LibvirtException {
+        if (command.hasManagedInstance(domain.getName())) {
+            LOGGER.error("GetUnmanagedInstancesCommand: vm already managed " + vmNameCmd);
+            throw new CloudRuntimeException("GetUnmanagedInstancesCommand:  vm already managed " + vmNameCmd);
+        }
+    }
+    private UnmanagedInstanceTO getUnmanagedInstance(LibvirtComputingResource libvirtComputingResource, Domain domain, Connect conn) {
+        try {
+            final LibvirtDomainXMLParser parser = new LibvirtDomainXMLParser();
+            parser.parseDomainXML(domain.getXMLDesc(1));
+
+            final UnmanagedInstanceTO instance = new UnmanagedInstanceTO();
+            instance.setName(domain.getName());
+
+            instance.setCpuCores((int) LibvirtComputingResource.countDomainRunningVcpus(domain));
+            instance.setCpuSpeed(parser.getCpuTuneDef().getShares()/instance.getCpuCores());
+
+            if (parser.getCpuModeDef() != null) {
+                instance.setCpuCoresPerSocket(parser.getCpuModeDef().getCoresPerSocket());
+            }
+            instance.setPowerState(getPowerState(libvirtComputingResource.getVmState(conn,domain.getName())));
+            instance.setMemory((int) LibvirtComputingResource.getDomainMemory(domain) / 1024);
+            instance.setNics(getUnmanagedInstanceNics(parser.getInterfaces()));
+            instance.setDisks(getUnmanagedInstanceDisks(parser.getDisks(),libvirtComputingResource));
+            instance.setVncPassword(parser.getVncPasswd() + "aaaaaaaaaaaaaa"); // Suffix back extra characters for DB compatibility
+
+            return instance;
+        } catch (Exception e) {
+            LOGGER.info("Unable to retrieve unmanaged instance info. " + e.getMessage());
+            throw new CloudRuntimeException("Unable to retrieve unmanaged instance info. " + e.getMessage());
+        }
+    }
+
+    private UnmanagedInstanceTO.PowerState getPowerState(VirtualMachine.PowerState vmPowerState) {
+        switch (vmPowerState) {
+            case PowerOn:
+                return UnmanagedInstanceTO.PowerState.PowerOn;
+            case PowerOff:
+                return UnmanagedInstanceTO.PowerState.PowerOff;
+            default:
+                return UnmanagedInstanceTO.PowerState.PowerUnknown;
+
+        }
+    }
+
+    private List<UnmanagedInstanceTO.Nic> getUnmanagedInstanceNics(List<LibvirtVMDef.InterfaceDef> interfaces) {
+        final ArrayList<UnmanagedInstanceTO.Nic> nics = new ArrayList<>(interfaces.size());
+        int counter = 0;
+        for (LibvirtVMDef.InterfaceDef interfaceDef : interfaces) {
+            final UnmanagedInstanceTO.Nic nic = new UnmanagedInstanceTO.Nic();
+            nic.setNicId(String.valueOf(counter++));
+            nic.setMacAddress(interfaceDef.getMacAddress());
+            nic.setAdapterType(interfaceDef.getModel().toString());
+            nic.setNetwork(interfaceDef.getDevName());
+            nic.setPciSlot(interfaceDef.getSlot().toString());
+            nic.setVlan(interfaceDef.getVlanTag());
+            nics.add(nic);
+        }
+        return nics;
+    }
+
+    private List<UnmanagedInstanceTO.Disk> getUnmanagedInstanceDisks(List<LibvirtVMDef.DiskDef> disksInfo, LibvirtComputingResource libvirtComputingResource){
+        final ArrayList<UnmanagedInstanceTO.Disk> disks = new ArrayList<>(disksInfo.size());
+        int counter = 0;
+        for (LibvirtVMDef.DiskDef diskDef : disksInfo) {
+            if (diskDef.getDeviceType() != LibvirtVMDef.DiskDef.DeviceType.DISK) {
+                continue;
+            }
+
+            final UnmanagedInstanceTO.Disk disk = new UnmanagedInstanceTO.Disk();
+            Long size = null;
+            String imagePath = null;
+            try {
+                QemuImgFile file = new QemuImgFile(diskDef.getSourcePath());
+                QemuImg qemu = new QemuImg(0);
+                Map<String, String> info = qemu.info(file);
+                size = Long.parseLong(info.getOrDefault("virtual_size", "0"));
+                imagePath = info.getOrDefault("image", null);
+            } catch (QemuImgException | LibvirtException e) {
+                throw new RuntimeException(e);
+            }
+
+            disk.setPosition(counter);
+            disk.setCapacity(size);
+            disk.setDiskId(String.valueOf(counter++));
+            disk.setLabel(diskDef.getDiskLabel());
+            disk.setController(diskDef.getBusType().toString());
+
+
+            Pair<String, String> sourceHostPath = getSourceHostPath(libvirtComputingResource, diskDef.getSourcePath());
+            if (sourceHostPath != null) {
+                disk.setDatastoreHost(sourceHostPath.first());
+                disk.setDatastorePath(sourceHostPath.second());
+            } else {
+                disk.setDatastorePath(diskDef.getSourcePath());
+                disk.setDatastoreHost(diskDef.getSourceHost());
+            }
+
+            disk.setDatastoreType(diskDef.getDiskType().toString());
+            disk.setDatastorePort(diskDef.getSourceHostPort());
+            disk.setImagePath(imagePath);
+            disk.setDatastoreName(imagePath.substring(imagePath.lastIndexOf("/")));
+            disks.add(disk);
+        }
+        return disks;
+    }
+
+    private Pair<String, String> getSourceHostPath(LibvirtComputingResource libvirtComputingResource, String diskPath) {
+        int pathEnd = diskPath.lastIndexOf("/");
+        if (pathEnd >= 0) {
+            diskPath = diskPath.substring(0, pathEnd);
+            return libvirtComputingResource.getSourceHostPath(diskPath);
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,51 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.cloud.hypervisor.kvm.resource.wrapper;
+
+import com.cloud.agent.api.PrepareUnmanageVMInstanceAnswer;
+import com.cloud.agent.api.PrepareUnmanageVMInstanceCommand;
+import com.cloud.hypervisor.kvm.resource.LibvirtComputingResource;
+import com.cloud.resource.CommandWrapper;
+import com.cloud.resource.ResourceWrapper;
+import org.apache.log4j.Logger;
+import org.libvirt.Connect;
+import org.libvirt.Domain;
+
+@ResourceWrapper(handles=PrepareUnmanageVMInstanceCommand.class)
+public final class LibvirtPrepareUnmanageVMInstanceCommandWrapper extends CommandWrapper<PrepareUnmanageVMInstanceCommand, PrepareUnmanageVMInstanceAnswer, LibvirtComputingResource> {
+    private static final Logger LOGGER = Logger.getLogger(LibvirtPrepareUnmanageVMInstanceCommandWrapper.class);
+    @Override
+    public PrepareUnmanageVMInstanceAnswer execute(PrepareUnmanageVMInstanceCommand command, LibvirtComputingResource libvirtComputingResource) {
+        final String vmName = command.getInstanceName();
+        final LibvirtUtilitiesHelper libvirtUtilitiesHelper = libvirtComputingResource.getLibvirtUtilitiesHelper();
+        LOGGER.debug(String.format("Verify if KVM instance: [%s] is available before Unmanaging VM.", vmName));
+        try {
+            final Connect conn = libvirtUtilitiesHelper.getConnectionByVmName(vmName);
+            final Domain domain = libvirtComputingResource.getDomain(conn, vmName);
+            if (domain == null) {
+                LOGGER.error("Prepare Unmanage VMInstanceCommand: vm not found " + vmName);
+                new PrepareUnmanageVMInstanceAnswer(command, false, String.format("Cannot find VM with name [%s] in KVM host.", vmName));
+            }
+        } catch (Exception e){
+            LOGGER.error("PrepareUnmanagedInstancesCommand failed due to " + e.getMessage());
+            return new PrepareUnmanageVMInstanceAnswer(command, false, "Error: " + e.getMessage());
+        }
+
+        return new PrepareUnmanageVMInstanceAnswer(command, true, "OK");
+    }
+}