def test_backport_1_0(self):
requests = objects.InstancePCIRequests(requests=[
objects.InstancePCIRequest(count=1, request_id=FAKE_UUID),
objects.InstancePCIRequest(count=2, request_id=FAKE_UUID)
])
primitive = requests.obj_to_primitive(target_version='1.0')
backported = objects.InstancePCIRequests.obj_from_primitive(primitive)
self.assertEqual('1.0', backported.VERSION)
self.assertEqual(2, len(backported.requests))
self.assertFalse(backported.requests[0].obj_attr_is_set('request_id'))
self.assertFalse(backported.requests[1].obj_attr_is_set('request_id'))
def test_save_and_reload(self, mock_get, mock_update):
database = {}
def _save(context, uuid, values):
database.setdefault(uuid, {'instance_uuid': uuid})
database[uuid].update(values)
def _get(context, uuid, columns):
return database.get(uuid, {})
mock_update.side_effect = _save
mock_get.side_effect = _get
requests = objects.InstancePCIRequests(context=self.context,
instance_uuid=FAKE_UUID,
requests=[
objects.InstancePCIRequest(
count=1,
is_new=False,
alias_name='alias_1',
spec=[{
'foo': 'bar'
}])
])
requests.save()
_requests = objects.InstancePCIRequests.get_by_instance_uuid(
self.context, FAKE_UUID)
self.assertEqual(requests.instance_uuid, _requests.instance_uuid)
self.assertEqual(len(requests.requests), len(_requests.requests))
self.assertEqual(requests.requests[0].alias_name,
_requests.requests[0].alias_name)
def _create_pci_requests_object(self, mock_get, requests):
pci_reqs = []
for request in requests:
pci_req_obj = objects.InstancePCIRequest(count=request['count'],
spec=request['spec'])
pci_reqs.append(pci_req_obj)
mock_get.return_value = objects.InstancePCIRequests(requests=pci_reqs)
def test_numa_topology_with_pci_fail(self, mock_get):
dev_dict = {
'compute_node_id': 1,
'address': 'a',
'product_id': 'p',
'vendor_id': 'v',
'numa_node': 1,
'status': 'available'
}
dev_dict2 = {
'compute_node_id': 1,
'address': 'a',
'product_id': 'p',
'vendor_id': 'v',
'numa_node': 2,
'status': 'available'
}
self.tracker.new_pci_tracker()
self.tracker.pci_tracker.set_hvdevs([dev_dict, dev_dict2])
request = objects.InstancePCIRequest(count=2,
spec=[{
'vendor_id': 'v',
'product_id': 'p'
}])
mock_get.return_value = objects.InstancePCIRequests(requests=[request])
huge_instance = objects.InstanceNUMATopology(cells=[
objects.InstanceNUMACell(id=1, cpuset=set([1, 2]), memory=512)
])
self.assertRaises(exception.ComputeResourcesUnavailable,
self._claim,
numa_topology=huge_instance)
def test_save(self, mock_update):
requests = objects.InstancePCIRequests(
context=self.context,
instance_uuid=FAKE_UUID,
requests=[
objects.InstancePCIRequest(count=1,
spec=[{
'foo': 'bar'
}, {
'baz': 'bat'
}],
alias_name='alias_1',
is_new=False,
request_id=FAKE_REQUEST_UUID)
])
requests.save()
self.assertEqual(FAKE_UUID, mock_update.call_args_list[0][0][1])
self.assertEqual([{
'count': 1,
'is_new': False,
'alias_name': 'alias_1',
'spec': [{
'foo': 'bar'
}, {
'baz': 'bat'
}],
'request_id': FAKE_REQUEST_UUID
}], jsonutils.loads(
mock_update.call_args_list[0][0][2]['pci_requests']))
def test_support_requests_no_numa_info(self):
cells = [objects.NUMACell(id=0, cpuset=set(), memory=0)]
pci_request = [
objects.InstancePCIRequest(count=1, spec=[{
'vendor_id': 'v3'
}])
]
self.assertEqual(True,
self.pci_stats.support_requests(pci_request, cells))
def test_consume_requests_no_numa_info(self):
cells = [objects.NUMACell(id=0, cpuset=set(), memory=0)]
pci_request = [
objects.InstancePCIRequest(count=1, spec=[{
'vendor_id': 'v3'
}])
]
devs = self.pci_stats.consume_requests(pci_request, cells)
self.assertEqual(1, len(devs))
self.assertEqual(set(['v3']), set([dev['vendor_id'] for dev in devs]))
def test_get_by_instance_uuid_and_newness(self, mock_get):
pcir = objects.InstancePCIRequests
mock_get.return_value = objects.InstancePCIRequests(
instance_uuid='fake-uuid',
requests=[
objects.InstancePCIRequest(count=1, is_new=False),
objects.InstancePCIRequest(count=2, is_new=True)
])
old_req = pcir.get_by_instance_uuid_and_newness(
self.context, 'fake-uuid', False)
mock_get.return_value = objects.InstancePCIRequests(
instance_uuid='fake-uuid',
requests=[
objects.InstancePCIRequest(count=1, is_new=False),
objects.InstancePCIRequest(count=2, is_new=True)
])
new_req = pcir.get_by_instance_uuid_and_newness(
self.context, 'fake-uuid', True)
self.assertEqual(1, old_req.requests[0].count)
self.assertEqual(2, new_req.requests[0].count)
def test_pci_passthrough_no_pci_stats(self):
request = objects.InstancePCIRequest(count=1,
spec=[{
'vendor_id': '8086'
}])
requests = objects.InstancePCIRequests(requests=[request])
filter_properties = {'pci_requests': requests}
host = fakes.FakeHostState(
'host1',
'node1',
attribute_dict={'pci_stats': stats.PciDeviceStats()})
self.assertFalse(self.filt_cls.host_passes(host, filter_properties))
def test_pci_passthrough_fail(self):
pci_stats_mock = mock.MagicMock()
pci_stats_mock.support_requests.return_value = False
request = objects.InstancePCIRequest(count=1,
spec=[{
'vendor_id': '8086'
}])
requests = objects.InstancePCIRequests(requests=[request])
filter_properties = {'pci_requests': requests}
host = fakes.FakeHostState(
'host1', 'node1', attribute_dict={'pci_stats': pci_stats_mock})
self.assertFalse(self.filt_cls.host_passes(host, filter_properties))
pci_stats_mock.support_requests.assert_called_once_with(
requests.requests)
def test_consume_reqeusts(self, mock_get_dev_filter):
mock_get_dev_filter.return_value = self.pci_wlist
self._create_pci_devices()
pci_requests = [
objects.InstancePCIRequest(count=1,
spec=[{
'physical_network': 'physnet1'
}]),
objects.InstancePCIRequest(count=1,
spec=[{
'vendor_id': '1137',
'product_id': '0072'
}])
]
devs = self.pci_stats.consume_requests(pci_requests)
self.assertEqual(2, len(devs))
self.assertEqual(set(['0071', '0072']),
set([dev['product_id'] for dev in devs]))
self._assertPoolContent(self.pci_stats.pools[0], '1137', '0072', 2)
self._assertPoolContent(self.pci_stats.pools[1],
'1137',
'0071',
3,
physical_network='physnet1')
def test_stat_consumption_from_instance_pci(self):
inst_topology = objects.InstanceNUMATopology(cells=[
objects.InstanceNUMACell(cpuset=set([0]), memory=512, id=0)
])
fake_requests = [{
'request_id': 'fake_request1',
'count': 1,
'spec': [{
'vendor_id': '8086'
}]
}]
fake_requests_obj = objects.InstancePCIRequests(
requests=[objects.InstancePCIRequest(**r) for r in fake_requests],
instance_uuid='fake-uuid')
instance = objects.Instance(root_gb=0,
ephemeral_gb=0,
memory_mb=512,
vcpus=1,
project_id='12345',
vm_state=vm_states.BUILDING,
task_state=task_states.SCHEDULING,
os_type='Linux',
uuid='fake-uuid',
numa_topology=inst_topology,
pci_requests=fake_requests_obj,
id=1243)
req_spec = sched_utils.build_request_spec(
None, None, [instance],
objects.Flavor(root_gb=0, ephemeral_gb=0, memory_mb=1024, vcpus=1))
host = host_manager.HostState("fakehost", "fakenode")
host.pci_stats = pci_stats.PciDeviceStats([
objects.PciDevicePool(vendor_id='8086',
product_id='15ed',
numa_node=1,
count=1)
])
host.numa_topology = fakes.NUMA_TOPOLOGY
host.consume_from_instance(req_spec['instance_properties'])
self.assertIsInstance(req_spec['instance_properties']['numa_topology'],
objects.InstanceNUMATopology)
self.assertEqual(512, host.numa_topology.cells[1].memory_usage)
self.assertEqual(1, host.numa_topology.cells[1].cpu_usage)
self.assertEqual(0, len(host.pci_stats.pools))
def _translate_alias_to_requests(alias_spec):
"""Generate complete pci requests from pci aliases in extra_spec."""
pci_aliases = _get_alias_from_config()
pci_requests = [] # list of a specs dict
alias_spec = alias_spec.replace(' ', '')
for name, count in [spec.split(':') for spec in alias_spec.split(',')]:
if name not in pci_aliases:
raise exception.PciRequestAliasNotDefined(alias=name)
else:
request = objects.InstancePCIRequest(count=int(count),
spec=copy.deepcopy(
pci_aliases[name]),
alias_name=name)
pci_requests.append(request)
return pci_requests
def test_pci_fail(self, mock_get):
dev_dict = {
'compute_node_id': 1,
'address': 'a',
'product_id': 'p',
'vendor_id': 'v1',
'numa_node': 1,
'status': 'available'
}
self.tracker.new_pci_tracker()
self.tracker.pci_tracker.set_hvdevs([dev_dict])
claim = self._claim()
request = objects.InstancePCIRequest(count=1,
spec=[{
'vendor_id': 'v',
'product_id': 'p'
}])
mock_get.return_value = objects.InstancePCIRequests(requests=[request])
claim._test_pci()
def test_from_request_spec_instance_props(self):
requests = objects.InstancePCIRequests(requests=[
objects.InstancePCIRequest(count=1,
request_id=FAKE_UUID,
spec=[{
'vendor_id': '8086',
'device_id': '1502'
}])
],
instance_uuid=FAKE_UUID)
result = jsonutils.to_primitive(requests)
result = objects.InstancePCIRequests.from_request_spec_instance_props(
result)
self.assertEqual(1, len(result.requests))
self.assertEqual(1, result.requests[0].count)
self.assertEqual(FAKE_UUID, result.requests[0].request_id)
self.assertEqual([{
'vendor_id': '8086',
'device_id': '1502'
}], result.requests[0].spec)
def test_numa_topology_with_pci_no_numa_info(self, mock_get):
dev_dict = {
'compute_node_id': 1,
'address': 'a',
'product_id': 'p',
'vendor_id': 'v',
'numa_node': None,
'status': 'available'
}
self.tracker.new_pci_tracker()
self.tracker.pci_tracker.set_hvdevs([dev_dict])
request = objects.InstancePCIRequest(count=1,
spec=[{
'vendor_id': 'v',
'product_id': 'p'
}])
mock_get.return_value = objects.InstancePCIRequests(requests=[request])
huge_instance = objects.InstanceNUMATopology(cells=[
objects.InstanceNUMACell(id=1, cpuset=set([1, 2]), memory=512)
])
self._claim(numa_topology=huge_instance)
vendor_id='v2',
product_id='p2',
address='0000:00:00.2',
numa_node=1)
fake_pci_3 = dict(fake_pci_1, address='0000:00:00.3')
fake_pci_4 = dict(fake_pci_1,
vendor_id='v3',
product_id='p3',
address='0000:00:00.3',
numa_node=None)
pci_requests = [
objects.InstancePCIRequest(count=1, spec=[{
'vendor_id': 'v1'
}]),
objects.InstancePCIRequest(count=1, spec=[{
'vendor_id': 'v2'
}])
]
pci_requests_multiple = [
objects.InstancePCIRequest(count=1, spec=[{
'vendor_id': 'v1'
}]),
objects.InstancePCIRequest(count=3, spec=[{
'vendor_id': 'v2'
}])
]
def test_new_compatibility(self):
request = objects.InstancePCIRequest(is_new=False)
self.assertFalse(request.new)