def test_enforce_injected_files(self):
reglimits = {
local_limit.INJECTED_FILES: 5,
local_limit.INJECTED_FILES_CONTENT: 10 * 1024,
local_limit.INJECTED_FILES_PATH: 255
}
self.useFixture(limit_fixture.LimitFixture(reglimits, {}))
local_limit.enforce_api_limit(local_limit.INJECTED_FILES, 5)
local_limit.enforce_api_limit(local_limit.INJECTED_FILES_CONTENT,
10 * 1024)
local_limit.enforce_api_limit(local_limit.INJECTED_FILES_PATH, 255)
e = self.assertRaises(exception.OnsetFileLimitExceeded,
local_limit.enforce_api_limit,
local_limit.INJECTED_FILES, 6)
msg = ("Resource %s is over limit" % local_limit.INJECTED_FILES)
self.assertIn(msg, str(e))
e = self.assertRaises(exception.OnsetFileContentLimitExceeded,
local_limit.enforce_api_limit,
local_limit.INJECTED_FILES_CONTENT,
10 * 1024 + 1)
msg = ("Resource %s is over limit" %
local_limit.INJECTED_FILES_CONTENT)
self.assertIn(msg, str(e))
e = self.assertRaises(exception.OnsetFilePathLimitExceeded,
local_limit.enforce_api_limit,
local_limit.INJECTED_FILES_PATH, 256)
msg = ("Resource %s is over limit" % local_limit.INJECTED_FILES_PATH)
self.assertIn(msg, str(e))
def test_quota_recheck_disabled_unified_limits(self, mock_enforce):
self.flags(driver="nova.quota.UnifiedLimitsDriver", group="quota")
self.flags(recheck_quota=False, group="quota")
self.useFixture(limit_fixture.LimitFixture({'server_key_pairs': 1},
{}))
self._check_success()
self.assertEqual(1, mock_enforce.call_count)
def test_enforce_api_limit_no_registered_limit_found(self):
self.useFixture(limit_fixture.LimitFixture({}, {}))
e = self.assertRaises(exception.MetadataLimitExceeded,
local_limit.enforce_api_limit,
local_limit.SERVER_METADATA_ITEMS, 42)
msg = ("Resource %s is over limit" % local_limit.SERVER_METADATA_ITEMS)
self.assertIn(msg, str(e))
def test_create_only_one_group_when_limit_is_one(self):
self.useFixture(limit_fixture.LimitFixture({'server_groups': 1}, {}))
policies = ['anti-affinity']
sgroup = {'name': 'test', 'policies': policies}
res_dict = self.controller.create(self.req,
body={'server_group': sgroup})
self.assertEqual(res_dict['server_group']['name'], 'test')
self.assertTrue(uuidutils.is_uuid_like(res_dict['server_group']['id']))
self.assertEqual(res_dict['server_group']['policies'], policies)
# prove we can't create two, as limited to one
sgroup2 = {'name': 'test2', 'policies': policies}
exc = self.assertRaises(webob.exc.HTTPForbidden,
self.controller.create,
self.req,
body={'server_group': sgroup2})
msg = ("Resource %s is over limit" % local_limit.SERVER_GROUPS)
self.assertIn(msg, str(exc))
# delete first one
self.controller.delete(self.req, res_dict['server_group']['id'])
# prove we can now create the second one
res_dict2 = self.controller.create(self.req,
body={'server_group': sgroup2})
self.assertEqual(res_dict2['server_group']['name'], 'test2')
self.assertTrue(uuidutils.is_uuid_like(
res_dict2['server_group']['id']))
self.assertEqual(res_dict2['server_group']['policies'], policies)
def test_enforce_db_limit_no_registered_limit_found(self, mock_count):
self.useFixture(limit_fixture.LimitFixture({}, {}))
mock_count.return_value = 5
e = self.assertRaises(exception.KeypairLimitExceeded,
local_limit.enforce_db_limit, self.context,
local_limit.KEY_PAIRS, uuids.user_id, 42)
msg = ("Resource %s is over limit" % local_limit.KEY_PAIRS)
self.assertIn(msg, str(e))
def test_get_legacy_default_limits(self):
reglimits = copy.deepcopy(self.new)
reglimits.pop('server_key_pairs')
self.useFixture(limit_fixture.LimitFixture(reglimits, {}))
limits = local_limit.get_legacy_default_limits()
expected = copy.deepcopy(self.legacy)
expected['key_pairs'] = 0
self.assertEqual(expected, limits)
def test_create_group_fails_with_zero_quota(self):
self.useFixture(limit_fixture.LimitFixture({'server_groups': 0}, {}))
sgroup = {'name': 'test', 'policies': ['anti-affinity']}
exc = self.assertRaises(webob.exc.HTTPForbidden,
self.controller.create,
self.req,
body={'server_group': sgroup})
msg = ("Resource %s is over limit" % local_limit.SERVER_GROUPS)
self.assertIn(msg, str(exc))
def setUp(self):
super(UnifiedLimitsControllerTest, self).setUp()
reglimits = {
local_limit.SERVER_METADATA_ITEMS: 128,
local_limit.INJECTED_FILES: 5,
local_limit.INJECTED_FILES_CONTENT: 10 * 1024,
local_limit.INJECTED_FILES_PATH: 255,
local_limit.KEY_PAIRS: 100,
local_limit.SERVER_GROUPS: 12,
local_limit.SERVER_GROUP_MEMBERS: 10
}
self.useFixture(limit_fixture.LimitFixture(reglimits, {}))
def test_enforce_api_limit_metadata(self):
# default max is 128
self.useFixture(
limit_fixture.LimitFixture(
{local_limit.SERVER_METADATA_ITEMS: 128}, {}))
local_limit.enforce_api_limit(local_limit.SERVER_METADATA_ITEMS, 128)
e = self.assertRaises(exception.MetadataLimitExceeded,
local_limit.enforce_api_limit,
local_limit.SERVER_METADATA_ITEMS, 129)
msg = ("Resource %s is over limit" % local_limit.SERVER_METADATA_ITEMS)
self.assertIn(msg, str(e))
def test_enforce_db_limit_server_groups(self, mock_count):
self.useFixture(
limit_fixture.LimitFixture({local_limit.SERVER_GROUPS: 10}, {}))
mock_count.return_value = {'project': {'server_groups': 9}}
local_limit.enforce_db_limit(self.context, local_limit.SERVER_GROUPS,
uuids.project_id, 1)
mock_count.assert_called_once_with(self.context, uuids.project_id)
self.assertRaises(exception.ServerGroupLimitExceeded,
local_limit.enforce_db_limit, self.context,
local_limit.SERVER_GROUPS, uuids.project_id, 2)
def setUp(self):
super(UnifiedLimitsQuotaClassesTest, self).setUp()
# Set server_groups so all config options get a different value
# but we also test as much as possible with the default config
self.flags(driver="nova.quota.UnifiedLimitsDriver", group='quota')
reglimits = {local_limit.SERVER_METADATA_ITEMS: 128,
local_limit.INJECTED_FILES: 5,
local_limit.INJECTED_FILES_CONTENT: 10 * 1024,
local_limit.INJECTED_FILES_PATH: 255,
local_limit.KEY_PAIRS: 100,
local_limit.SERVER_GROUPS: 12,
local_limit.SERVER_GROUP_MEMBERS: 10}
self.useFixture(limit_fixture.LimitFixture(reglimits, {}))
def test_quota_during_recheck_unified_limits(self, mock_enforce):
"""Simulate a race where this request initially has enough quota to
progress partially through the create path but then fails the quota
recheck because a parallel request filled up the quota first.
"""
self.flags(driver="nova.quota.UnifiedLimitsDriver", group="quota")
self.useFixture(
limit_fixture.LimitFixture({'server_key_pairs': 100}, {}))
# First quota check succeeds, second (recheck) fails.
mock_enforce.side_effect = [
None, exception.KeypairLimitExceeded('oslo.limit message')
]
msg = 'oslo.limit message'
self._test_quota_during_recheck(mock_enforce, msg)
def test_enforce_db_limit_server_group_members(self, mock_get):
self.useFixture(
limit_fixture.LimitFixture({local_limit.SERVER_GROUP_MEMBERS: 10},
{}))
mock_get.return_value = objects.InstanceGroup(members=[])
local_limit.enforce_db_limit(self.context,
local_limit.SERVER_GROUP_MEMBERS,
uuids.server_group, 10)
mock_get.assert_called_once_with(self.context, uuids.server_group)
self.assertRaises(exception.GroupMemberLimitExceeded,
local_limit.enforce_db_limit, self.context,
local_limit.SERVER_GROUP_MEMBERS, uuids.server_group,
11)
def test_enforce_db_limit_keypairs(self, mock_count):
self.useFixture(
limit_fixture.LimitFixture({local_limit.KEY_PAIRS: 100}, {}))
mock_count.return_value = 99
local_limit.enforce_db_limit(self.context, local_limit.KEY_PAIRS,
uuids.user_id, 1)
mock_count.assert_called_once_with(self.context, uuids.user_id)
self.assertRaises(exception.KeypairLimitExceeded,
local_limit.enforce_db_limit, self.context,
local_limit.KEY_PAIRS, uuids.user_id, 2)
mock_count.return_value = 100
local_limit.enforce_db_limit(self.context, local_limit.KEY_PAIRS,
uuids.user_id, 0)
mock_count.return_value = 101
self.assertRaises(exception.KeypairLimitExceeded,
local_limit.enforce_db_limit, self.context,
local_limit.KEY_PAIRS, uuids.user_id, 0)
def setUp(self):
super(UnifiedLimitsTest, self).setUp()
# Use different project_ids for non-admin and admin.
self.api.project_id = 'fake'
self.admin_api.project_id = 'admin'
self.flags(driver="nova.quota.UnifiedLimitsDriver", group="quota")
reglimits = {local_limit.SERVER_METADATA_ITEMS: 128,
local_limit.INJECTED_FILES: 5,
local_limit.INJECTED_FILES_CONTENT: 10 * 1024,
local_limit.INJECTED_FILES_PATH: 255,
local_limit.KEY_PAIRS: 100,
local_limit.SERVER_GROUPS: 10,
local_limit.SERVER_GROUP_MEMBERS: 1,
'servers': 4,
'class:VCPU': 8,
'class:MEMORY_MB': 32768,
'class:DISK_GB': 250}
projlimits = {self.api.project_id: {'servers': 2,
'class:VCPU': 4,
'class:MEMORY_MB': 16384,
'class:DISK_GB': 100}}
self.useFixture(limit_fixture.LimitFixture(reglimits, projlimits))
self.ctx = nova_context.get_admin_context()
def test_quota_unified_limits(self):
self.flags(driver="nova.quota.UnifiedLimitsDriver", group="quota")
self.useFixture(limit_fixture.LimitFixture({'server_key_pairs': 0},
{}))
msg = ("Resource %s is over limit" % local_limit.KEY_PAIRS)
self.assertKeypairRaises(exception.KeypairLimitExceeded, msg, 'foo')
def setUp(self):
super(ServerGroupQuotasUnifiedLimitsTestV21, self).setUp()
self.flags(driver='nova.quota.UnifiedLimitsDriver', group='quota')
self.req = fakes.HTTPRequest.blank('')
self.controller = sg_v21.ServerGroupController()
self.useFixture(limit_fixture.LimitFixture({'server_groups': 10}, {}))
def test_get_legacy_project_limits(self):
reglimits = {'servers': 5, 'class:MEMORY_MB': 7}
projlimits = {uuids.project_id: {'servers': 1}}
self.useFixture(limit_fixture.LimitFixture(reglimits, projlimits))
limits = placement_limits.get_legacy_project_limits(uuids.project_id)
self.assertEqual({'instances': 1, 'cores': 0, 'ram': 7}, limits)
def test_get_legacy_default_limits(self):
reglimits = {'servers': 1, 'class:VCPU': 2}
self.useFixture(limit_fixture.LimitFixture(reglimits, {}))
limits = placement_limits.get_legacy_default_limits()
self.assertEqual({'cores': 2, 'instances': 1, 'ram': 0}, limits)
def test_success_unified_limits(self):
self.flags(driver="nova.quota.UnifiedLimitsDriver", group="quota")
self.useFixture(limit_fixture.LimitFixture({'server_key_pairs': 1},
{}))
self._check_success()
