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,