[Vmware] Improve listing of Vmware Datacenter VMs for migration to KVM

plugins/hypervisors/vmware/src/main/java/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java

@@ -43,6 +43,7 @@
 import javax.naming.ConfigurationException;
 import javax.persistence.EntityExistsException;
 
+import com.cloud.hypervisor.vmware.mo.VirtualMachineMO;
 import com.cloud.hypervisor.vmware.util.VmwareClient;
 import org.apache.cloudstack.api.command.admin.zone.AddVmwareDcCmd;
 import org.apache.cloudstack.api.command.admin.zone.ImportVsphereStoragePoliciesCmd;
@@ -1587,14 +1588,26 @@
         return compatiblePools;
     }
 
-    @Override
-    public List<UnmanagedInstanceTO> listVMsInDatacenter(ListVmwareDcVmsCmd cmd) {
+    private static class VcenterData {
+        public final String vcenter;
+        public final String datacenterName;
+        public final String username;
+        public final String password;
+
+        public VcenterData(String vcenter, String datacenterName, String username, String password) {
+            this.vcenter = vcenter;
+            this.datacenterName = datacenterName;
+            this.username = username;
+            this.password = password;
+        }
+    }
+
+    private VcenterData getVcenterData(ListVmwareDcVmsCmd cmd) {
         String vcenter = cmd.getVcenter();
         String datacenterName = cmd.getDatacenterName();
         String username = cmd.getUsername();
         String password = cmd.getPassword();
         Long existingVcenterId = cmd.getExistingVcenterId();
-        String keyword = cmd.getKeyword();
 
         if ((existingVcenterId == null && StringUtils.isBlank(vcenter)) ||
                 (existingVcenterId != null && StringUtils.isNotBlank(vcenter))) {
@@ -1615,34 +1628,67 @@
             username = vmwareDc.getUser();
             password = vmwareDc.getPassword();
         }
+        VcenterData vmwaredc = new VcenterData(vcenter, datacenterName, username, password);
+        return vmwaredc;
+    }
+
+    private static VmwareContext getVmwareContext(String vcenter, String username, String password) throws Exception {
+        s_logger.debug(String.format("Connecting to the VMware vCenter %s", vcenter));
+        String serviceUrl = String.format("https://%s/sdk/vimService", vcenter);
+        VmwareClient vimClient = new VmwareClient(vcenter);
+        vimClient.connect(serviceUrl, username, password);
+        return new VmwareContext(vimClient, vcenter);
+    }
+
+    @Override
+    public List<UnmanagedInstanceTO> listVMsInDatacenter(ListVmwareDcVmsCmd cmd) {
+        VcenterData vmwareDC = getVcenterData(cmd);
+        String vcenter = vmwareDC.vcenter;
+        String username = vmwareDC.username;
+        String password = vmwareDC.password;
+        String datacenterName = vmwareDC.datacenterName;
+        String keyword = cmd.getKeyword();
+        String esxiHostName = cmd.getHost();
+        String virtualMachineName = cmd.getInstanceName();
 
         try {
-            s_logger.debug(String.format("Connecting to the VMware datacenter %s at vCenter %s to retrieve VMs",
-                    datacenterName, vcenter));
-            String serviceUrl = String.format("https://%s/sdk/vimService", vcenter);
-            VmwareClient vimClient = new VmwareClient(vcenter);
-            vimClient.connect(serviceUrl, username, password);
-            VmwareContext context = new VmwareContext(vimClient, vcenter);
-
-            DatacenterMO dcMo = new DatacenterMO(context, datacenterName);
-            ManagedObjectReference dcMor = dcMo.getMor();
-            if (dcMor == null) {
-                String msg = String.format("Unable to find VMware datacenter %s in vCenter %s",
-                        datacenterName, vcenter);
-                s_logger.error(msg);
-                throw new InvalidParameterValueException(msg);
+            VmwareContext context = getVmwareContext(vcenter, username, password);
+            DatacenterMO dcMo = getDatacenterMO(context, vcenter, datacenterName);
+
+            List<UnmanagedInstanceTO> instances;
+            if (StringUtils.isNotBlank(esxiHostName) && StringUtils.isNotBlank(virtualMachineName)) {
+                ManagedObjectReference hostMor = dcMo.findHost(esxiHostName);
+                if (hostMor == null) {
+                    String errorMsg = String.format("Cannot find a host with name %s on vcenter %s", esxiHostName, vcenter);
+                    s_logger.error(errorMsg);
+                    throw new CloudRuntimeException(errorMsg);
+                }
+                HostMO hostMO = new HostMO(context, hostMor);
+                VirtualMachineMO vmMo = hostMO.findVmOnHyperHost(virtualMachineName);
+                instances = Collections.singletonList(VmwareHelper.getUnmanagedInstance(hostMO, vmMo));
+            } else {
+                instances = dcMo.getAllVmsOnDatacenter(keyword);
             }
-            List<UnmanagedInstanceTO> instances = dcMo.getAllVmsOnDatacenter();
-            return StringUtils.isBlank(keyword) ? instances :
-                    instances.stream().filter(x -> x.getName().toLowerCase().contains(keyword.toLowerCase())).collect(Collectors.toList());
+            return instances;
         } catch (Exception e) {
-            String errorMsg = String.format("Error retrieving stopped VMs from the VMware VC %s datacenter %s: %s",
+            String errorMsg = String.format("Error retrieving VMs from the VMware VC %s datacenter %s: %s",
                     vcenter, datacenterName, e.getMessage());
             s_logger.error(errorMsg, e);
             throw new CloudRuntimeException(errorMsg);
         }
     }
 
+    private static DatacenterMO getDatacenterMO(VmwareContext context, String vcenter, String datacenterName) throws Exception {
+        DatacenterMO dcMo = new DatacenterMO(context, datacenterName);
+        ManagedObjectReference dcMor = dcMo.getMor();
+        if (dcMor == null) {
+            String msg = String.format("Unable to find VMware datacenter %s in vCenter %s", datacenterName, vcenter);
+            s_logger.error(msg);
+            throw new InvalidParameterValueException(msg);
+        }
+        return dcMo;
+    }
+
     @Override
     public boolean hasNexusVSM(Long clusterId) {
         ClusterVSMMapVO vsmMapVo = null;

plugins/hypervisors/vmware/src/main/java/org/apache/cloudstack/api/command/admin/zone/ListVmwareDcVmsCmd.java

@@ -70,6 +70,12 @@
     @Parameter(name = ApiConstants.PASSWORD, type = CommandType.STRING, description = "The password for specified username.")
     private String password;
 
+    @Parameter(name = ApiConstants.HOST, type = CommandType.STRING, description = "Name of the host on vCenter. Must be set along with the instancename parameter")
+    private String host;
+
+    @Parameter(name = ApiConstants.INSTANCE_NAME, type = CommandType.STRING, description = "Name of the VM on vCenter. Must be set along with the host parameter")
+    private String instanceName;
+
     public String getVcenter() {
         return vcenter;
     }
@@ -86,10 +92,18 @@
         return datacenterName;
     }
 
+    public String getHost() {
+        return host;
+    }
+
     public Long getExistingVcenterId() {
         return existingVcenterId;
     }
 
+    public String getInstanceName() {
+        return instanceName;
+    }
+
     @Override
     public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, NetworkRuleConflictException {
         checkParameters();
@@ -125,6 +139,11 @@
             throw new ServerApiException(ApiErrorCode.PARAM_ERROR,
                     "Please set all the information for a vCenter IP/Name, datacenter, username and password");
         }
+        if ((StringUtils.isNotBlank(instanceName) && StringUtils.isBlank(host)) ||
+                (StringUtils.isBlank(instanceName) && StringUtils.isNotBlank(host))) {
+            throw new ServerApiException(ApiErrorCode.PARAM_ERROR,
+                    "Please set the hostname parameter along with the virtualmachinename parameter");
+        }
     }
 
     @Override

ui/src/views/tools/ManageInstances.vue

@@ -1302,6 +1302,31 @@ export default {
         this.fetchInstances()
       }
     },
+    fetchVmwareInstanceForKVMMigration (vmname, hostname) {
+      const params = {}
+      if (this.isMigrateFromVmware && this.selectedVmwareVcenter) {
+        if (this.selectedVmwareVcenter.vcenter) {
+          params.datacentername = this.selectedVmwareVcenter.datacentername
+          params.vcenter = this.selectedVmwareVcenter.vcenter
+          params.username = this.selectedVmwareVcenter.username
+          params.password = this.selectedVmwareVcenter.password
+        } else {
+          params.existingvcenterid = this.selectedVmwareVcenter.existingvcenterid
+        }
+        params.instancename = vmname
+        params.host = hostname
+      }
+      api('listVmwareDcVms', params).then(json => {
+        const response = json.listvmwaredcvmsresponse
+        this.selectedUnmanagedInstance = response.unmanagedinstance[0]
+        this.selectedUnmanagedInstance.ostypename = this.selectedUnmanagedInstance.osdisplayname
+        this.selectedUnmanagedInstance.state = this.selectedUnmanagedInstance.powerstate
+      }).catch(error => {
+        this.$notifyError(error)
+      }).finally(() => {
+        this.loading = false
+      })
+    },
     onManageInstanceAction () {
       this.selectedUnmanagedInstance = {}
       if (this.unmanagedInstances.length > 0 &&
@@ -1319,6 +1344,9 @@ export default {
           }
         })
         this.showUnmanageForm = false
+      } else if (this.isMigrateFromVmware) {
+        this.fetchVmwareInstanceForKVMMigration(this.selectedUnmanagedInstance.name, this.selectedUnmanagedInstance.hostname)
+        this.showUnmanageForm = true
       } else {
         this.showUnmanageForm = true
       }

ui/src/views/tools/SelectVmwareVcenter.vue

@@ -227,6 +227,8 @@ export default {
       } else {
         params.existingvcenterid = this.selectedExistingVcenterId
       }
+      params.page = 1
+      params.pagesize = 10
       api('listVmwareDcVms', params).then(json => {
         const obj = {
           params: params,
@@ -265,6 +267,11 @@ export default {
         this.loading = false
       })
     },
+    onSelectExternalVmwareDatacenter (value) {
+      if (this.vcenterSelectedOption === 'new' && !(this.vcenter === '' || this.datacentername === '' || this.username === '' || this.password === '')) {
+        this.listVmwareDatacenterVms()
+      }
+    },
     onSelectExistingVmwareDatacenter (value) {
       this.selectedExistingVcenterId = value
     },

vmware-base/src/main/java/com/cloud/hypervisor/vmware/mo/BaseMO.java

@@ -16,6 +16,12 @@
 // under the License.
 package com.cloud.hypervisor.vmware.mo;
 
+import com.cloud.utils.Pair;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.VirtualMachinePowerState;
+import org.apache.cloudstack.vm.UnmanagedInstanceTO;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.log4j.Logger;
 
 import com.vmware.vim25.CustomFieldDef;
@@ -24,12 +30,21 @@
 
 import com.cloud.hypervisor.vmware.util.VmwareContext;
 
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 public class BaseMO {
     private static final Logger s_logger = Logger.getLogger(BaseMO.class);
 
     protected VmwareContext _context;
     protected ManagedObjectReference _mor;
 
+    protected static String[] propertyPathsForUnmanagedVmsThinListing = new String[] {"name", "config.template",
+            "runtime.powerState", "config.guestId", "config.guestFullName", "runtime.host"};
+
     private String _name;
 
     public BaseMO(VmwareContext context, ManagedObjectReference mor) {
@@ -153,4 +168,66 @@
 
         return cfmMo.getCustomFieldKey(morType, fieldName);
     }
+
+    private static UnmanagedInstanceTO.PowerState convertPowerState(VirtualMachinePowerState powerState) {
+        return powerState == VirtualMachinePowerState.POWERED_ON ? UnmanagedInstanceTO.PowerState.PowerOn :
+                powerState == VirtualMachinePowerState.POWERED_OFF ? UnmanagedInstanceTO.PowerState.PowerOff : UnmanagedInstanceTO.PowerState.PowerUnknown;
+    }
+
+    protected List<UnmanagedInstanceTO> convertVmsObjectContentsToUnmanagedInstances(List<ObjectContent> ocs, String keyword) throws Exception {
+        Map<String, Pair<String, String>> hostClusterNamesMap = new HashMap<>();
+        List<UnmanagedInstanceTO> vms = new ArrayList<>();
+        if (ocs != null) {
+            for (ObjectContent oc : ocs) {
+                List<DynamicProperty> objProps = oc.getPropSet();
+                UnmanagedInstanceTO vm = new UnmanagedInstanceTO();
+                if (objProps != null) {
+                    boolean isTemplate = false;
+                    boolean excludeByKeyword = false;
+                    String vmName;
+                    for (DynamicProperty objProp : objProps) {
+                        if (objProp.getName().equals("name")) {
+                            vmName = (String) objProp.getVal();
+                            if (StringUtils.isNotBlank(keyword) && !vmName.contains(keyword)) {
+                                excludeByKeyword = true;
+                            }
+                            vm.setName(vmName);
+                        } else if (objProp.getName().equals("config.template")) {
+                            isTemplate = (Boolean) objProp.getVal();
+                        } else if (objProp.getName().equals("runtime.powerState")) {
+                            VirtualMachinePowerState powerState = (VirtualMachinePowerState) objProp.getVal();
+                            vm.setPowerState(convertPowerState(powerState));
+                        } else if (objProp.getName().equals("config.guestFullName")) {
+                            vm.setOperatingSystem((String) objProp.getVal());
+                        } else if (objProp.getName().equals("config.guestId")) {
+                            vm.setOperatingSystemId((String) objProp.getVal());
+                        } else if (objProp.getName().equals("runtime.host")) {
+                            ManagedObjectReference hostMor = (ManagedObjectReference) objProp.getVal();
+                            if (hostMor != null && StringUtils.isNotBlank(hostMor.getValue())) {
+                                String hostMorValue = hostMor.getValue();
+                                Pair<String, String> hostClusterPair;
+                                if (hostClusterNamesMap.containsKey(hostMorValue)) {
+                                     hostClusterPair = hostClusterNamesMap.get(hostMorValue);
+                                } else {
+                                    HostMO hostMO = new HostMO(_context, hostMor);
+                                    ClusterMO clusterMO = new ClusterMO(_context, hostMO.getHyperHostCluster());
+                                    hostClusterPair = new Pair<>(hostMO.getHostName(), clusterMO.getName());
+                                    hostClusterNamesMap.put(hostMorValue, hostClusterPair);
+                                }
+                                vm.setHostName(hostClusterPair.first());
+                                vm.setClusterName(hostClusterPair.second());
+                            }
+                        }
+                    }
+                    if (!isTemplate && !excludeByKeyword) {
+                        vms.add(vm);
+                    }
+                }
+            }
+        }
+        if (vms.size() > 0) {
+            vms.sort(Comparator.comparing(UnmanagedInstanceTO::getName));
+        }
+        return vms;
+    }
 }

vmware-base/src/main/java/com/cloud/hypervisor/vmware/mo/DatacenterMO.java

@@ -21,7 +21,6 @@
 import java.util.Arrays;
 import java.util.List;
 
-import com.cloud.hypervisor.vmware.util.VmwareHelper;
 import org.apache.cloudstack.vm.UnmanagedInstanceTO;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.log4j.Logger;
@@ -161,28 +160,9 @@
         return null;
     }
 
-    public List<UnmanagedInstanceTO> getAllVmsOnDatacenter() throws Exception {
-        List<UnmanagedInstanceTO> vms = new ArrayList<>();
-        List<ObjectContent> ocs = getVmPropertiesOnDatacenterVmFolder(new String[] {"name"});
-        if (ocs != null) {
-            for (ObjectContent oc : ocs) {
-                ManagedObjectReference vmMor = oc.getObj();
-                if (vmMor != null) {
-                    VirtualMachineMO vmMo = new VirtualMachineMO(_context, vmMor);
-                    try {
-                        if (!vmMo.isTemplate()) {
-                            HostMO hostMO = vmMo.getRunningHost();
-                            UnmanagedInstanceTO unmanagedInstance = VmwareHelper.getUnmanagedInstance(hostMO, vmMo);
-                            vms.add(unmanagedInstance);
-                        }
-                    } catch (Exception e) {
-                        s_logger.debug(String.format("Unexpected error checking unmanaged instance %s, excluding it: %s", vmMo.getVmName(), e.getMessage()), e);
-                    }
-                }
-            }
-        }
-
-        return vms;
+    public List<UnmanagedInstanceTO> getAllVmsOnDatacenter(String keyword) throws Exception {
+        List<ObjectContent> ocs = getVmPropertiesOnDatacenterVmFolder(propertyPathsForUnmanagedVmsThinListing);
+        return convertVmsObjectContentsToUnmanagedInstances(ocs, keyword);
     }
 
     public List<HostMO> getAllHostsOnDatacenter() throws Exception {