Calculate memory_mb_max_unit based on instance's memory_mb

Previously the memory_mb_max_unit was relying on the
overallMemoryUsage reported by the ESXi, which was wrong, because
the host could still have a big VM with reserved memory, that was
not consuming any RAM and thus not reflected in the memory usage.

We are now looking for the instances spawned on that ESXi and
subtract their configured memory_mb from the total RAM capacity
of the host, resulting in a realistic memory_mb_max_unit.

Change-Id: I72821c97d80f9f675dca943d65f94e36824d81b6

Author: leust

nova/tests/unit/virt/vmwareapi/test_driver_api.py

@@ -2377,8 +2377,8 @@ def test_get_available_resource(self):
                 stats['supported_instances'])
         memory_mbmax_unit = stats['stats']['memory_mb_max_unit']
         vcpus_max_unit = stats['stats']['vcpus_max_unit']
-        # memory_mb_used = fake.HostSystem.overallMemoryUsage = 500
-        self.assertEqual(memory_mbmax_unit, 1024 - 500)
+        # memory_mb_used = fake.HostSystem.hardware.memorySize = 1024
+        self.assertEqual(memory_mbmax_unit, 1024)
         # vcpus_max_unit = fake.HostSystem.summary.hardware.numCpuThreads
         self.assertEqual(vcpus_max_unit, 16)
 

nova/virt/vmwareapi/driver.py

@@ -405,7 +405,10 @@ def _get_cluster_stats(self, host_stats):
         # memory_mb_max_unit represents the free memory of the freest host
         # available in the cluster. Can be used by the scheduler to determine
         # if the cluster can accommodate a big VM.
-        memory_mb_max_unit = 0
+        # It's calculated by looking at the configured memoryMB of each instance
+        # in that host, not taking into account the actual memory usage.
+        memory_mb_max_unit = max(
+            mem for mem in self._vmops.get_available_memory_per_host().values())
         # vcpus_max_unit represents the vCPUs of a physical node from the
         # cluster. It can be used to determine if a VM can be powered-on in
         # this cluster, by comparing its flavor.vcpus to this value.
@@ -414,11 +417,6 @@ def _get_cluster_stats(self, host_stats):
             # Skip the cluster node
             if nodename == self._nodename:
                 continue
-            memory_mb_free = (resources['memory_mb'] -
-                              resources['memory_mb_used'])
-            if memory_mb_max_unit < memory_mb_free:
-                memory_mb_max_unit = memory_mb_free
-
             vcpus = resources['vcpus']
             if vcpus_max_unit < vcpus:
                 vcpus_max_unit = vcpus

nova/virt/vmwareapi/vmops.py

@@ -18,6 +18,7 @@
 """
 Class for VM tasks like spawn, snapshot, suspend, resume etc.
 """
+import collections
 
 import contextlib
 import copy
@@ -4808,3 +4809,56 @@ def check_can_live_migrate_source(self, instance):
                 raise exception.MigrationPreCheckError(
                         reason=("Found non-configdrive CD-ROM. "
                                 "Can only migrate configdrive"))
+
+    def get_available_memory_per_host(self):
+        """Retrieve per-host available RAM.
+
+        The value is calculated by subtracting the total configured
+        memory_mb of the instances residing on that host from the
+        total memory size of the host.
+
+        Returns a dict containing available RAM information per host.
+        {
+            "host-ref-value": 1024
+        }
+        """
+        (host_mors, _) = vm_util.get_hosts_and_reservations_for_cluster(
+                            self._session, self._cluster)
+
+        ram_per_host = {}
+        # initialize ram_per_host with the hosts in the expected state
+        # and their total memorySize.
+        result = self._session._call_method(vim_util,
+                            "get_properties_for_a_collection_of_objects",
+                            "HostSystem", host_mors,
+                            ["summary.runtime", "summary.hardware"])
+        with vutil.WithRetrieval(self._session.vim, result) as objects:
+            for obj in objects:
+                host_props = vutil.propset_dict(obj.propSet)
+                runtime_summary = host_props['summary.runtime']
+                if (runtime_summary.inMaintenanceMode or
+                        runtime_summary.connectionState != "connected"):
+                    continue
+                host_ref_value = vutil.get_moref_value(obj.obj)
+                hardware_summary = host_props.get("summary.hardware")
+                mem_size = getattr(hardware_summary, "memorySize", 0)
+                ram_per_host[host_ref_value] = mem_size // units.Mi
+
+        props = ['config.hardware.memoryMB', 'runtime.host']
+        vms = self._list_instances_in_cluster(additional_properties=props)
+
+        for (vm_uuid, vm_props) in vms:
+            host_obj = vm_props.get('runtime.host')
+            if not host_obj:
+                continue
+            host_ref_value = vutil.get_moref_value(host_obj)
+            if host_ref_value not in ram_per_host:
+                continue
+
+            vm_mb = vm_props.get('config.hardware.memoryMB', 0)
+
+            # make sure the minimum available memory >= 0
+            ram_per_host[host_ref_value] = \
+                max(ram_per_host[host_ref_value] - vm_mb, 0)
+
+        return ram_per_host