def _get_fake_host_state_with_networks(self):
network_a = objects.NetworkMetadata(physnets=set(['foo', 'bar']),
tunneled=False)
network_b = objects.NetworkMetadata(physnets=set(), tunneled=True)
host_topology = objects.NUMATopology(cells=[
objects.NUMACell(id=1,
cpuset=set([1, 2]),
pcpuset=set(),
memory=2048,
cpu_usage=2,
memory_usage=2048,
mempages=[],
siblings=[set([1]), set([2])],
pinned_cpus=set(),
network_metadata=network_a),
objects.NUMACell(id=2,
cpuset=set([3, 4]),
pcpuset=set(),
memory=2048,
cpu_usage=2,
memory_usage=2048,
mempages=[],
siblings=[set([3]), set([4])],
pinned_cpus=set(),
network_metadata=network_b)
])
return fakes.FakeHostState(
'host1', 'node1', {
'numa_topology': host_topology,
'pci_stats': None,
'cpu_allocation_ratio': 16.0,
'ram_allocation_ratio': 1.5
})
def test_obj_make_compatible(self):
network_metadata = objects.NetworkMetadata(physnets=set(['foo',
'bar']),
tunneled=True)
cell = objects.NUMACell(id=0,
socket=0,
cpuset=set([1, 2]),
pcpuset=set([3, 4]),
memory=32,
cpu_usage=10,
pinned_cpus=set([3, 4]),
siblings=[set([5, 6])],
network_metadata=network_metadata)
versions = ovo_base.obj_tree_get_versions('NUMACell')
primitive = cell.obj_to_primitive(target_version='1.5',
version_manifest=versions)
self.assertIn('socket', primitive['nova_object.data'])
primitive = cell.obj_to_primitive(target_version='1.4',
version_manifest=versions)
self.assertIn('pcpuset', primitive['nova_object.data'])
self.assertNotIn('socket', primitive['nova_object.data'])
primitive = cell.obj_to_primitive(target_version='1.3',
version_manifest=versions)
self.assertNotIn('pcpuset', primitive['nova_object.data'])
self.assertIn('network_metadata', primitive['nova_object.data'])
primitive = cell.obj_to_primitive(target_version='1.2',
version_manifest=versions)
self.assertNotIn('network_metadata', primitive['nova_object.data'])
def test_compat_network_metadata(self):
network_metadata = objects.NetworkMetadata(physnets=set(),
tunneled=False)
req_obj = objects.RequestSpec(network_metadata=network_metadata,
user_id=fakes.FAKE_USER_ID)
versions = ovo_base.obj_tree_get_versions('RequestSpec')
primitive = req_obj.obj_to_primitive(target_version='1.9',
version_manifest=versions)
primitive = primitive['nova_object.data']
self.assertNotIn('network_metadata', primitive)
self.assertIn('user_id', primitive)
def test_numa_topology_filter_pass_networks(self):
host = self._get_fake_host_state_with_networks()
instance_topology = objects.InstanceNUMATopology(cells=[
objects.InstanceNUMACell(id=0, cpuset=set([1]), memory=512),
objects.InstanceNUMACell(id=1, cpuset=set([3]), memory=512)])
network_metadata = objects.NetworkMetadata(
physnets=set(['foo']), tunneled=False)
spec_obj = self._get_spec_obj(numa_topology=instance_topology,
network_metadata=network_metadata)
self.assertTrue(self.filt_cls.host_passes(host, spec_obj))
# this should pass because while the networks are affined to different
# host NUMA nodes, our guest itself has multiple NUMA nodes
network_metadata = objects.NetworkMetadata(
physnets=set(['foo', 'bar']), tunneled=True)
spec_obj = self._get_spec_obj(numa_topology=instance_topology,
network_metadata=network_metadata)
self.assertTrue(self.filt_cls.host_passes(host, spec_obj))
def test_numa_topology_filter_fail_networks(self):
host = self._get_fake_host_state_with_networks()
instance_topology = objects.InstanceNUMATopology(cells=[
objects.InstanceNUMACell(id=0, cpuset=set([1]), memory=512)])
# this should fail because the networks are affined to different host
# NUMA nodes but our guest only has a single NUMA node
network_metadata = objects.NetworkMetadata(
physnets=set(['foo']), tunneled=True)
spec_obj = self._get_spec_obj(numa_topology=instance_topology,
network_metadata=network_metadata)
self.assertFalse(self.filt_cls.host_passes(host, spec_obj))
def test_obj_make_compatible(self):
network_meta = objects.NetworkMetadata(physnets=set(['foo', 'bar']),
tunneled=True)
limits = objects.NUMATopologyLimits(cpu_allocation_ratio=1.0,
ram_allocation_ratio=1.0,
network_metadata=network_meta)
versions = ovo_base.obj_tree_get_versions('NUMATopologyLimits')
primitive = limits.obj_to_primitive(target_version='1.1',
version_manifest=versions)
self.assertIn('network_metadata', primitive['nova_object.data'])
primitive = limits.obj_to_primitive(target_version='1.0',
version_manifest=versions)
self.assertNotIn('network_metadata', primitive['nova_object.data'])
def test_selection_obj_to_dict(self):
"""Tests that to_dict() method properly converts a Selection object to
the corresponding dict.
"""
fake_network_metadata = objects.NetworkMetadata(physnets=set(
['foo', 'bar']),
tunneled=True)
fake_numa_limit = objects.numa.NUMATopologyLimits(
cpu_allocation_ratio=1.0,
ram_allocation_ratio=1.0,
network_metadata=fake_network_metadata)
fake_limit = {
"memory_mb": 1024,
"disk_gb": 100,
"vcpus": 2,
"numa_topology": fake_numa_limit
}
fake_limit_obj = objects.SchedulerLimits.from_dict(fake_limit)
sel_obj = objects.Selection(service_host="fakehost",
nodename="fakenode",
compute_node_uuid=uuids.host,
cell_uuid=uuids.cell,
limits=fake_limit_obj,
allocation_request="fake",
allocation_request_version="99.9")
result = sel_obj.to_dict()
self.assertEqual(['host', 'limits', 'nodename'], sorted(result.keys()))
self.assertEqual('fakehost', result['host'])
self.assertEqual('fakenode', result['nodename'])
limits = result['limits']
self.assertEqual(['disk_gb', 'memory_mb', 'numa_topology'],
sorted(limits.keys()))
self.assertEqual(100, limits['disk_gb'])
self.assertEqual(1024, limits['memory_mb'])
numa_topology = limits['numa_topology']['nova_object.data']
self.assertEqual(1.0, numa_topology['cpu_allocation_ratio'])
self.assertEqual(1.0, numa_topology['ram_allocation_ratio'])
network_meta = numa_topology['network_metadata']['nova_object.data']
# sets are unordered so we need to convert to a list
self.assertEqual(['bar', 'foo'], sorted(network_meta['physnets']))
self.assertTrue(network_meta['tunneled'])
def ensure_network_metadata(self, instance):
if not (instance.info_cache and instance.info_cache.network_info):
return
physnets = set([])
tunneled = True
# physical_network and tunneled might not be in the cache for old
# instances that haven't had their info_cache healed yet
for vif in instance.info_cache.network_info:
physnet = vif.get('network', {}).get('meta', {}).get(
'physical_network', None)
if physnet:
physnets.add(physnet)
tunneled |= vif.get('network', {}).get('meta', {}).get(
'tunneled', False)
self.network_metadata = objects.NetworkMetadata(
physnets=physnets, tunneled=tunneled)
def obj_load_attr(self, attrname):
if attrname not in REQUEST_SPEC_OPTIONAL_ATTRS:
raise exception.ObjectActionError(
action='obj_load_attr',
reason='attribute %s not lazy-loadable' % attrname)
if attrname == 'security_groups':
self.security_groups = objects.SecurityGroupList(objects=[])
return
if attrname == 'network_metadata':
self.network_metadata = objects.NetworkMetadata(
physnets=set(), tunneled=False)
return
# NOTE(sbauza): In case the primitive was not providing that field
# because of a previous RequestSpec version, we want to default
# that field in order to have the same behaviour.
self.obj_set_defaults(attrname)
