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_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_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)
class ResizeClaimTestCase(ClaimTestCase):
def setUp(self):
super(ResizeClaimTestCase, self).setUp()
self.instance = self._fake_instance()
self.get_numa_constraint_patch = None
def _claim(self, limits=None, overhead=None, **kwargs):
instance_type = self._fake_instance_type(**kwargs)
numa_constraint = kwargs.pop('numa_topology', None)
if overhead is None:
overhead = {'memory_mb': 0}
with mock.patch('patron.virt.hardware.numa_get_constraints',
return_value=numa_constraint):
return claims.ResizeClaim('context',
self.instance,
instance_type, {},
self.tracker,
self.resources,
overhead=overhead,
limits=limits)
def _set_pci_request(self, claim):
request = [{
'count': 1,
'spec': [{
'vendor_id': 'v',
'product_id': 'p'
}],
}]
claim.instance.update(
system_metadata={'new_pci_requests': jsonutils.dumps(request)})
@mock.patch('patron.objects.InstancePCIRequests.get_by_instance_uuid',
return_value=objects.InstancePCIRequests(requests=[]))
def test_ext_resources(self, mock_get):
self._claim()
self.assertTrue(self.tracker.ext_resources_handler.test_called)
self.assertTrue(self.tracker.ext_resources_handler.usage_is_itype)
@mock.patch('patron.objects.InstancePCIRequests.get_by_instance_uuid',
return_value=objects.InstancePCIRequests(requests=[]))
def test_abort(self, mock_get):
claim = self._abort()
self.assertTrue(claim.tracker.rcalled)
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_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_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_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 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 get_pci_requests_from_flavor(flavor):
"""Get flavor's pci request.
The pci_passthrough:alias scope in flavor extra_specs
describes the flavor's pci requests, the key is
'pci_passthrough:alias' and the value has format
'alias_name_x:count, alias_name_y:count, ... '. The alias_name is
defined in 'pci_alias' configurations.
The flavor's requirement is translated into pci requests list,
each entry in the list is a dictionary. The dictionary has
three keys. The 'specs' gives the pci device properties
requirement, the 'count' gives the number of devices, and the
optional 'alias_name' is the corresponding alias definition name.
Example:
Assume alias configuration is::
| {'vendor_id':'8086',
| 'device_id':'1502',
| 'name':'alias_1'}
The flavor extra specs includes: 'pci_passthrough:alias': 'alias_1:2'.
The returned pci_requests are::
| pci_requests = [{'count':2,
| 'specs': [{'vendor_id':'8086',
| 'device_id':'1502'}],
| 'alias_name': 'alias_1'}]
:param flavor: the flavor to be checked
:returns: a list of pci requests
"""
pci_requests = []
if ('extra_specs' in flavor
and 'pci_passthrough:alias' in flavor['extra_specs']):
pci_requests = _translate_alias_to_requests(
flavor['extra_specs']['pci_passthrough:alias'])
return objects.InstancePCIRequests(requests=pci_requests)
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)
def __init__(self):
self.new_pci_tracker()
def abort_instance_claim(self, *args, **kwargs):
self.icalled = True
def drop_resize_claim(self, *args, **kwargs):
self.rcalled = True
def new_pci_tracker(self):
ctxt = context.RequestContext('testuser', 'testproject')
self.pci_tracker = pci_manager.PciDevTracker(ctxt)
@mock.patch('patron.objects.InstancePCIRequests.get_by_instance_uuid',
return_value=objects.InstancePCIRequests(requests=[]))
class ClaimTestCase(test.NoDBTestCase):
def setUp(self):
super(ClaimTestCase, self).setUp()
self.resources = self._fake_resources()
self.tracker = DummyTracker()
def _claim(self, limits=None, overhead=None, **kwargs):
numa_topology = kwargs.pop('numa_topology', None)
instance = self._fake_instance(**kwargs)
if numa_topology:
db_numa_topology = {
'id': 1,
'created_at': None,
'updated_at': None,
'deleted_at': None,
