openstack
/
nova
Code Issues Proposed changes

virt: use compute.vm_mode constants and validate vm mode type 

Where we have hardcoded vm modes, use compute.vm_mode constants.
Where we get vm modes from external systems, validate them against
the list of acceptable names.

The baremetal/ironic drivers are reporting a bogus vm mode of
'baremetal' for supported instances which is confusing the vm
mode with the Nova driver type. These drivers use the native
ABI for their architecture, so should be reporting 'hvm' as
the vm mode, which indicates an unmodified native OS ABI.

On the other side, the ImagePropertiesFilter will canonicalize
the hvtype it fetches from image metadata, so that 'baremetal'
gets remapped to 'hvm' during comparison.

Closes-bug: #1348629
Change-Id: Ibda7c5ab0759aee672870d84974ccdea25f14407
This commit is contained in:
Daniel P. Berrange 2014-07-25 12:55:40 +01:00
parent 77efa337c5
commit 8fcd1b2c73
10 changed files with 59 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
nova/compute/vm_mode.py
View File

@ -78,6 +78,9 @@ def canonicalize(mode):
if mode == "hv":
mode = HVM
if mode == "baremetal":
mode = HVM
if not is_valid(mode):
raise exception.InvalidVirtualMachineMode(vmmode=mode)

4
nova/tests/compute/test_vmmode.py
View File

@ -53,6 +53,10 @@ class ComputeVMModeTest(test.NoDBTestCase):
mode = vm_mode.canonicalize('hv')
self.assertEqual(vm_mode.HVM, mode)
def test_name_baremetal_compat(self):
mode = vm_mode.canonicalize('baremetal')
self.assertEqual(vm_mode.HVM, mode)
def test_name_hvm(self):
mode = vm_mode.canonicalize('hvm')
self.assertEqual(vm_mode.HVM, mode)

55
nova/tests/scheduler/test_host_filters.py
View File

@ -24,6 +24,7 @@ import stubout
from nova.compute import arch
from nova.compute import hvtype
from nova.compute import vm_mode
from nova import context
from nova import db
from nova import objects
@ -678,13 +679,13 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'_architecture': arch.X86_64,
'hypervisor_type': hvtype.KVM,
'vm_mode': 'hvm',
'vm_mode': vm_mode.HVM,
'hypervisor_version_requires': '>=6.0,<6.2'
}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -694,11 +695,11 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.ARMV7,
'hypervisor_type': hvtype.QEMU,
'vm_mode': 'hvm'}}
'vm_mode': vm_mode.HVM}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
@ -708,13 +709,13 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'hypervisor_type': hvtype.KVM,
'vm_mode': 'hvm',
'vm_mode': vm_mode.HVM,
'hypervisor_version_requires': '>=6.2'}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'enabled': True,
'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
@ -723,11 +724,11 @@ class HostFiltersTestCase(test.NoDBTestCase):
self._stub_service_is_up(True)
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'vm_mode': 'hvm'}}
'vm_mode': vm_mode.HVM}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -736,11 +737,11 @@ class HostFiltersTestCase(test.NoDBTestCase):
self._stub_service_is_up(True)
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'vm_mode': 'hvm'}}
'vm_mode': vm_mode.HVM}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.XEN, 'xen')],
[(arch.X86_64, hvtype.XEN, vm_mode.XEN)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
@ -751,7 +752,7 @@ class HostFiltersTestCase(test.NoDBTestCase):
filter_properties = {'request_spec': {}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -761,7 +762,7 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'hypervisor_type': hvtype.KVM,
'vm_mode': 'hvm'}}
'vm_mode': vm_mode.HVM}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'enabled': True,
@ -774,12 +775,12 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'hypervisor_type': hvtype.KVM,
'vm_mode': 'hvm',
'vm_mode': vm_mode.HVM,
'hypervisor_version_requires': '>=6.0'}}
filter_properties = {'request_spec': {'image': img_props}}
capabilities = {'enabled': True,
'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')]}
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)]}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -788,12 +789,12 @@ class HostFiltersTestCase(test.NoDBTestCase):
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'architecture': arch.X86_64,
'hypervisor_type': hvtype.KVM,
'vm_mode': 'hvm',
'vm_mode': vm_mode.HVM,
'hypervisor_version_requires': '>=6.0'}}
filter_properties = {'request_spec': {'image': img_props}}
capabilities = {'enabled': True,
'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': 5000}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
@ -806,7 +807,7 @@ class HostFiltersTestCase(test.NoDBTestCase):
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.XEN, 'xen')],
[(arch.X86_64, hvtype.XEN, vm_mode.XEN)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -819,7 +820,7 @@ class HostFiltersTestCase(test.NoDBTestCase):
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.X86_64, hvtype.KVM, 'hvm')],
[(arch.X86_64, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -832,7 +833,7 @@ class HostFiltersTestCase(test.NoDBTestCase):
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.I686, hvtype.KVM, 'hvm')],
[(arch.I686, hvtype.KVM, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@ -845,7 +846,21 @@ class HostFiltersTestCase(test.NoDBTestCase):
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.I686, hvtype.XEN, 'hvm')],
[(arch.I686, hvtype.XEN, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def test_image_properties_filter_baremetal_vmmode_compat(self):
# if an old image has 'baremetal' for vmmode it should be
# treated as hvm
self._stub_service_is_up(True)
filt_cls = self.class_map['ImagePropertiesFilter']()
img_props = {'properties': {'vm_mode': 'baremetal'}}
filter_properties = {'request_spec': {'image': img_props}}
hypervisor_version = utils.convert_version_to_int('6.0.0')
capabilities = {'supported_instances':
[(arch.I686, hvtype.BAREMETAL, vm_mode.HVM)],
'hypervisor_version': hypervisor_version}
host = fakes.FakeHostState('host1', 'node1', capabilities)
self.assertTrue(filt_cls.host_passes(host, filter_properties))

2
nova/tests/virt/baremetal/test_driver.py
View File

@ -397,7 +397,7 @@ class BareMetalDriverWithDBTestCase(bm_db_base.BMDBTestCase):
node['node_info']['memory_mb'])
self.assertEqual(resources['memory_mb_used'], 0)
self.assertEqual(resources['supported_instances'],
'[["x86_64", "baremetal", "baremetal"]]')
'[["x86_64", "baremetal", "hvm"]]')
self.assertEqual(resources['stats'],
'{"cpu_arch": "x86_64", "baremetal_driver": '
'"nova.virt.baremetal.fake.FakeDriver", '

3
nova/virt/baremetal/driver.py
View File

@ -27,6 +27,7 @@ from nova.compute import flavors
from nova.compute import hvtype
from nova.compute import power_state
from nova.compute import task_states
from nova.compute import vm_mode
from nova import context as nova_context
from nova import exception
from nova.i18n import _
@ -155,7 +156,7 @@ class BareMetalDriver(driver.ComputeDriver):
self.supported_instances = [(
arch.canonicalize(extra_specs['cpu_arch']),
hvtype.BAREMETAL,
'baremetal'
vm_mode.HVM
), ]
@classmethod

5
nova/virt/hyperv/hostops.py
View File

@ -25,6 +25,7 @@ from oslo.config import cfg
from nova.compute import arch
from nova.compute import hvtype
from nova.compute import vm_mode
from nova.openstack.common import jsonutils
from nova.openstack.common import log as logging
from nova.openstack.common import units
@ -131,8 +132,8 @@ class HostOps(object):
'vcpus_used': 0,
'cpu_info': jsonutils.dumps(cpu_info),
'supported_instances': jsonutils.dumps(
[(arch.I686, hvtype.HYPERV, 'hvm'),
(arch.X86_64, hvtype.HYPERV, 'hvm')]),
[(arch.I686, hvtype.HYPERV, vm_mode.HVM),
(arch.X86_64, hvtype.HYPERV, vm_mode.HVM)]),
'numa_topology': None,
}

6
nova/virt/ironic/driver.py
View File

@ -27,8 +27,10 @@ from oslo.config import cfg
import six
from nova.compute import arch
from nova.compute import hvtype
from nova.compute import power_state
from nova.compute import task_states
from nova.compute import vm_mode
from nova import context as nova_context
from nova import exception
from nova.i18n import _
@ -120,7 +122,9 @@ def _get_nodes_supported_instances(cpu_arch=None):
"""Return supported instances for a node."""
if not cpu_arch:
return []
return [(cpu_arch, 'baremetal', 'baremetal')]
return [(cpu_arch,
hvtype.BAREMETAL,
vm_mode.HVM)]
def _log_ironic_polling(what, node, instance):

2
nova/virt/libvirt/driver.py
View File

@ -4699,7 +4699,7 @@ class LibvirtDriver(driver.ComputeDriver):
instance_cap = (
arch.canonicalize(g.arch),
hvtype.canonicalize(dt),
g.ostype)
vm_mode.canonicalize(g.ostype))
instance_caps.append(instance_cap)
return instance_caps

5
nova/virt/vmwareapi/host.py
View File

@ -19,6 +19,7 @@ Management class for host-related functions (start, reboot, etc).
from nova.compute import arch
from nova.compute import hvtype
from nova.compute import vm_mode
from nova import exception
from nova.openstack.common import log as logging
from nova.openstack.common import units
@ -92,8 +93,8 @@ class HostState(object):
str(summary.config.product.version))
data["hypervisor_hostname"] = self._host_name
data["supported_instances"] = [
(arch.I686, hvtype.VMWARE, 'hvm'),
(arch.X86_64, hvtype.VMWARE, 'hvm')]
(arch.I686, hvtype.VMWARE, vm_mode.HVM),
(arch.X86_64, hvtype.VMWARE, vm_mode.HVM)]
self._stats = data
return data

2
nova/virt/xenapi/host.py
View File

@ -24,6 +24,7 @@ from oslo.config import cfg
from nova.compute import arch
from nova.compute import hvtype
from nova.compute import task_states
from nova.compute import vm_mode
from nova.compute import vm_states
from nova import context
from nova import exception
@ -285,6 +286,7 @@ def to_supported_instances(host_capabilities):
ostype, _version, guestarch = capability.split("-")
guestarch = arch.canonicalize(guestarch)
ostype = vm_mode.canonicalize(ostype)
result.append((guestarch, hvtype.XEN, ostype))
except ValueError: