Merge "Refactoring the codes about getting used and free resources"

watcher/decision_engine/strategy/strategies/basic_consolidation.py

@@ -201,19 +201,13 @@ class BasicConsolidation(base.ServerConsolidationBaseStrategy):
         LOG.debug('Migrate instance %s from %s to  %s',
                   instance_to_migrate, source_node, destination_node)
 
-        total_cores = 0
+        used_resources = self.compute_model.get_node_used_resources(
-        total_disk = 0
+            destination_node)
-        total_mem = 0
-        for instance in self.compute_model.get_node_instances(
-                destination_node):
-            total_cores += instance.vcpus
-            total_disk += instance.disk
-            total_mem += instance.memory
 
         # capacity requested by the compute node
-        total_cores += instance_to_migrate.vcpus
+        total_cores = used_resources['vcpu'] + instance_to_migrate.vcpus
-        total_disk += instance_to_migrate.disk
+        total_disk = used_resources['disk'] + instance_to_migrate.disk
-        total_mem += instance_to_migrate.memory
+        total_mem = used_resources['memory'] + instance_to_migrate.memory
 
         return self.check_threshold(destination_node, total_cores, total_disk,
                                     total_mem)

watcher/decision_engine/strategy/strategies/host_maintenance.py

@@ -137,37 +137,6 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
                     ram=node.memory_mb_capacity,
                     disk=node.disk_gb_capacity)
 
-    def get_node_used(self, node):
-        """Collect cpu, ram and disk used of a node.
-
-        :param node: node object
-        :return: dict(cpu(cores), ram(MB), disk(B))
-        """
-        vcpus_used = 0
-        memory_used = 0
-        disk_used = 0
-        for instance in self.compute_model.get_node_instances(node):
-            vcpus_used += instance.vcpus
-            memory_used += instance.memory
-            disk_used += instance.disk
-
-        return dict(cpu=vcpus_used,
-                    ram=memory_used,
-                    disk=disk_used)
-
-    def get_node_free(self, node):
-        """Collect cpu, ram and disk free of a node.
-
-        :param node: node object
-        :return: dict(cpu(cores), ram(MB), disk(B))
-        """
-        node_capacity = self.get_node_capacity(node)
-        node_used = self.get_node_used(node)
-        return dict(cpu=node_capacity['cpu']-node_used['cpu'],
-                    ram=node_capacity['ram']-node_used['ram'],
-                    disk=node_capacity['disk']-node_used['disk'],
-                    )
-
     def host_fits(self, source_node, destination_node):
         """check host fits
 
@@ -175,9 +144,11 @@ class HostMaintenance(base.HostMaintenanceBaseStrategy):
         from source_node to destination_node.
         """
 
-        source_node_used = self.get_node_used(source_node)
+        source_node_used = self.compute_model.get_node_used_resources(
-        destination_node_free = self.get_node_free(destination_node)
+            source_node)
-        metrics = ['cpu', 'ram']
+        destination_node_free = self.compute_model.get_node_free_resources(
+            destination_node)
+        metrics = ['vcpu', 'memory']
         for m in metrics:
             if source_node_used[m] > destination_node_free[m]:
                 return False

watcher/decision_engine/strategy/strategies/noisy_neighbor.py

@@ -208,19 +208,6 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
 
         return hosts_need_release, hosts_target
 
-    def calc_used_resource(self, node):
-        """Calculate the used vcpus, memory and disk based on VM flavors"""
-        instances = self.compute_model.get_node_instances(node)
-        vcpus_used = 0
-        memory_mb_used = 0
-        disk_gb_used = 0
-        for instance in instances:
-            vcpus_used += instance.vcpus
-            memory_mb_used += instance.memory
-            disk_gb_used += instance.disk
-
-        return vcpus_used, memory_mb_used, disk_gb_used
-
     def filter_dest_servers(self, hosts, instance_to_migrate):
         required_cores = instance_to_migrate.vcpus
         required_disk = instance_to_migrate.disk
@@ -228,12 +215,9 @@ class NoisyNeighbor(base.NoisyNeighborBaseStrategy):
 
         dest_servers = []
         for host in hosts:
-            cores_used, mem_used, disk_used = self.calc_used_resource(host)
+            free_res = self.compute_model.get_node_free_resources(host)
-            cores_available = host.vcpu_capacity - cores_used
+            if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
-            disk_available = host.disk_gb_capacity - disk_used
+                    required_disk and free_res['memory'] >= required_memory):
-            mem_available = host.memory_mb_capacity - mem_used
-            if (cores_available >= required_cores and disk_available >=
-                    required_disk and mem_available >= required_memory):
                 dest_servers.append(host)
 
         return dest_servers

watcher/decision_engine/strategy/strategies/outlet_temp_control.py

@@ -140,19 +140,6 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
                 if cn.state == element.ServiceState.ONLINE.value and
                 cn.status in default_node_scope}
 
-    def calc_used_resource(self, node):
-        """Calculate the used vcpus, memory and disk based on VM flavors"""
-        instances = self.compute_model.get_node_instances(node)
-        vcpus_used = 0
-        memory_mb_used = 0
-        disk_gb_used = 0
-        for instance in instances:
-            vcpus_used += instance.vcpus
-            memory_mb_used += instance.memory
-            disk_gb_used += instance.disk
-
-        return vcpus_used, memory_mb_used, disk_gb_used
-
     def group_hosts_by_outlet_temp(self):
         """Group hosts based on outlet temp meters"""
         nodes = self.get_available_compute_nodes()
@@ -222,13 +209,9 @@ class OutletTempControl(base.ThermalOptimizationBaseStrategy):
         for instance_data in hosts:
             host = instance_data['compute_node']
             # available
-            cores_used, mem_used, disk_used = self.calc_used_resource(host)
+            free_res = self.compute_model.get_node_free_resources(host)
-            cores_available = host.vcpu_capacity - cores_used
+            if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
-            disk_available = host.disk_gb_capacity - disk_used
+                    required_disk and free_res['memory'] >= required_memory):
-            mem_available = host.memory_mb_capacity - mem_used
-            if cores_available >= required_cores \
-                    and disk_available >= required_disk \
-                    and mem_available >= required_memory:
                 dest_servers.append(instance_data)
 
         return dest_servers

watcher/decision_engine/strategy/strategies/uniform_airflow.py

@@ -135,16 +135,9 @@ class UniformAirflow(base.BaseStrategy):
 
     def calculate_used_resource(self, node):
         """Compute the used vcpus, memory and disk based on instance flavors"""
-        instances = self.compute_model.get_node_instances(node)
+        used_res = self.compute_model.get_node_used_resources(node)
-        vcpus_used = 0
-        memory_mb_used = 0
-        disk_gb_used = 0
-        for instance in instances:
-            vcpus_used += instance.vcpus
-            memory_mb_used += instance.memory
-            disk_gb_used += instance.disk
 
-        return vcpus_used, memory_mb_used, disk_gb_used
+        return used_res['vcpu'], used_res['memory'], used_res['disk']
 
     def choose_instance_to_migrate(self, hosts):
         """Pick up an active instance instance to migrate from provided hosts

watcher/decision_engine/strategy/strategies/workload_balance.py

@@ -132,19 +132,6 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
                 if cn.state == element.ServiceState.ONLINE.value and
                 cn.status in default_node_scope}
 
-    def calculate_used_resource(self, node):
-        """Calculate the used vcpus, memory and disk based on VM flavors"""
-        instances = self.compute_model.get_node_instances(node)
-        vcpus_used = 0
-        memory_mb_used = 0
-        disk_gb_used = 0
-        for instance in instances:
-            vcpus_used += instance.vcpus
-            memory_mb_used += instance.memory
-            disk_gb_used += instance.disk
-
-        return vcpus_used, memory_mb_used, disk_gb_used
-
     def choose_instance_to_migrate(self, hosts, avg_workload, workload_cache):
         """Pick up an active instance instance to migrate from provided hosts
 
@@ -203,14 +190,10 @@ class WorkloadBalance(base.WorkloadStabilizationBaseStrategy):
             host = instance_data['compute_node']
             workload = instance_data['workload']
             # calculate the available resources
-            cores_used, mem_used, disk_used = self.calculate_used_resource(
+            free_res = self.compute_model.get_node_free_resources(host)
-                host)
+            if (free_res['vcpu'] >= required_cores and
-            cores_available = host.vcpu_capacity - cores_used
+                    free_res['memory'] >= required_mem and
-            disk_available = host.disk_gb_capacity - disk_used
+                    free_res['disk'] >= required_disk):
-            mem_available = host.memory_mb_capacity - mem_used
-            if (cores_available >= required_cores and
-                    mem_available >= required_mem and
-                    disk_available >= required_disk):
                 if (self._meter == 'instance_cpu_usage' and
                     ((src_instance_workload + workload) <
                      self.threshold / 100 * host.vcpus)):

watcher/tests/decision_engine/strategy/strategies/test_host_maintenance.py

@@ -70,22 +70,6 @@ class TestHostMaintenance(TestBaseStrategy):
         self.assertEqual(node_capacity,
                          self.strategy.get_node_capacity(node_0))
 
-    def test_get_node_used(self):
-        model = self.fake_c_cluster.generate_scenario_1()
-        self.m_c_model.return_value = model
-        node_0 = model.get_node_by_uuid("Node_0")
-        node_used = dict(cpu=20, ram=4, disk=40)
-        self.assertEqual(node_used,
-                         self.strategy.get_node_used(node_0))
-
-    def test_get_node_free(self):
-        model = self.fake_c_cluster.generate_scenario_1()
-        self.m_c_model.return_value = model
-        node_0 = model.get_node_by_uuid("Node_0")
-        node_free = dict(cpu=20, ram=128, disk=210)
-        self.assertEqual(node_free,
-                         self.strategy.get_node_free(node_0))
-
     def test_host_fits(self):
         model = self.fake_c_cluster.generate_scenario_1()
         self.m_c_model.return_value = model

watcher/tests/decision_engine/strategy/strategies/test_noisy_neighbor.py

@@ -60,15 +60,6 @@ class TestNoisyNeighbor(TestBaseStrategy):
         self.strategy.input_parameters.update({'period': 100})
         self.strategy.threshold = 100
 
-    def test_calc_used_resource(self):
-        model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
-        self.m_c_model.return_value = model
-        node = model.get_node_by_uuid("fa69c544-906b-4a6a-a9c6-c1f7a8078c73")
-        cores_used, mem_used, disk_used = self.strategy.calc_used_resource(
-            node)
-
-        self.assertEqual((10, 2, 20), (cores_used, mem_used, disk_used))
-
     def test_group_hosts(self):
         self.strategy.cache_threshold = 35
         self.strategy.period = 100

watcher/tests/decision_engine/strategy/strategies/test_outlet_temp_control.py

@@ -60,15 +60,6 @@ class TestOutletTempControl(TestBaseStrategy):
         self.strategy.input_parameters.update({'threshold': 34.3})
         self.strategy.threshold = 34.3
 
-    def test_calc_used_resource(self):
-        model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
-        self.m_c_model.return_value = model
-        node = model.get_node_by_uuid("fa69c544-906b-4a6a-a9c6-c1f7a8078c73")
-        cores_used, mem_used, disk_used = self.strategy.calc_used_resource(
-            node)
-
-        self.assertEqual((10, 2, 20), (cores_used, mem_used, disk_used))
-
     def test_group_hosts_by_outlet_temp(self):
         model = self.fake_c_cluster.generate_scenario_3_with_2_nodes()
         self.m_c_model.return_value = model

watcher/tests/decision_engine/strategy/strategies/test_workload_balance.py

@@ -64,15 +64,6 @@ class TestWorkloadBalance(TestBaseStrategy):
         self.strategy._meter = 'instance_cpu_usage'
         self.strategy._granularity = 300
 
-    def test_calc_used_resource(self):
-        model = self.fake_c_cluster.generate_scenario_6_with_2_nodes()
-        self.m_c_model.return_value = model
-        node = model.get_node_by_uuid('Node_0')
-        cores_used, mem_used, disk_used = (
-            self.strategy.calculate_used_resource(node))
-
-        self.assertEqual((cores_used, mem_used, disk_used), (20, 64, 40))
-
     def test_group_hosts_by_cpu_util(self):
         model = self.fake_c_cluster.generate_scenario_6_with_2_nodes()
         self.m_c_model.return_value = model