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)
