def test_get_by_uuid_from_db(self): rp = resource_provider.ResourceProvider(context=self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME) rp.create() retrieved_rp = resource_provider.ResourceProvider._get_by_uuid_from_db( self.context, _RESOURCE_PROVIDER_UUID) self.assertEqual(rp.uuid, retrieved_rp.uuid) self.assertEqual(rp.name, retrieved_rp.name)
def _make_inventory(self, rp_uuid=None): uuid = rp_uuid or uuids.inventory_resource_provider name = uuid db_rp = resource_provider.ResourceProvider(context=self.context, uuid=uuid, name=name) db_rp.create() db_inventory = self._create_inventory_in_db(db_rp.id) return db_rp, db_inventory
def test_create_no_parent(self): rp = resource_provider.ResourceProvider(self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME) rp.create() self.assertIsInstance(rp.id, int) self.assertEqual(_RESOURCE_PROVIDER_UUID, rp.uuid) self.assertEqual(_RESOURCE_PROVIDER_NAME, rp.name) self.assertEqual(_RESOURCE_PROVIDER_UUID, rp.root_provider_uuid) self.assertIsNone(rp.parent_provider_uuid)
def _create_resource_provider(self, inventory): """Helper method to create a resource provider with inventory""" ctxt = context.get_admin_context() rp_uuid = uuidutils.generate_uuid() rp = rp_obj.ResourceProvider(context=ctxt, name=rp_uuid, uuid=rp_uuid) rp.create() inv = rp_obj.Inventory(context=ctxt, resource_provider=rp, **inventory) inv_list = rp_obj.InventoryList(objects=[inv]) rp.set_inventory(inv_list) return rp
def test_set_traits_resets_changes(self, mock_set_traits, mock_reset): trait = resource_provider.Trait(name="HW_CPU_X86_AVX2") traits = resource_provider.TraitList(objects=[trait]) rp = resource_provider.ResourceProvider(self.context, name='cn1', uuid=uuids.cn1) rp.set_traits(traits) mock_set_traits.assert_called_once_with(self.context, rp, traits) mock_reset.assert_called_once_with()
def test_create_with_root_provider_uuid_fail(self): obj = resource_provider.ResourceProvider( context=self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME, root_provider_uuid=_RESOURCE_PROVIDER_UUID, ) exc = self.assertRaises(exception.ObjectActionError, obj.create) self.assertIn('root provider UUID cannot be manually set', str(exc))
def test_save_immutable(self): fields = { 'id': 1, 'uuid': _RESOURCE_PROVIDER_UUID, 'generation': 1, 'root_provider_uuid': _RESOURCE_PROVIDER_UUID, } for field in fields: rp = resource_provider.ResourceProvider(context=self.context) setattr(rp, field, fields[field]) self.assertRaises(exception.ObjectActionError, rp.save)
def test_create(self, mock_db_create): obj = resource_provider.ResourceProvider(context=self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME) obj.create() self.assertEqual(_RESOURCE_PROVIDER_UUID, obj.uuid) self.assertIsInstance(obj.id, int) mock_db_create.assert_called_once_with(self.context, { 'uuid': _RESOURCE_PROVIDER_UUID, 'name': _RESOURCE_PROVIDER_NAME })
def test_get_allocations(self, mock_get_allocations_from_db, mock_ensure_cache): rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=uuids.resource_provider) rp_alloc_list = resource_provider.AllocationList allocations = rp_alloc_list.get_all_by_resource_provider( self.context, rp) self.assertEqual(1, len(allocations)) mock_get_allocations_from_db.assert_called_once_with( self.context, rp.id) self.assertEqual(_ALLOCATION_DB['used'], allocations[0].used)
def test_create_requires_created_resource_provider(self): rp = resource_provider.ResourceProvider( context=self.context, uuid=uuids.inventory_resource_provider) inventory_dict = dict(_INVENTORY_DB) inventory_dict.pop('id') inventory_dict.pop('resource_provider_id') inventory_dict.pop('resource_class_id') inventory_dict['resource_provider'] = rp inventory = resource_provider.Inventory(context=self.context, **inventory_dict) error = self.assertRaises(exception.ObjectActionError, inventory.create) self.assertIn('resource_provider required', str(error))
def test_set_defaults(self): rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=_RESOURCE_PROVIDER_UUID) kwargs = dict(resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, total=16) inv = resource_provider.Inventory(self.context, **kwargs) inv.obj_set_defaults() self.assertEqual(0, inv.reserved) self.assertEqual(1, inv.min_unit) self.assertEqual(1, inv.max_unit) self.assertEqual(1, inv.step_size) self.assertEqual(1.0, inv.allocation_ratio)
def test_non_negative_handling(self): # NOTE(cdent): Just checking, useless to be actually # comprehensive here. rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=_RESOURCE_PROVIDER_UUID) kwargs = dict(resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, total=16, reserved=2, min_unit=1, max_unit=-8, step_size=1, allocation_ratio=1.0) self.assertRaises(ValueError, resource_provider.Inventory, **kwargs)
def test_capacity(self): rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=_RESOURCE_PROVIDER_UUID) kwargs = dict(resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, total=16, reserved=16) inv = resource_provider.Inventory(self.context, **kwargs) inv.obj_set_defaults() self.assertEqual(0, inv.capacity) inv.reserved = 15 self.assertEqual(1, inv.capacity) inv.allocation_ratio = 2.0 self.assertEqual(2, inv.capacity)
def test_get_all_by_resource_provider(self, mock_get, mock_ensure_cache): expected = [ dict(_INVENTORY_DB, resource_provider_id=_RESOURCE_PROVIDER_ID), dict(_INVENTORY_DB, id=_INVENTORY_DB['id'] + 1, resource_provider_id=_RESOURCE_PROVIDER_ID) ] mock_get.return_value = expected rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=_RESOURCE_PROVIDER_UUID) objs = resource_provider.InventoryList.get_all_by_resource_provider( self.context, rp) self.assertEqual(2, len(objs)) self.assertEqual(_INVENTORY_DB['id'], objs[0].id) self.assertEqual(_INVENTORY_DB['id'] + 1, objs[1].id) self.assertEqual(_RESOURCE_PROVIDER_ID, objs[0].resource_provider.id)
def test_create(self, mock_db_create, mock_ensure_cache): rp = resource_provider.ResourceProvider(id=_RESOURCE_PROVIDER_ID, uuid=_RESOURCE_PROVIDER_UUID) obj = resource_provider.Inventory(context=self.context, resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, total=16, reserved=2, min_unit=1, max_unit=8, step_size=1, allocation_ratio=1.0) obj.create() self.assertEqual(_INVENTORY_ID, obj.id) expected = dict(_INVENTORY_DB) expected.pop('id') mock_db_create.assert_called_once_with(self.context, expected)
def create_resource_provider(req): """POST to create a resource provider. On success return a 201 response with an empty body and a location header pointing to the newly created resource provider. """ context = req.environ['placement.context'] schema = POST_RESOURCE_PROVIDER_SCHEMA want_version = req.environ[microversion.MICROVERSION_ENVIRON] if want_version.matches((1, 14)): schema = POST_RP_SCHEMA_V1_14 data = util.extract_json(req.body, schema) try: uuid = data.setdefault('uuid', uuidutils.generate_uuid()) resource_provider = rp_obj.ResourceProvider(context, **data) resource_provider.create() except db_exc.DBDuplicateEntry as exc: # Whether exc.columns has one or two entries (in the event # of both fields being duplicates) appears to be database # dependent, so going with the complete solution here. duplicate = ', '.join( ['%s: %s' % (column, data[column]) for column in exc.columns]) raise webob.exc.HTTPConflict( _('Conflicting resource provider %(duplicate)s already exists.') % {'duplicate': duplicate}) except exception.ObjectActionError as exc: raise webob.exc.HTTPBadRequest( _('Unable to create resource provider "%(name)s", %(rp_uuid)s: ' '%(error)s') % { 'name': data['name'], 'rp_uuid': uuid, 'error': exc }) req.response.location = util.resource_provider_url(req.environ, resource_provider) req.response.status = 201 req.response.content_type = None return req.response
def test_destroy(self): def emulate_rp_mysql_delete(func): def wrapped(context, _id): rp = context.session.query( models.ResourceProvider).\ filter( models.ResourceProvider.id == _id).first() self.assertIsNone(rp.root_provider_id) return func(context, _id) return wrapped emulated = emulate_rp_mysql_delete(resource_provider._delete_rp_record) rp = resource_provider.ResourceProvider(self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME) rp.create() with mock.patch.object(resource_provider, '_delete_rp_record', emulated): rp.destroy()
def test_create_with_id_fails(self): rp = resource_provider.ResourceProvider(context=self.context, uuid=_RESOURCE_PROVIDER_UUID, name=_RESOURCE_PROVIDER_NAME) rp.create() inv = resource_provider.Inventory(context=self.context, resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, total=16, reserved=2, min_unit=1, max_unit=8, step_size=1, allocation_ratio=1.0) inv.create() obj = resource_provider.Allocation(context=self.context, id=99, resource_provider=rp, resource_class=_RESOURCE_CLASS_NAME, consumer_id=uuids.fake_instance, used=8) alloc_list = resource_provider.AllocationList(self.context, objects=[obj]) self.assertRaises(exception.ObjectActionError, alloc_list.create_all)
def start_fixture(self): super(SharedStorageFixture, self).start_fixture() self.context = context.get_admin_context() cn1_uuid = uuidutils.generate_uuid() cn2_uuid = uuidutils.generate_uuid() ss_uuid = uuidutils.generate_uuid() agg_uuid = uuidutils.generate_uuid() os.environ['CN1_UUID'] = cn1_uuid os.environ['CN2_UUID'] = cn2_uuid os.environ['SS_UUID'] = ss_uuid os.environ['AGG_UUID'] = agg_uuid cn1 = rp_obj.ResourceProvider( self.context, name='cn1', uuid=cn1_uuid) cn1.create() cn2 = rp_obj.ResourceProvider( self.context, name='cn2', uuid=cn2_uuid) cn2.create() ss = rp_obj.ResourceProvider( self.context, name='ss', uuid=ss_uuid) ss.create() # Populate compute node inventory for VCPU and RAM for cn in (cn1, cn2): vcpu_inv = rp_obj.Inventory( self.context, resource_provider=cn, resource_class='VCPU', total=24, reserved=0, max_unit=24, min_unit=1, step_size=1, allocation_ratio=16.0) vcpu_inv.obj_set_defaults() ram_inv = rp_obj.Inventory( self.context, resource_provider=cn, resource_class='MEMORY_MB', total=128 * 1024, reserved=0, max_unit=128 * 1024, min_unit=256, step_size=256, allocation_ratio=1.5) ram_inv.obj_set_defaults() inv_list = rp_obj.InventoryList(objects=[vcpu_inv, ram_inv]) cn.set_inventory(inv_list) # Populate shared storage provider with DISK_GB inventory disk_inv = rp_obj.Inventory( self.context, resource_provider=ss, resource_class='DISK_GB', total=2000, reserved=100, max_unit=2000, min_unit=10, step_size=10, allocation_ratio=1.0) disk_inv.obj_set_defaults() inv_list = rp_obj.InventoryList(objects=[disk_inv]) ss.set_inventory(inv_list) # Mark the shared storage pool as having inventory shared among any # provider associated via aggregate t = rp_obj.Trait.get_by_name( self.context, "MISC_SHARES_VIA_AGGREGATE", ) ss.set_traits(rp_obj.TraitList(objects=[t])) # Now associate the shared storage pool and both compute nodes with the # same aggregate cn1.set_aggregates([agg_uuid]) cn2.set_aggregates([agg_uuid]) ss.set_aggregates([agg_uuid])
def test_create_no_uuid_fail(self): obj = resource_provider.ResourceProvider(context=self.context) self.assertRaises(exception.ObjectActionError, obj.create)
def test_create_id_fail(self): obj = resource_provider.ResourceProvider(context=self.context, uuid=_RESOURCE_PROVIDER_UUID, id=_RESOURCE_PROVIDER_ID) self.assertRaises(exception.ObjectActionError, obj.create)
def setUp(self): super(TestPlacementURLs, self).setUp() self.resource_provider = rp_obj.ResourceProvider( name=uuidsentinel.rp_name, uuid=uuidsentinel.rp_uuid) self.resource_class = rp_obj.ResourceClass( name='CUSTOM_BAREMETAL_GOLD', id=1000)
def start_fixture(self): super(AllocationFixture, self).start_fixture() self.context = context.get_admin_context() # For use creating and querying allocations/usages os.environ['ALT_USER_ID'] = uuidutils.generate_uuid() project_id = os.environ['PROJECT_ID'] user_id = os.environ['USER_ID'] alt_user_id = os.environ['ALT_USER_ID'] # Stealing from the super rp_name = os.environ['RP_NAME'] rp_uuid = os.environ['RP_UUID'] rp = rp_obj.ResourceProvider( self.context, name=rp_name, uuid=rp_uuid) rp.create() # Create some DISK_GB inventory and allocations. consumer_id = uuidutils.generate_uuid() inventory = rp_obj.Inventory( self.context, resource_provider=rp, resource_class='DISK_GB', total=2048, step_size=10, min_unit=10, max_unit=600) inventory.obj_set_defaults() rp.add_inventory(inventory) alloc1 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='DISK_GB', consumer_id=consumer_id, project_id=project_id, user_id=user_id, used=500) alloc2 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='DISK_GB', consumer_id=consumer_id, project_id=project_id, user_id=user_id, used=500) alloc_list = rp_obj.AllocationList( self.context, objects=[alloc1, alloc2] ) alloc_list.create_all() # Create some VCPU inventory and allocations. consumer_id = uuidutils.generate_uuid() os.environ['CONSUMER_ID'] = consumer_id inventory = rp_obj.Inventory( self.context, resource_provider=rp, resource_class='VCPU', total=10, max_unit=4) inventory.obj_set_defaults() rp.add_inventory(inventory) alloc1 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='VCPU', consumer_id=consumer_id, project_id=project_id, user_id=user_id, used=2) alloc2 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='VCPU', consumer_id=consumer_id, project_id=project_id, user_id=user_id, used=4) alloc_list = rp_obj.AllocationList( self.context, objects=[alloc1, alloc2]) alloc_list.create_all() # Create a couple of allocations for a different user. consumer_id = uuidutils.generate_uuid() alloc1 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='DISK_GB', consumer_id=consumer_id, project_id=project_id, user_id=alt_user_id, used=20) alloc2 = rp_obj.Allocation( self.context, resource_provider=rp, resource_class='VCPU', consumer_id=consumer_id, project_id=project_id, user_id=alt_user_id, used=1) alloc_list = rp_obj.AllocationList( self.context, objects=[alloc1, alloc2]) alloc_list.create_all() # The ALT_RP_XXX variables are for a resource provider that has # not been created in the Allocation fixture os.environ['ALT_RP_UUID'] = uuidutils.generate_uuid() os.environ['ALT_RP_NAME'] = uuidutils.generate_uuid()
def setUp(self): super(TestPickLastModified, self).setUp() self.resource_provider = rp_obj.ResourceProvider( name=uuidsentinel.rp_name, uuid=uuidsentinel.rp_uuid)