openstack
/
zun
Code Issues Proposed changes

Merge "Refactor get_available_resources"

This commit is contained in:
Zuul 2019-05-17 02:00:45 +00:00 committed by Gerrit Code Review
parent 37e2463835 9776a098b2
commit 18601ad876
3 changed files with 66 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
zun/compute/compute_node_tracker.py
View File

@ -53,26 +53,36 @@ class ComputeNodeTracker(object):
compute_node.pci_device_pools = dev_pools_obj
def update_available_resources(self, context):
resources = self.container_driver.get_available_resources()
# Check if the compute_node is already registered
node = self._get_compute_node(context)
if not node:
# If not, register it and pass the object to the driver
numa_obj = self.container_driver.get_host_numa_topology()
node = objects.ComputeNode(context)
node.hostname = self.host
node.numa_topology = numa_obj
node.disk_quota_supported = \
self.container_driver.node_support_disk_quota()
node.enable_cpu_pinning = CONF.compute.enable_cpu_pinning
self._copy_resources(node, resources)
node.create(context)
LOG.info('Node created for :%(host)s', {'host': self.host})
self.container_driver.get_available_resources(node)
else:
self._copy_resources(node, resources)
self._setup_pci_tracker(context, node)
self.compute_node = node
self._update_available_resource(context)
# NOTE(sbiswas7): Consider removing the return statement if not needed
return node
def _copy_resources(self, node, resources):
keys = ["numa_topology", "mem_total", "mem_free", "mem_available",
"mem_used", "total_containers", "running_containers",
"paused_containers", "stopped_containers", "cpus",
"architecture", "os_type", "os", "kernel_version", "cpu_used",
"labels", "disk_total", "disk_quota_supported", "runtimes",
"enable_cpu_pinning"]
for key in keys:
if key in resources:
setattr(node, key, resources[key])
def _get_compute_node(self, context):
"""Returns compute node for the host"""
try:

53
zun/container/driver.py
View File

@ -205,34 +205,45 @@ class ContainerDriver(object):
def get_available_nodes(self):
pass
def get_available_resources(self, node):
def get_available_resources(self):
"""Retrieve resource information.
This method is called when nova-compute launches, and
as part of a periodic task that records the results in the DB.
:returns: dictionary containing resource info
"""
data = {}
numa_topo_obj = self.get_host_numa_topology()
node.numa_topology = numa_topo_obj
data['numa_topology'] = numa_topo_obj
meminfo = self.get_host_mem()
(mem_total, mem_free, mem_ava, mem_used) = meminfo
node.mem_total = mem_total // units.Ki
node.mem_free = mem_free // units.Ki
node.mem_available = mem_ava // units.Ki
node.mem_used = mem_used // units.Ki
data['mem_total'] = mem_total // units.Ki
data['mem_free'] = mem_free // units.Ki
data['mem_available'] = mem_ava // units.Ki
data['mem_used'] = mem_used // units.Ki
info = self.get_host_info()
node.total_containers = info['total_containers']
node.running_containers = info['running_containers']
node.paused_containers = info['paused_containers']
node.stopped_containers = info['stopped_containers']
node.cpus = info['cpus']
node.architecture = info['architecture']
node.os_type = info['os_type']
node.os = info['os']
node.kernel_version = info['kernel_version']
data['total_containers'] = info['total_containers']
data['running_containers'] = info['running_containers']
data['paused_containers'] = info['paused_containers']
data['stopped_containers'] = info['stopped_containers']
data['cpus'] = info['cpus']
data['architecture'] = info['architecture']
data['os_type'] = info['os_type']
data['os'] = info['os']
data['kernel_version'] = info['kernel_version']
cpu_used = self.get_cpu_used()
node.cpu_used = cpu_used
node.labels = info['labels']
data['cpu_used'] = cpu_used
data['labels'] = info['labels']
disk_total = self.get_total_disk_for_container()
node.disk_total = disk_total
data['disk_total'] = disk_total
disk_quota_supported = self.node_support_disk_quota()
node.disk_quota_supported = disk_quota_supported
node.runtimes = info['runtimes']
node.enable_cpu_pinning = info['enable_cpu_pinning']
data['disk_quota_supported'] = disk_quota_supported
data['runtimes'] = info['runtimes']
data['enable_cpu_pinning'] = info['enable_cpu_pinning']
return data
def node_is_available(self, nodename):
"""Return whether this compute service manages a particular node."""

38
zun/tests/unit/container/docker/test_docker_driver.py
View File

@ -22,7 +22,6 @@ from zun.common import exception
from zun import conf
from zun.container.docker.driver import DockerDriver
from zun.container.docker import utils as docker_utils
from zun import objects
from zun.objects.container import Container
from zun.tests.unit.container import base
from zun.tests.unit.db import utils
@ -941,22 +940,21 @@ class TestDockerDriver(base.DriverTestCase):
'docker_root_dir': '/var/lib/docker'}
mock_cpu_used.return_value = 1.0
mock_disk.return_value = 80
node_obj = objects.ComputeNode()
self.driver.get_available_resources(node_obj)
self.assertEqual(_numa_topo_spec, node_obj.numa_topology.to_list())
self.assertEqual(node_obj.mem_total, 100)
self.assertEqual(node_obj.mem_free, 50)
self.assertEqual(node_obj.mem_available, 50)
self.assertEqual(10, node_obj.total_containers)
self.assertEqual(8, node_obj.running_containers)
self.assertEqual(0, node_obj.paused_containers)
self.assertEqual(2, node_obj.stopped_containers)
self.assertEqual(48, node_obj.cpus)
self.assertEqual(1.0, node_obj.cpu_used)
self.assertEqual('x86_64', node_obj.architecture)
self.assertEqual('linux', node_obj.os_type)
self.assertEqual('CentOS', node_obj.os)
self.assertEqual('3.10.0-123', node_obj.kernel_version)
self.assertEqual({'dev.type': 'product'}, node_obj.labels)
self.assertEqual(80, node_obj.disk_total)
self.assertEqual(['runc'], node_obj.runtimes)
data = self.driver.get_available_resources()
self.assertEqual(_numa_topo_spec, data['numa_topology'].to_list())
self.assertEqual(100, data['mem_total'])
self.assertEqual(50, data['mem_free'], 50)
self.assertEqual(50, data['mem_available'])
self.assertEqual(10, data['total_containers'])
self.assertEqual(8, data['running_containers'])
self.assertEqual(0, data['paused_containers'])
self.assertEqual(2, data['stopped_containers'])
self.assertEqual(48, data['cpus'])
self.assertEqual(1.0, data['cpu_used'])
self.assertEqual('x86_64', data['architecture'])
self.assertEqual('linux', data['os_type'])
self.assertEqual('CentOS', data['os'])
self.assertEqual('3.10.0-123', data['kernel_version'])
self.assertEqual({'dev.type': 'product'}, data['labels'])
self.assertEqual(80, data['disk_total'])
self.assertEqual(['runc'], data['runtimes'])