def set_global_account_limit(account,
rse_expression,
bytes_,
issuer,
vo='def'):
"""
Set a global account limit.
:param account: The account name.
:param rse_expression: The rse expression.
:param bytes_: The limit in bytes.
:param issuer: The issuer account_core.
:param vo: The VO to act on.
"""
kwargs = {
'account': account,
'rse_expression': rse_expression,
'bytes': bytes_
}
if not rucio.api.permission.has_permission(
issuer=issuer, vo=vo, action='set_global_account_limit',
kwargs=kwargs):
raise rucio.common.exception.AccessDenied(
'Account %s can not set account limits.' % (issuer))
account = InternalAccount(account, vo=vo)
if not account_exists(account=account):
raise rucio.common.exception.AccountNotFound(
'Account %s does not exist' % (account))
account_limit_core.set_global_account_limit(account=account,
rse_expression=rse_expression,
bytes_=bytes_)
def test_delete_global_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Delete global account limit """
rse_exp = 'MOCK'
account_limit.set_global_account_limit(account=self.account, rse_expression=rse_exp, bytes_=10, session=self.db_session)
self.alclient.delete_global_account_limit(account=self.account.external, rse_expression=rse_exp)
result = account_limit.get_global_account_limit(account=self.account, rse_expression=rse_exp)
assert result is None
def test_global_account_limit(self):
""" ACCOUNT_LIMIT (CORE): Set, get and delete global account limit """
account_limit.set_global_account_limit(self.account, 'MOCK', 200000, session=self.db_session)
assert account_limit.get_global_account_limit(account=self.account, rse_expression='MOCK', session=self.db_session) == 200000
assert account_limit.get_global_account_limit(account=self.account, rse_expression='MOCK2', session=self.db_session) is None
account_limit.delete_global_account_limit(self.account, 'MOCK', session=self.db_session)
assert account_limit.get_global_account_limit(account=self.account, rse_expression='MOCK', session=self.db_session) is None
def test_get_global_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limit. """
expression = 'MOCK'
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
result = self.client.get_global_account_limit(account=self.account.external, rse_expression=expression)
assert result[expression] == limit
def test_4(self):
# enough RSEs, local and global quota -> 2 RSEs
set_global_account_limit(account=self.account, rse_expression=self.rse_1_name, bytes=20)
set_global_account_limit(account=self.account, rse_expression=self.rse_2_name, bytes=20)
set_local_account_limit(account=self.account, rse_id=self.mock1_id, bytes=20)
set_local_account_limit(account=self.account, rse_id=self.mock2_id, bytes=20)
copies = 2
rses = [self.rse_1, self.rse_2]
rse_selector = RSESelector(self.account, rses, None, copies)
assert_equal(len(rse_selector.rses), 2)
def test_3(self):
# global quota not enough -> error
copies = 2
rses = [self.rse_1, self.rse_2]
set_local_account_limit(account=self.account, rse_id=self.mock1_id, bytes=20)
set_global_account_limit(account=self.account, rse_expression=self.rse_1_name, bytes=10)
increase(self.mock1_id, self.account, 10, 10)
update_account_counter(account=self.account, rse_id=self.mock1_id)
with assert_raises(InsufficientAccountLimit):
RSESelector(self.account, rses, None, copies)
def test_get_global_account_usage(self):
""" ACCOUNT_LIMIT (CORE): Get global account usage. """
limit1 = 10
limit2 = 20
account_limit.set_global_account_limit(self.account, 'MOCK|MOCK2', limit1)
account_limit.set_global_account_limit(self.account, 'MOCK4|MOCK3', limit2)
results = account_limit.get_global_account_usage(account=self.account)
assert len(results) == 2
results = account_limit.get_global_account_usage(account=self.account, rse_expression='MOCK|MOCK2')
assert len(results) == 1
def test_5(self):
# enough RSEs and local quota, but global quota missing -> 1 RSE
copies = 1
rses = [self.rse_1, self.rse_2]
set_global_account_limit(account=self.account, rse_expression=self.rse_1_name, bytes=10)
increase(self.mock1_id, self.account, 10, 10)
update_account_counter(account=self.account, rse_id=self.mock1_id)
set_local_account_limit(account=self.account, rse_id=self.mock2_id, bytes=20)
set_local_account_limit(account=self.account, rse_id=self.mock1_id, bytes=20)
rse_selector = RSESelector(self.account, rses, None, copies)
assert_equal(len(rse_selector.rses), 1)
def test_get_global_account_limits(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limits """
expression = 'MOCK'
resolved_rses = ['MOCK']
resolved_rse_ids = [get_rse_id('MOCK', **self.vo)]
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
results = self.client.get_global_account_limits(account=self.account.external)
assert len(results) == 1
assert results[expression]['resolved_rses'] == resolved_rses
assert results[expression]['resolved_rse_ids'] == resolved_rse_ids
assert results[expression]['limit'] == limit
def test_get_global_account_usage(self):
""" ACCOUNT_LIMIT (CORE): Get global account usage. """
rse_exp1 = 'MOCK|MOCK2'
rse_exp2 = 'MOCK4|MOCK3'
limit1 = 10
limit2 = 20
account_limit.set_global_account_limit(self.account, rse_exp1, limit1)
account_limit.set_global_account_limit(self.account, rse_exp2, limit2)
results = account_limit.get_global_account_usage(account=self.account)
assert_equal(len(results), 2)
results = account_limit.get_global_account_usage(
account=self.account, rse_expression=rse_exp1)
assert_equal(len(results), 1)
def test_3(self):
# enough RSEs and global quota, also after after change -> 2 RSE
set_global_account_limit(account=self.account, rse_expression=self.rse_1_name, bytes=20)
set_global_account_limit(account=self.account, rse_expression=self.rse_2_name, bytes=20)
set_local_account_limit(account=self.account, rse_id=self.mock1_id, bytes=20)
set_local_account_limit(account=self.account, rse_id=self.mock2_id, bytes=20)
copies = 2
rses = [self.rse_1, self.rse_2]
rse_selector = RSESelector(self.account, rses, None, copies)
assert_equal(len(rse_selector.rses), 2)
rse_selector.select_rse(10, [self.mock1_id], copies=1)
rse_selector.select_rse(10, [self.mock2_id], copies=1)
rses = rse_selector.select_rse(5, [], copies=2)
assert_equal(len(rses), 2)
def test_global_account_limits(self):
""" ACCOUNT_LIMIT (CORE): Set, get and delete global account limits """
resolved_rse_ids = [get_rse_id('MOCK', **self.vo)]
resolved_rses = ['MOCK']
limit = 10
account_limit.set_global_account_limit(self.account, 'MOCK', limit, session=self.db_session)
results = account_limit.get_global_account_limits(account=self.account, session=self.db_session)
assert len(results) == 1
assert 'MOCK' in results
assert results['MOCK']['resolved_rses'] == resolved_rses
assert results['MOCK']['resolved_rse_ids'] == resolved_rse_ids
assert results['MOCK']['limit'] == limit
account_limit.delete_global_account_limit(self.account, 'MOCK', session=self.db_session)
results = account_limit.get_global_account_limits(account=self.account, session=self.db_session)
assert len(results) == 0
def test_2(self):
# enough RSEs and global quota, but not enough global quota after change -> 1 RSE
set_global_account_limit(account=self.account,
rse_expression=self.rse_1_name,
bytes=10)
set_global_account_limit(account=self.account,
rse_expression=self.rse_2_name,
bytes=10)
set_local_account_limit(account=self.account,
rse_id=self.mock1_id,
bytes=20)
set_local_account_limit(account=self.account,
rse_id=self.mock2_id,
bytes=20)
copies = 2
rses = [self.rse_1, self.rse_2]
rse_selector = RSESelector(self.account, rses, None, copies)
assert len(rse_selector.rses) == 2
rse_selector.select_rse(10, [self.mock1_id], copies=1)
rses = rse_selector.select_rse(5, [], copies=1)
assert len(rses) == 1
assert rses[0][0] == self.mock2_id
def test_global_account_limits(self):
""" ACCOUNT_LIMIT (CORE): Set, get and delete global account limits """
resolved_rse_ids = [get_rse_id('MOCK', **self.vo)]
resolved_rses = ['MOCK']
limit = 10
account_limit.set_global_account_limit(self.account,
'MOCK',
limit,
session=self.db_session)
results = account_limit.get_global_account_limits(
account=self.account, session=self.db_session)
assert_equal(len(results), 1)
assert_in('MOCK', results)
assert_equal(results['MOCK']['resolved_rses'], resolved_rses)
assert_equal(results['MOCK']['resolved_rse_ids'], resolved_rse_ids)
assert_equal(results['MOCK']['limit'], limit)
account_limit.delete_global_account_limit(self.account,
'MOCK',
session=self.db_session)
results = account_limit.get_global_account_limits(
account=self.account, session=self.db_session)
assert_equal(len(results), 0)
