openstack
/
watcher
Code Issues Proposed changes

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

This commit is contained in:
Zuul 2019-11-20 03:18:38 +00:00 committed by Gerrit Code Review
parent b3a3c686bf 689ae25ef5
commit cc0c2d227e
10 changed files with 22 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
watcher/decision_engine/strategy/strategies/basic_consolidation.py
View File

@ -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
total_disk = 0
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
used_resources = self.compute_model.get_node_used_resources(
destination_node)
# capacity requested by the compute node
total_cores += instance_to_migrate.vcpus
total_disk += instance_to_migrate.disk
total_mem += instance_to_migrate.memory
total_cores = used_resources['vcpu'] + instance_to_migrate.vcpus
total_disk = used_resources['disk'] + instance_to_migrate.disk
total_mem = used_resources['memory'] + instance_to_migrate.memory
return self.check_threshold(destination_node, total_cores, total_disk,
total_mem)

39
watcher/decision_engine/strategy/strategies/host_maintenance.py
View File

@ -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)
destination_node_free = self.get_node_free(destination_node)
metrics = ['cpu', 'ram']
source_node_used = self.compute_model.get_node_used_resources(
source_node)
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

22
watcher/decision_engine/strategy/strategies/noisy_neighbor.py
View File

@ -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)
cores_available = host.vcpu_capacity - cores_used
disk_available = host.disk_gb_capacity - disk_used
mem_available = host.memory_mb_capacity - mem_used
if (cores_available >= required_cores and disk_available >=
required_disk and mem_available >= required_memory):
free_res = self.compute_model.get_node_free_resources(host)
if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
required_disk and free_res['memory'] >= required_memory):
dest_servers.append(host)
return dest_servers

23
watcher/decision_engine/strategy/strategies/outlet_temp_control.py
View File

@ -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)
cores_available = host.vcpu_capacity - cores_used
disk_available = host.disk_gb_capacity - disk_used
mem_available = host.memory_mb_capacity - mem_used
if cores_available >= required_cores \
and disk_available >= required_disk \
and mem_available >= required_memory:
free_res = self.compute_model.get_node_free_resources(host)
if (free_res['vcpu'] >= required_cores and free_res['disk'] >=
required_disk and free_res['memory'] >= required_memory):
dest_servers.append(instance_data)
return dest_servers

11
watcher/decision_engine/strategy/strategies/uniform_airflow.py
View File

@ -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)
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
used_res = self.compute_model.get_node_used_resources(node)
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

25
watcher/decision_engine/strategy/strategies/workload_balance.py
View File

@ -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(
host)
cores_available = host.vcpu_capacity - cores_used
disk_available = host.disk_gb_capacity - disk_used
mem_available = host.memory_mb_capacity - mem_used
if (cores_available >= required_cores and
mem_available >= required_mem and
disk_available >= required_disk):
free_res = self.compute_model.get_node_free_resources(host)
if (free_res['vcpu'] >= required_cores and
free_res['memory'] >= required_mem and
free_res['disk'] >= required_disk):
if (self._meter == 'instance_cpu_usage' and
((src_instance_workload + workload) <
self.threshold / 100 * host.vcpus)):

16
watcher/tests/decision_engine/strategy/strategies/test_host_maintenance.py
View File

@ -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

9
watcher/tests/decision_engine/strategy/strategies/test_noisy_neighbor.py
View File

@ -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

9
watcher/tests/decision_engine/strategy/strategies/test_outlet_temp_control.py
View File

@ -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

9
watcher/tests/decision_engine/strategy/strategies/test_workload_balance.py
View File

@ -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