rucio 37.0.0rc1__py3-none-any.whl

rucio/gateway/account.py

@@ -0,0 +1,345 @@
+# 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, Any, Optional
+
+import rucio.common.exception
+import rucio.core.identity
+import rucio.gateway.permission
+from rucio.common.schema import validate_schema
+from rucio.common.types import InternalAccount
+from rucio.common.utils import gateway_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 collections.abc import Iterator
+
+    from sqlalchemy.orm import Session
+
+    from rucio.common.types import AccountAttributesDict, IdentityDict, UsageDict
+    from rucio.db.sqla.models import Account
+
+
+@transactional_session
+def add_account(
+    account: str,
+    type_: str,
+    email: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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_}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='add_account', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not add account. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    account_core.add_account(internal_account, AccountType[type_.upper()], email, session=session)
+
+
+@transactional_session
+def del_account(
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='del_account', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not delete account. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    account_core.del_account(internal_account, session=session)
+
+
+@read_session
+def get_account_info(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "Account":
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    acc = account_core.get_account(internal_account, session=session)
+    acc.account = acc.account.external
+    return acc
+
+
+@transactional_session
+def update_account(
+    account: str,
+    key: str,
+    value: Any,
+    issuer: str = 'root',
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """ 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 = {}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='update_account', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not change %s  of the account. %s' % (issuer, key, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.update_account(internal_account, key, value, session=session)
+
+
+@stream_session
+def list_accounts(filter_: Optional[dict[str, Any]] = None, vo: str = 'def', *, session: "Session") -> 'Iterator[dict[str, Any]]':
+    """
+    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
+    filter_ = filter_ or {}
+
+    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 gateway_update_return_dict(result, session=session)
+
+
+@read_session
+def account_exists(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> bool:
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.account_exists(internal_account, session=session)
+
+
+@read_session
+def list_identities(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list["IdentityDict"]:
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.list_identities(internal_account, session=session)
+
+
+@read_session
+def list_account_attributes(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list["AccountAttributesDict"]:
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.list_account_attributes(internal_account, session=session)
+
+
+@transactional_session
+def add_account_attribute(
+    key: str,
+    value: Any,
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='add_attribute', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not add attributes. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    account_core.add_account_attribute(internal_account, key, value, session=session)
+
+
+@transactional_session
+def del_account_attribute(
+    key: str,
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='del_attribute', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not delete attribute. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    account_core.del_account_attribute(internal_account, key, session=session)
+
+
+@read_session
+def get_usage(
+    rse: str,
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "UsageDict":
+    """
+    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)
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.get_usage(rse_id, internal_account, session=session)
+
+
+@read_session
+def get_usage_history(
+    rse: str,
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list["UsageDict"]:
+    """
+    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)
+    internal_account = InternalAccount(account, vo=vo)
+
+    return account_core.get_usage_history(rse_id, internal_account, session=session)

rucio/gateway/account_limit.py

@@ -0,0 +1,363 @@
+# 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, Any, Union
+
+import rucio.common.exception
+import rucio.gateway.permission
+from rucio.common.types import InternalAccount, RSEResolvedGlobalAccountLimitDict
+from rucio.common.utils import gateway_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: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list[dict[str, Any]]:
+    """
+    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 dictionaries.
+    """
+    rse_id = get_rse_id(rse=rse, vo=vo, session=session)
+
+    return [gateway_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: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, Any]:
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    rse_instead_id = {}
+    for elem in account_limit_core.get_local_account_limits(account=internal_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: str,
+    rse: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, Union[int, float, None]]:
+    """
+    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.
+    """
+
+    internal_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=internal_account, rse_id=rse_id, session=session)}
+
+
+@read_session
+def get_global_account_limits(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, RSEResolvedGlobalAccountLimitDict]:
+    """
+    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:
+        internal_account = InternalAccount(account, vo=vo)
+    else:
+        internal_account = InternalAccount('*', vo=vo)
+
+    return account_limit_core.get_global_account_limits(account=internal_account, session=session)
+
+
+@read_session
+def get_global_account_limit(
+    account: str,
+    rse_expression: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, dict[str, RSEResolvedGlobalAccountLimitDict]]:
+    """
+    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.
+    """
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    return {rse_expression: account_limit_core.get_global_account_limit(account=internal_account, rse_expression=rse_expression, session=session)}
+
+
+@transactional_session
+def set_local_account_limit(
+    account: str,
+    rse: str,
+    bytes_: int,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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_}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='set_local_account_limit', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not set account limits. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    account_limit_core.set_local_account_limit(account=internal_account, rse_id=rse_id, bytes_=bytes_, session=session)
+
+
+@transactional_session
+def set_global_account_limit(
+    account: str,
+    rse_expression: str,
+    bytes_: int,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
+    """
+    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_}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='set_global_account_limit', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not set account limits. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    account_limit_core.set_global_account_limit(account=internal_account, rse_expression=rse_expression, bytes_=bytes_, session=session)
+
+
+@transactional_session
+def delete_local_account_limit(
+    account: str,
+    rse: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> bool:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='delete_local_account_limit', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not delete account limits. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    return account_limit_core.delete_local_account_limit(account=internal_account, rse_id=rse_id, session=session)
+
+
+@transactional_session
+def delete_global_account_limit(
+    account: str,
+    rse_expression: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> bool:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='delete_global_account_limit', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not delete global account limits. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    return account_limit_core.delete_global_account_limit(account=internal_account, rse_expression=rse_expression, session=session)
+
+
+@read_session
+def get_local_account_usage(
+    account: str,
+    rse: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list[dict[str, Any]]:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='get_local_account_usage', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not list account usage. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    return [gateway_update_return_dict(d, session=session) for d in account_limit_core.get_local_account_usage(account=internal_account, rse_id=rse_id, session=session)]
+
+
+@read_session
+def get_global_account_usage(
+    account: str,
+    rse_expression: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list[dict[str, Any]]:
+    """
+    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}
+    auth_result = rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='get_global_account_usage', kwargs=kwargs, session=session)
+    if not auth_result.allowed:
+        raise rucio.common.exception.AccessDenied('Account %s can not list global account usage. %s' % (issuer, auth_result.message))
+
+    internal_account = InternalAccount(account, vo=vo)
+
+    if not account_exists(account=internal_account, session=session):
+        raise rucio.common.exception.AccountNotFound('Account %s does not exist' % (internal_account))
+
+    return [gateway_update_return_dict(d, session=session) for d in account_limit_core.get_global_account_usage(account=internal_account, rse_expression=rse_expression, session=session)]