rucio 38.3.0__py3-none-any.whl → 38.5.0__py3-none-any.whl

rucio/core/did_meta_plugins/json_meta.py

@@ -38,7 +38,8 @@ class JSONDidMeta(DidMetaPlugin):
 
     def __init__(self):
         super(JSONDidMeta, self).__init__()
-        self.plugin_name = "JSON"
+
+        self._plugin_name = "JSON"
 
     @read_session
     def get_metadata(self, scope, name, *, session: "Session"):
@@ -231,10 +232,3 @@ class JSONDidMeta(DidMetaPlugin):
     @read_session
     def manages_key(self, key, *, session: "Session"):
         return json_implemented(session=session)
-
-    def get_plugin_name(self):
-        """
-        Returns a unique identifier for this plugin. This can be later used for filtering down results to this plugin only.
-        :returns: The name of the plugin.
-        """
-        return self.plugin_name

rucio/core/did_meta_plugins/mongo_meta.py

@@ -81,7 +81,7 @@ class MongoDidMeta(DidMetaPlugin):
         self.db = self.client[con_params['mongo_db']]
         self.col = self.db[con_params['mongo_collection']]
 
-        self.plugin_name = "MONGO"
+        self._plugin_name = "MONGO"
 
     def drop_database(self):
         self.client.drop_database(self.db.name)
@@ -188,9 +188,8 @@ class MongoDidMeta(DidMetaPlugin):
         if recursive:
             # TODO: possible, but requires retrieving the results of a concurrent sqla query to call list_content on for datasets and containers
             raise exception.UnsupportedOperation(
-                "'{}' metadata module does not currently support recursive searches".format(
-                    self.plugin_name.lower()
-                ))
+                "'{}' metadata module does not currently support recursive searches".format(self.name)
+            )
 
         if long:
             query_result = self.col.find(mongo_query_str)
@@ -219,11 +218,3 @@ class MongoDidMeta(DidMetaPlugin):
 
     def manages_key(self, key, *, session: "Optional[Session]" = None):
         return True
-
-    def get_plugin_name(self):
-        """
-        Returns a unique identifier for this plugin. This can be later used for filtering down results to this plugin only.
-
-        :returns: The name of the plugin
-        """
-        return self.plugin_name

rucio/core/did_meta_plugins/postgres_meta.py

@@ -95,7 +95,7 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
         else:                                       # managed by Rucio, create a metadata table if it doesn't exist
             self._try_create_metadata_table()
 
-        self.plugin_name = "POSTGRES_JSON"
+        self._plugin_name = "POSTGRES_JSON"
 
     def _try_create_metadata_table(self):
         """
@@ -260,17 +260,19 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
 
     def delete_metadata(self, scope, name, key, *, session: "Optional[Session]" = None):
         """
-        Delete a key from metadata.
+        Delete a key from metadata of DID.
 
         :param scope: the scope of DID
         :param name: the name of the DID
         :param key: the key to be deleted
         :param session: the database session in use
         """
-        statement = sql.SQL("UPDATE {} SET data = {}.data - {}").format(
+        statement = sql.SQL("UPDATE {} SET data = {}.data - {} WHERE scope = {} AND name = {}").format(
             sql.Identifier(self.table),
             sql.Identifier(self.table),
-            sql.Literal(key)
+            sql.Literal(key),
+            sql.Literal(scope.internal),
+            sql.Literal(name)
         )
 
         cur = self.client.cursor()
@@ -306,7 +308,7 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
             # TODO: possible, but requires retrieving the results of a concurrent sqla query to call list_content
             #       on for datasets and containers
             raise exception.UnsupportedOperation(
-                "'{}' metadata module does not currently support recursive searches".format(self.plugin_name.lower())
+                "'{}' metadata module does not currently support recursive searches".format(self.name)
             )
 
         statement = sql.SQL("SELECT * FROM {} WHERE {} {}").format(
@@ -341,12 +343,3 @@ class ExternalPostgresJSONDidMeta(DidMetaPlugin):
 
     def manages_key(self, key, *, session: "Optional[Session]" = None):
         return True
-
-    def get_plugin_name(self):
-        """
-        Returns a unique identifier for this plugin. This can be later used for filtering down results to this
-        plugin only.
-
-        :returns: The name of the plugin
-        """
-        return self.plugin_name

rucio/core/dirac.py

@@ -99,7 +99,7 @@ def add_files(
     # The list of scopes is necessary for the extract_scope
     filter_ = {'scope': InternalScope(scope='*', vo=vo)}
     scopes = list_scopes(filter_=filter_, session=session)
-    scopes = [scope.external for scope in scopes]
+    scopes = [scope['scope'].external for scope in scopes]
     exist_lfn = []
     try:
         config_lifetime: str = config_get(section='dirac', option='lifetime', default='{}', session=session)

rucio/core/opendata.py

@@ -21,10 +21,14 @@ from sqlalchemy.exc import DataError, IntegrityError
 from sqlalchemy.sql.expression import bindparam, select
 
 from rucio.common import exception
+from rucio.common.config import config_get, config_get_bool, config_get_int
+from rucio.common.constants import DEFAULT_VO
 from rucio.common.exception import OpenDataError, OpenDataInvalidStateUpdate
+from rucio.common.types import InternalAccount
 from rucio.core.did import list_files
 from rucio.core.monitor import MetricManager
 from rucio.core.replica import list_replicas
+from rucio.core.rule import add_rule
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import DIDType, OpenDataDIDState
 
@@ -300,6 +304,7 @@ def get_opendata_did(
         include_files: bool = True,
         include_metadata: bool = False,
         include_doi: bool = True,
+        include_rule: bool = True,
         session: "Session",
 ) -> dict[str, Any]:
     """
@@ -312,10 +317,11 @@ def get_opendata_did(
         include_files: If True, include a list of associated files. Defaults to True.
         include_metadata: If True, include extended metadata. Defaults to False.
         include_doi: If True, include DOI (Digital Object Identifier) information. Defaults to True.
+        include_rule: If True, include the Opendata replication rule. Defaults to True.
         session: SQLAlchemy session to use for the query.
 
     Returns:
-        A dictionary containing metadata about the specified DID.
+        A dictionary containing info about the specified DID which include "scope", "name", "state", "meta" (if requested), etc.
     """
 
     query = select(
@@ -345,6 +351,8 @@ def get_opendata_did(
         result["doi"] = get_opendata_doi(scope=scope, name=name, session=session)
     if include_metadata:
         result["meta"] = get_opendata_meta(scope=scope, name=name, session=session)
+    if include_rule:
+        result["rule"] = _fetch_opendata_rule(scope=scope, name=name, session=session)
     if include_files:
         opendata_files = get_opendata_did_files(scope=scope, name=name, session=session)
         result["files"] = opendata_files
@@ -508,7 +516,7 @@ def update_opendata_did(
         meta: Optional[Union[dict, str]] = None,
         doi: Optional[str] = None,
         session: "Session",
-) -> None:
+) -> dict[str, Any]:
     """
     Update an existing Opendata DID in the catalog.
 
@@ -520,6 +528,9 @@ def update_opendata_did(
         doi: DOI to associate with the DID. Must be a valid DOI string (e.g., "10.1234/foo.bar").
         session: SQLAlchemy session to use for the operation.
 
+    Returns:
+        A dictionary containing the scope and name of the DID and details of the updates performed. (e.g., new/old state, new/old DOI, etc.)
+
     Raises:
         InputValidationError: If none of 'state', 'meta', or 'doi' are provided, or if the provided data is invalid.
         OpenDataDataIdentifierNotFound: If the Opendata DID does not exist.
@@ -533,14 +544,18 @@ def update_opendata_did(
     if not _check_opendata_did_exists(scope=scope, name=name, session=session):
         raise exception.OpenDataDataIdentifierNotFound(f"OpenData DID '{scope}:{name}' not found.")
 
+    result = {}
+
     if state is not None:
-        update_opendata_state(scope=scope, name=name, state=state, session=session)
+        result |= update_opendata_state(scope=scope, name=name, state=state, session=session)
 
     if meta is not None:
-        update_opendata_meta(scope=scope, name=name, meta=meta, session=session)
+        result |= update_opendata_meta(scope=scope, name=name, meta=meta, session=session)
 
     if doi is not None:
-        update_opendata_doi(scope=scope, name=name, doi=doi, session=session)
+        result |= update_opendata_doi(scope=scope, name=name, doi=doi, session=session)
+
+    return result
 
 
 def update_opendata_meta(
@@ -549,7 +564,7 @@ def update_opendata_meta(
         name: str,
         meta: Union[dict, str],
         session: "Session",
-) -> None:
+) -> dict[str, Any]:
     """
     Update the metadata associated with an Opendata DID.
 
@@ -559,6 +574,9 @@ def update_opendata_meta(
         meta: Metadata to update for the DID. Must be a valid JSON object or string.
         session: SQLAlchemy session to use for the operation.
 
+    Returns:
+        A dictionary containing the scope, name, and updated metadata of the Opendata DID.
+
     Raises:
         InputValidationError: If 'meta' is not a dictionary or a valid JSON string.
         OpenDataDataIdentifierNotFound: If the Opendata DID does not exist.
@@ -598,6 +616,93 @@ def update_opendata_meta(
     except DataError as error:
         raise exception.InputValidationError(f"Invalid data: {error}")
 
+    return {"scope": scope, "name": name, "meta_new": meta}
+
+
+def _fetch_opendata_rule(scope: "InternalScope",
+                         name: str,
+                         session: "Session"
+                         ) -> Optional[str]:
+    """
+    Retrieves the replication rule ID associated with an Opendata DID, if it exists.
+    The rule is searched for in the rules table by matching the scope, name, account (root), rse_expression,
+    and copies (1) based on the configuration used for creating the rule.
+
+    Parameters:
+        scope: The scope under which the Opendata DID is registered.
+        name: The name of the Opendata DID.
+        session: SQLAlchemy session to use for the query.
+    Returns:
+        The replication rule ID if it exists, otherwise None.
+    """
+
+    rule_rse_expression = config_get("opendata", "rule_rse_expression", raise_exception=False, default=None)
+    if not rule_rse_expression:
+        return None
+
+    rule_account = config_get("opendata", "rule_account", raise_exception=False, default="root")
+    rule_vo = config_get("opendata", "rule_vo", raise_exception=False, default=DEFAULT_VO)
+    rule_copies = config_get_int("opendata", "rule_copies", raise_exception=False, default=1)
+
+    return session.execute(
+        select(models.ReplicationRule.id).where(
+            and_(
+                models.ReplicationRule.scope == scope,
+                models.ReplicationRule.name == name,
+                models.ReplicationRule.account == InternalAccount(account=rule_account, vo=rule_vo),
+                models.ReplicationRule.rse_expression == rule_rse_expression,
+                models.ReplicationRule.copies == rule_copies,
+            )
+        )
+    ).scalar()
+
+
+def _add_opendata_rule(
+        scope: "InternalScope",
+        name: str,
+        session: "Session"
+) -> str:
+    """
+    Create a replication rule for an Opendata DID.
+    The rule is created with parameters defined in the configuration file under the [opendata] section.
+
+    Parameters:
+        scope: The scope under which the Opendata DID is registered.
+        name: The name of the Opendata DID.
+        session: SQLAlchemy session to use for the operation.
+    Returns:
+        The ID of the created replication rule.
+    Raises:
+        ValueError: If there is an error during the rule creation process.
+    """
+
+    rule_asynchronous = config_get_bool("opendata", "rule_asynchronous", raise_exception=False, default=False)
+    rule_activity = config_get("opendata", "rule_activity", raise_exception=False, default=None)
+    rule_rse_expression = config_get("opendata", "rule_rse_expression", raise_exception=True)
+    rule_account = config_get("opendata", "rule_account", raise_exception=False, default="root")
+    rule_vo = config_get("opendata", "rule_vo", raise_exception=False, default=DEFAULT_VO)
+    rule_copies = config_get_int("opendata", "rule_copies", raise_exception=False, default=1)
+
+    add_rule_result = add_rule(
+        dids=[{"scope": scope, "name": name}],
+        # We need an account, perhaps we should pass the issuer argument around like in other methods with account
+        account=InternalAccount(account=rule_account, vo=rule_vo),
+        copies=rule_copies,
+        rse_expression=rule_rse_expression,
+        grouping="DATASET",
+        weight=None,
+        lifetime=None,
+        locked=False,
+        subscription_id=None,
+        activity=rule_activity,
+        asynchronous=rule_asynchronous,
+        session=session,
+    )
+    if len(add_rule_result) != 1:
+        raise ValueError(f"Error adding Open Data rule: {add_rule_result}")
+
+    return add_rule_result[0]
+
 
 def update_opendata_state(
         *,
@@ -605,9 +710,10 @@ def update_opendata_state(
         name: str,
         state: OpenDataDIDState,
         session: "Session",
-) -> None:
+) -> dict[str, Any]:
     """
     Update the state of an Opendata DID.
+    If the new state is PUBLIC, a replication rule may be created based on configuration.
 
     Parameters:
         scope: The scope under which the Opendata DID is registered.
@@ -615,6 +721,9 @@ def update_opendata_state(
         state: The new state to set for the Opendata DID.
         session: SQLAlchemy session to use for the operation.
 
+    Returns:
+        A dictionary with the scope and name of the DID and the rule id if a rule was created and the old and new state.
+
     Raises:
         InputValidationError: If the provided state is not a valid OpenDataDIDState.
         OpenDataDataIdentifierNotFound: If the Opendata DID does not exist.
@@ -676,15 +785,30 @@ def update_opendata_state(
         if state_before == OpenDataDIDState.DRAFT:
             raise OpenDataInvalidStateUpdate("Cannot set state to SUSPENDED from DRAFT. First set it to PUBLIC.")
 
+    output = {"scope": scope, "name": name, "state_old": state_before, "state_new": state}
+
     try:
         result = session.execute(update_query)
 
         if result.rowcount == 0:
             raise ValueError(f"Error updating Opendata state for DID '{scope}:{name}'.")
 
+        if state == OpenDataDIDState.PUBLIC:
+            rule_enable = config_get_bool("opendata", "rule_enable", raise_exception=False, default=False)
+            if rule_enable:
+                rule_id = _fetch_opendata_rule(scope=scope, name=name, session=session)
+                if rule_id:
+                    output["rule"] = rule_id
+                    output["comments"] = "Replication rule already exists"
+                else:
+                    output["rule"] = _add_opendata_rule(scope=scope, name=name, session=session)
+                    output["comments"] = "Replication rule created"
+
     except DataError as error:
         raise exception.InputValidationError(f"Invalid data: {error}")
 
+    return output
+
 
 def update_opendata_doi(
         *,
@@ -692,7 +816,7 @@ def update_opendata_doi(
         name: str,
         doi: str,
         session: "Session",
-) -> None:
+) -> dict[str, Any]:
     """
     Update the DOI (Digital Object Identifier) associated with an Opendata DID.
 
@@ -702,6 +826,9 @@ def update_opendata_doi(
         doi: The new DOI to associate with the Opendata DID. Must be a valid DOI string.
         session: SQLAlchemy session to use for the operation.
 
+    Returns:
+        A dictionary containing the scope, name, new DOI, and previous DOI of the Opendata DID.
+
     Raises:
         InputValidationError: If the provided DOI is not a valid string or does not match the expected format.
         OpenDataDataIdentifierNotFound: If the Opendata DID does not exist.
@@ -740,5 +867,20 @@ def update_opendata_doi(
         if result.rowcount == 0:
             raise ValueError(f"Error updating Opendata DOI for DID '{scope}:{name}'.")
 
+    except IntegrityError as error:
+        msg = str(error)
+
+        if (
+                search(r'ORA-00001: unique constraint \([^)]+\) violated', msg)
+                or search(r'UNIQUE constraint failed: dids_opendata_doi\.doi', msg)
+                or search(r'1062.*Duplicate entry.*for key', msg)
+                or search(r'duplicate key value violates unique constraint', msg)
+                or search(r'columns?.*not unique', msg)
+        ):
+            raise exception.OpenDataDuplicateDOI(doi=doi)
+
+        raise exception.OpenDataError()
     except DataError as error:
         raise exception.InputValidationError(f"Invalid data: {error}")
+
+    return {"scope": scope, "name": name, "doi_new": doi, "doi_old": doi_before}

rucio/core/rse.py

@@ -824,8 +824,12 @@ def list_rses(filters: Optional[dict[str, Any]] = None, *, session: "Session") -
 
         for (k, v) in filters.items():
             if hasattr(models.RSE, k):
-                if k == 'rse_type':
-                    stmt = stmt.where(getattr(models.RSE, k) == RSEType[v])
+                # API calls always provide str, but some core calls use the right type
+                if isinstance(v, str):
+                    try:
+                        stmt = stmt.where(getattr(models.RSE, k) == models.RSE.from_str(k, v))
+                    except ValueError as e:
+                        raise exception.InvalidObject(*e.args)
                 else:
                     stmt = stmt.where(getattr(models.RSE, k) == v)
             else:

rucio/core/rule_grouping.py

@@ -690,7 +690,7 @@ def __repair_stuck_locks_with_none_grouping(datasetfiles, locks, replicas, sourc
                     associated_replica.lock_cnt = session.execute(stmt).scalar_one()
                     continue
                 # Check if this is a STUCK lock due to source_replica filtering
-                if source_rses:
+                if source_rses and not lock.repair_cnt:
                     associated_replica = [replica for replica in replicas[(file['scope'], file['name'])] if replica.rse_id == lock.rse_id][0]
                     # Check if there is an eligible source replica for this lock
                     if set(source_replicas.get((file['scope'], file['name']), [])).intersection(source_rses) and (selector_rse_dict.get(lock.rse_id, {}).get('availability_write', True) or rule.ignore_availability):
@@ -806,7 +806,7 @@ def __repair_stuck_locks_with_all_grouping(datasetfiles, locks, replicas, source
                     associated_replica.lock_cnt = session.execute(stmt).scalar_one()
                     continue
                 # Check if this is a STUCK lock due to source_replica filtering
-                if source_rses:
+                if source_rses and not lock.repair_cnt:
                     associated_replica = [replica for replica in replicas[(file['scope'], file['name'])] if replica.rse_id == lock.rse_id][0]
                     # Check if there is an eligible source replica for this lock
                     if set(source_replicas.get((file['scope'], file['name']), [])).intersection(source_rses) and (selector_rse_dict.get(lock.rse_id, {}).get('availability_write', True) or rule.ignore_availability):
@@ -891,7 +891,7 @@ def __repair_stuck_locks_with_dataset_grouping(datasetfiles, locks, replicas, so
                     associated_replica.lock_cnt = session.execute(stmt).scalar_one()
                     continue
                 # Check if this is a STUCK lock due to source_replica filtering
-                if source_rses:
+                if source_rses and not lock.repair_cnt:
                     associated_replica = [replica for replica in replicas[(file['scope'], file['name'])] if replica.rse_id == lock.rse_id][0]
                     # Check if there is an eligible source replica for this lock
                     if set(source_replicas.get((file['scope'], file['name']), [])).intersection(source_rses) and (selector_rse_dict.get(lock.rse_id, {}).get('availability_write', True) or rule.ignore_availability):

rucio/core/scope.py

@@ -14,21 +14,24 @@
 
 from re import match
 from traceback import format_exc
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
-from sqlalchemy import and_, select
+from sqlalchemy import and_, select, update
 from sqlalchemy.exc import IntegrityError
 
-from rucio.common.exception import AccountNotFound, Duplicate, RucioException, VONotFound
+import rucio.core.account as account_core
+from rucio.common.exception import AccountNotFound, Duplicate, RucioException, ScopeNotFound, VONotFound
 from rucio.core.vo import vo_exists
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import AccountStatus, ScopeStatus
 from rucio.db.sqla.session import read_session, transactional_session
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from sqlalchemy.orm import Session
 
-    from rucio.common.types import InternalScope
+    from rucio.common.types import InternalAccount, InternalScope
 
 
 @transactional_session
@@ -87,7 +90,7 @@ def bulk_add_scopes(scopes, account, skip_existing=False, *, session: "Session")
 
 
 @read_session
-def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session") -> list["InternalScope"]:
+def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session") -> "Iterable[dict[Literal['scope', 'account'], Any]]":
     """
     Lists all scopes.
     :param filter_: Dictionary of attributes by which the input data should be filtered
@@ -97,7 +100,8 @@ def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session")
     """
     filter_ = filter_ or {}
     stmt = select(
-        models.Scope.scope
+        models.Scope.scope,
+        models.Scope.account
     ).where(
         models.Scope.status != ScopeStatus.DELETED
     )
@@ -112,8 +116,14 @@ def list_scopes(filter_: Optional[dict[str, Any]] = None, *, session: "Session")
                 stmt = stmt.where(
                     models.Scope.scope == filter_['scope']
                 )
+    scopes = []
+    for scope, account in session.execute(stmt):
+        scopes.append({
+            "scope": scope,
+            "account": account
+        })
 
-    return list(session.execute(stmt).scalars().all())
+    return scopes
 
 
 @read_session
@@ -179,3 +189,33 @@ def is_scope_owner(scope, account, *, session: "Session"):
              models.Scope.account == account)
     )
     return bool(session.execute(stmt).scalar())
+
+
+@transactional_session
+def update_scope(scope: "InternalScope", account: "InternalAccount", *, session: "Session") -> None:
+    """ Give the scope a new owner
+
+    :param scope: the name for the existing scope.
+    :param account: the account to add the scope to.
+    :param session: The database session in use.
+    """
+
+    if not vo_exists(vo=scope.vo, session=session):
+        raise VONotFound('VO {} not found'.format(scope.vo))
+
+    # Verify both the scope and account exist
+    account_core.get_account(account, session=session)
+    if not check_scope(scope):
+        raise ScopeNotFound
+
+    stmt = update(
+        models.Scope
+    ).where(
+        models.Scope.scope == scope
+    ).values({
+        models.Scope.account: account
+    })
+    try:
+        session.execute(stmt)
+    except Exception:
+        raise RucioException(str(format_exc()))

rucio/daemons/automatix/automatix.py

@@ -177,6 +177,8 @@ def run_once(heartbeat_handler: HeartbeatHandler, inputfile: str, **_kwargs) ->
     vo = map_vo(client.vo)  # type: ignore
     filters = {"scope": InternalScope("*", vo=vo)}
     scopes = list_scopes(filter_=filters)
+    if not isinstance(scopes[0], str):   # TODO Backwards Compat - Remove in v40, #8125
+        scopes = [scope['scope'] for scope in scopes]
     if InternalScope(scope, vo=vo) not in scopes:
         logger(logging.ERROR, "Scope %s does not exist. Exiting", scope)
         return True

rucio/db/sqla/models.py

@@ -877,6 +877,28 @@ class RSE(BASE, SoftModelBase):
                    CheckConstraint('RSE_TYPE IS NOT NULL', name='RSES_TYPE_NN'),
                    ForeignKeyConstraint(['vo'], ['vos.vo'], name='RSES_VOS_FK'), )
 
+    @staticmethod
+    def from_str(key: str, value: str) -> Any:
+        """Parses str value to key-specific database type."""
+
+        if key in ['deterministic', 'volatile', 'staging_area', 'availability_read', 'availability_write', 'availability_delete']:
+            # boolean types
+            if value == '1' or value.casefold() == 'true'.casefold():
+                return True
+            elif value == '0' or value.casefold() == 'false'.casefold():
+                return False
+            else:
+                raise ValueError(f'Invalid boolean value: {value}')
+
+        elif key == 'rse_type':
+            try:
+                return RSEType[value]
+            except KeyError:
+                raise ValueError(f'Invalid rse_type: {value}')
+
+        else:
+            return value
+
 
 class RSELimit(BASE, ModelBase):
     """Represents RSE limits"""

rucio/gateway/account.py

@@ -14,10 +14,9 @@
 
 from typing import TYPE_CHECKING, Any, Optional
 
-import rucio.common.exception
-import rucio.core.identity
 import rucio.gateway.permission
 from rucio.common.constants import DEFAULT_VO
+from rucio.common.exception import AccessDenied, InvalidAccountType
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount
 from rucio.common.utils import gateway_update_return_dict
@@ -55,11 +54,13 @@ def add_account(
     validate_schema(name='account', obj=account, vo=vo)
 
     kwargs = {'account': account, 'type': type_}
+    if type_.upper() not in AccountType._member_names_:
+        raise InvalidAccountType(f"{type_} is an invalid account type. Choose from {AccountType._member_names_}")
 
     with db_session(DatabaseOperationType.WRITE) as session:
         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))
+            raise AccessDenied('Account %s can not add account. %s' % (issuer, auth_result.message))
 
         internal_account = InternalAccount(account, vo=vo)
 
@@ -83,7 +84,7 @@ def del_account(
     with db_session(DatabaseOperationType.WRITE) as session:
         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))
+            raise AccessDenied('Account %s can not delete account. %s' % (issuer, auth_result.message))
 
         internal_account = InternalAccount(account, vo=vo)
 
@@ -132,7 +133,7 @@ def update_account(
     with db_session(DatabaseOperationType.WRITE) as session:
         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))
+            raise AccessDenied('Account %s can not change %s  of the account. %s' % (issuer, key, auth_result.message))
 
         internal_account = InternalAccount(account, vo=vo)
 
@@ -242,7 +243,7 @@ def add_account_attribute(
     with db_session(DatabaseOperationType.WRITE) as session:
         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))
+            raise AccessDenied('Account %s can not add attributes. %s' % (issuer, auth_result.message))
 
         internal_account = InternalAccount(account, vo=vo)
 
@@ -268,7 +269,7 @@ def del_account_attribute(
     with db_session(DatabaseOperationType.WRITE) as session:
         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))
+            raise AccessDenied('Account %s can not delete attribute. %s' % (issuer, auth_result.message))
 
         internal_account = InternalAccount(account, vo=vo)
 

rucio/gateway/did.py

@@ -62,7 +62,7 @@ def list_dids(
         if 'account' in or_group:
             or_group['account'] = InternalAccount(or_group['account'], vo=vo)
         if 'scope' in or_group:
-            or_group['account'] = InternalScope(or_group['scope'], vo=vo)
+            or_group['scope'] = InternalScope(or_group['scope'], vo=vo)
 
     with db_session(DatabaseOperationType.READ) as session:
         result = did.list_dids(scope=internal_scope, filters=filters, did_type=did_type, ignore_case=ignore_case,

rucio/gateway/dirac.py

@@ -52,7 +52,7 @@ def add_files(
 
     with db_session(DatabaseOperationType.WRITE) as session:
         filter_ = {'scope': InternalScope(scope='*', vo=vo)}
-        scopes = [scope.external for scope in list_scopes(filter_=filter_, session=session)]
+        scopes = [scope['scope'].external for scope in list_scopes(filter_=filter_, session=session)]
         dids = []
         rses = {}
         for lfn in lfns: