rucio 32.8.6__py3-none-any.whl

rucio/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import gettext
+
+gettext.install('rucio')

rucio/alembicrevision.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ALEMBIC_REVISION = '27e3a68927fb'  # the current alembic head revision

rucio/api/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

rucio/api/account.py

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING
+
+import rucio.api.permission
+import rucio.common.exception
+import rucio.core.identity
+from rucio.common.schema import validate_schema
+from rucio.common.types import InternalAccount
+from rucio.common.utils import api_update_return_dict
+from rucio.core import account as account_core
+from rucio.core.rse import get_rse_id
+from rucio.db.sqla.constants import AccountType
+from rucio.db.sqla.session import read_session, stream_session, transactional_session
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+
+@transactional_session
+def add_account(account, type_, email, issuer, vo='def', *, session: "Session"):
+    """
+    Creates an account with the provided account name, contact information, etc.
+
+    :param account: The account name.
+    :param type_: The account type
+    :param email: The Email address associated with the account.
+
+    :param issuer: The issuer account_core.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+
+    """
+
+    validate_schema(name='account', obj=account, vo=vo)
+
+    kwargs = {'account': account, 'type': type_}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='add_account', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not add account' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    account_core.add_account(account, AccountType[type_.upper()], email, session=session)
+
+
+@transactional_session
+def del_account(account, issuer, vo='def', *, session: "Session"):
+    """
+    Disables an account with the provided account name.
+
+    :param account: The account name.
+    :param issuer: The issuer account.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+
+    """
+    kwargs = {'account': account}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='del_account', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not delete account' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    account_core.del_account(account, session=session)
+
+
+@read_session
+def get_account_info(account, vo='def', *, session: "Session"):
+    """
+    Returns the info like the statistics information associated to an account_core.
+
+    :param account: The account name.
+    :returns: A list with all account information.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    acc = account_core.get_account(account, session=session)
+    acc.account = acc.account.external
+    return acc
+
+
+@transactional_session
+def update_account(account, key, value, issuer='root', vo='def', *, session: "Session"):
+    """ Update a property of an account_core.
+
+    :param account: Name of the account_core.
+    :param key: Account property like status.
+    :param value: Property value.
+    :param issuer: The issuer account
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    """
+    validate_schema(name='account', obj=account, vo=vo)
+    kwargs = {}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='update_account', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not change %s  of the account' % (issuer, key))
+
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.update_account(account, key, value, session=session)
+
+
+@stream_session
+def list_accounts(filter_={}, vo='def', *, session: "Session"):
+    """
+    Lists all the Rucio account names.
+
+    REST API: http://<host>:<port>/rucio/accounts
+
+    :param filter_: Dictionary of attributes by which the input data should be filtered
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+
+    :returns: List of all accounts.
+    """
+    # If filter is empty, create a new dict to avoid overwriting the function's default
+    if not filter_:
+        filter_ = {}
+
+    if 'account' in filter_:
+        filter_['account'] = InternalAccount(filter_['account'], vo=vo)
+    else:
+        filter_['account'] = InternalAccount(account='*', vo=vo)
+    for result in account_core.list_accounts(filter_=filter_, session=session):
+        yield api_update_return_dict(result, session=session)
+
+
+@read_session
+def account_exists(account, vo='def', *, session: "Session"):
+    """
+    Checks to see if account exists. This procedure does not check it's status.
+
+    :param account: Name of the account.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    :returns: True if found, otherwise false.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.account_exists(account, session=session)
+
+
+@read_session
+def list_identities(account, vo='def', *, session: "Session"):
+    """
+    List all identities on an account_core.
+
+    :param account: The account name.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.list_identities(account, session=session)
+
+
+@read_session
+def list_account_attributes(account, vo='def', *, session: "Session"):
+    """
+    Returns all the attributes for the given account.
+
+    :param account: The account name.
+    :param vo: The VO to act on
+    :param session: The database session in use.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.list_account_attributes(account, session=session)
+
+
+@transactional_session
+def add_account_attribute(key, value, account, issuer, vo='def', *, session: "Session"):
+    """
+    Add an attribute to an account.
+
+    :param key: attribute key.
+    :param value: attribute value.
+    :param account: The account name.
+    :param issuer: The issuer account.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    """
+    validate_schema(name='account_attribute', obj=key, vo=vo)
+    validate_schema(name='account_attribute', obj=value, vo=vo)
+
+    kwargs = {'account': account, 'key': key, 'value': value}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='add_attribute', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not add attributes' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    account_core.add_account_attribute(account, key, value, session=session)
+
+
+@transactional_session
+def del_account_attribute(key, account, issuer, vo='def', *, session: "Session"):
+    """
+    Delete an attribute to an account.
+
+    :param key: attribute key.
+    :param account: The account name.
+    :param issuer: The issuer account.
+    :param vo: The VO to act on.
+    :param session: The database session in use.
+    """
+    kwargs = {'account': account, 'key': key}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='del_attribute', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not delete attribute' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    account_core.del_account_attribute(account, key, session=session)
+
+
+@read_session
+def get_usage(rse, account, issuer, vo='def', *, session: "Session"):
+    """
+    Returns current values of the specified counter, or raises CounterNotFound if the counter does not exist.
+
+    :param rse:              The RSE.
+    :param account:          The account name.
+    :param issuer:           The issuer account.
+    :param vo:               The VO to act on.
+    :param session:          The database session in use.
+    :returns:                A dictionary with total and bytes.
+    """
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.get_usage(rse_id, account, session=session)
+
+
+@read_session
+def get_usage_history(rse, account, issuer, vo='def', *, session: "Session"):
+    """
+    Returns historical values of the specified counter, or raises CounterNotFound if the counter does not exist.
+
+    :param rse:              The RSE.
+    :param account:          The account name.
+    :param issuer:           The issuer account.
+    :param vo:               The VO to act on.
+    :param session:          The database session in use.
+    :returns:                A dictionary with total and bytes.
+    """
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+    account = InternalAccount(account, vo=vo)
+
+    return account_core.get_usage_history(rse_id, account, session=session)

rucio/api/account_limit.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING
+
+import rucio.api.permission
+import rucio.common.exception
+from rucio.common.types import InternalAccount
+from rucio.common.utils import api_update_return_dict
+from rucio.core import account_limit as account_limit_core
+from rucio.core.account import account_exists
+from rucio.core.rse import get_rse_id, get_rse_name
+from rucio.db.sqla.session import read_session, transactional_session
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+
+@read_session
+def get_rse_account_usage(rse, vo='def', *, session: "Session"):
+    """
+    Returns the account limit and usage for all for all accounts on a RSE.
+
+    :param rse:      The RSE name.
+    :param vo:       The VO to act on.
+    :param session:  The database session in use.
+    :return:         List of dictionnaries.
+    """
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+
+    return [api_update_return_dict(d, session=session) for d in account_limit_core.get_rse_account_usage(rse_id=rse_id, session=session)]
+
+
+@read_session
+def get_local_account_limits(account, vo='def', *, session: "Session"):
+    """
+    Lists the limitation names/values for the specified account name.
+
+    REST API: http://<host>:<port>/rucio/account/<account>/limits
+
+    :param account:     The account name.
+    :param vo:          The VO to act on.
+    :param session:     The database session in use.
+
+    :returns: The account limits.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    rse_instead_id = {}
+    for elem in account_limit_core.get_local_account_limits(account=account, session=session).items():
+        rse_instead_id[get_rse_name(rse_id=elem[0], session=session)] = elem[1]
+    return rse_instead_id
+
+
+@read_session
+def get_local_account_limit(account, rse, vo='def', *, session: "Session"):
+    """
+    Lists the limitation names/values for the specified account name and rse name.
+
+    REST API: http://<host>:<port>/rucio/account/<account>/limits
+
+    :param account:     The account name.
+    :param rse:         The rse name.
+    :param vo:          The VO to act on.
+    :param session:     The database session in use.
+
+    :returns: The account limit.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+    return {rse: account_limit_core.get_local_account_limit(account=account, rse_id=rse_id, session=session)}
+
+
+@read_session
+def get_global_account_limits(account, vo='def', *, session: "Session"):
+    """
+    Lists the limitation names/values for the specified account name.
+
+    REST API: http://<host>:<port>/rucio/account/<account>/limits
+
+    :param account:     The account name.
+    :param vo:          The VO to act on.
+    :param session:     The database session in use.
+
+    :returns: The account limits.
+    """
+    if account:
+        account = InternalAccount(account, vo=vo)
+    else:
+        account = InternalAccount('*', vo=vo)
+
+    return account_limit_core.get_global_account_limits(account=account, session=session)
+
+
+@read_session
+def get_global_account_limit(account, rse_expression, vo='def', *, session: "Session"):
+    """
+    Lists the limitation names/values for the specified account name and rse expression.
+
+    REST API: http://<host>:<port>/rucio/account/<account>/limits
+
+    :param account:         The account name.
+    :param rse_expression:  The rse expression.
+    :param vo:              The VO to act on.
+    :param session:         The database session in use.
+
+    :returns: The account limit.
+    """
+
+    account = InternalAccount(account, vo=vo)
+
+    return {rse_expression: account_limit_core.get_global_account_limit(account=account, rse_expression=rse_expression, session=session)}
+
+
+@transactional_session
+def set_local_account_limit(account, rse, bytes_, issuer, vo='def', *, session: "Session"):
+    """
+    Set an account limit..
+
+    :param account: The account name.
+    :param rse:     The rse name.
+    :param bytes_:   The limit in bytes.
+    :param issuer:  The issuer account_core.
+    :param vo:      The VO to act on.
+    :param session: The database session in use.
+    """
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+
+    kwargs = {'account': account, 'rse': rse, 'rse_id': rse_id, 'bytes': bytes_}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='set_local_account_limit', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not set account limits.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (account))
+
+    account_limit_core.set_local_account_limit(account=account, rse_id=rse_id, bytes_=bytes_, session=session)
+
+
+@transactional_session
+def set_global_account_limit(account, rse_expression, bytes_, issuer, vo='def', *, session: "Session"):
+    """
+    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.
+    :param session:         The database session in use.
+    """
+
+    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, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not set account limits.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        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_, session=session)
+
+
+@transactional_session
+def delete_local_account_limit(account, rse, issuer, vo='def', *, session: "Session"):
+    """
+    Delete an account limit..
+
+    :param account: The account name.
+    :param rse:     The rse name.
+    :param issuer:  The issuer account_core.
+    :param vo:      The VO to act on.
+    :param session: The database session in use.
+
+    :returns: True if successful; False otherwise.
+    """
+
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+    kwargs = {'account': account, 'rse': rse, 'rse_id': rse_id}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='delete_local_account_limit', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not delete account limits.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (account))
+
+    return account_limit_core.delete_local_account_limit(account=account, rse_id=rse_id, session=session)
+
+
+@transactional_session
+def delete_global_account_limit(account, rse_expression, issuer, vo='def', *, session: "Session"):
+    """
+    Delete a global account limit..
+
+    :param account:        The account name.
+    :param rse_expression: The rse expression.
+    :param issuer:         The issuer account_core.
+    :param vo:             The VO to act on.
+    :param session:        The database session in use.
+
+    :returns: True if successful; False otherwise.
+    """
+
+    kwargs = {'account': account, 'rse_expression': rse_expression}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='delete_global_account_limit', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not delete global account limits.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (account))
+
+    return account_limit_core.delete_global_account_limit(account=account, rse_expression=rse_expression, session=session)
+
+
+@read_session
+def get_local_account_usage(account, rse, issuer, vo='def', *, session: "Session"):
+    """
+    Get the account usage and connect it with (if available) the account limits of the account.
+
+    :param account:  The account to read.
+    :param rse:      The rse to read (If none, get all).
+    :param issuer:   The issuer account.
+    :param vo:       The VO to act on.
+    :param session:  The database session in use.
+
+    :returns:        List of dicts {'rse_id', 'rse', 'bytes', 'files', 'bytes_limit', 'bytes_remaining'}
+    """
+
+    rse_id = None
+
+    if rse:
+        rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+    kwargs = {'account': account, 'rse': rse, 'rse_id': rse_id}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='get_local_account_usage', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not list account usage.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (account))
+
+    return [api_update_return_dict(d, session=session) for d in account_limit_core.get_local_account_usage(account=account, rse_id=rse_id, session=session)]
+
+
+@read_session
+def get_global_account_usage(account, rse_expression, issuer, vo='def', *, session: "Session"):
+    """
+    Get the account usage and connect it with (if available) the account limits of the account.
+
+    :param account:         The account to read.
+    :param rse_expression:  The rse expression to read (If none, get all).
+    :param issuer:          The issuer account.
+    :param vo:              The VO to act on.
+    :param session:         The database session in use.
+
+    :returns:               List of dicts {'rse_id', 'rse', 'bytes', 'files', 'bytes_limit', 'bytes_remaining'}
+    """
+
+    kwargs = {'account': account, 'rse_expression': rse_expression}
+    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='get_global_account_usage', kwargs=kwargs, session=session):
+        raise rucio.common.exception.AccessDenied('Account %s can not list global account usage.' % (issuer))
+
+    account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (account))
+
+    return [api_update_return_dict(d, session=session) for d in account_limit_core.get_global_account_usage(account=account, rse_expression=rse_expression, session=session)]