rucio 38.2.0__py3-none-any.whl → 38.4.0__py3-none-any.whl

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/replica.py

@@ -22,7 +22,6 @@ from curses.ascii import isprint
 from datetime import datetime, timedelta
 from hashlib import sha256
 from itertools import groupby
-from json import dumps
 from re import match
 from struct import unpack
 from traceback import format_exc
@@ -2304,9 +2303,9 @@ def __cleanup_after_replica_deletion(
             for scope, name, did_type in session.execute(stmt):
                 if did_type == DIDType.DATASET:
                     messages.append({'event_type': 'ERASE',
-                                     'payload': dumps({'scope': scope.external,
-                                                       'name': name,
-                                                       'account': 'root'})})
+                                     'payload': {'scope': scope.external,
+                                                 'name': name,
+                                                 'account': 'root'}})
                 dids_to_delete.add(ScopeName(scope=scope, name=name))
 
     # Remove Archive Constituents

rucio/core/request.py

@@ -1513,7 +1513,7 @@ class TransferStatsManager:
     def __enter__(self) -> "TransferStatsManager":
         self.record_stats = config_get_bool('transfers', 'stats_enabled', default=self.record_stats)
         downsample_period = config_get_int('transfers', 'stats_downsample_period', default=self.downsample_period)
-        # Introduce some voluntary jitter to reduce the likely-hood of performing this database
+        # Introduce some voluntary jitter to reduce the likelihood of performing this database
         # operation multiple times in parallel.
         self.downsample_period = random.randint(downsample_period * 3 // 4, math.ceil(downsample_period * 5 / 4))  # noqa: S311
         if self.record_stats:

rucio/core/rule.py

@@ -37,7 +37,7 @@ import rucio.core.lock  # import get_replica_locks, get_files_and_replica_locks_
 import rucio.core.replica  # import get_and_lock_file_replicas, get_and_lock_file_replicas_for_dataset
 from rucio.common.cache import MemcacheRegion
 from rucio.common.config import config_get
-from rucio.common.constants import DEFAULT_VO, RseAttr
+from rucio.common.constants import DEFAULT_ACTIVITY, DEFAULT_VO, POLICY_ALGORITHM_TYPES_LITERAL, RseAttr
 from rucio.common.exception import (
     DataIdentifierNotFound,
     DuplicateRule,
@@ -98,7 +98,7 @@ class AutoApprove(PolicyPackageAlgorithms):
     Handle automatic approval algorithms for replication rules
     """
 
-    _algorithm_type = 'auto_approve'
+    _algorithm_type: POLICY_ALGORITHM_TYPES_LITERAL = 'auto_approve'
 
     def __init__(self, rule: models.ReplicationRule, did: models.DataIdentifier, session: 'Session', vo: str = DEFAULT_VO) -> None:
         super().__init__()
@@ -180,7 +180,7 @@ def add_rule(
     locked: bool,
     subscription_id: Optional[str],
     source_replica_expression: Optional[str] = None,
-    activity: str = 'User Subscriptions',
+    activity: Optional[str] = None,
     notify: Optional[Literal['Y', 'N', 'C', 'P']] = None,
     purge_replicas: bool = False,
     ignore_availability: bool = False,
@@ -232,6 +232,9 @@ def add_rule(
     if copies <= 0:
         raise InvalidValueForKey("The number of copies for a replication rule should be greater than 0.")
 
+    if not activity:
+        activity = DEFAULT_ACTIVITY
+
     rule_ids = []
 
     grouping_value = {'ALL': RuleGrouping.ALL, 'NONE': RuleGrouping.NONE}.get(grouping, RuleGrouping.DATASET)

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):
@@ -921,8 +921,8 @@ def __is_retry_required(lock, activity):
     :param activity:             The activity of the rule.
     """
 
-    created_at_diff = (datetime.utcnow() - lock.created_at).days * 24 * 3600 + (datetime.utcnow() - lock.created_at).seconds
-    updated_at_diff = (datetime.utcnow() - lock.updated_at).days * 24 * 3600 + (datetime.utcnow() - lock.updated_at).seconds
+    created_at_diff = (datetime.utcnow() - lock.created_at).total_seconds()
+    updated_at_diff = (datetime.utcnow() - lock.updated_at).total_seconds()
 
     if activity == 'Express':
         if updated_at_diff > 3600 * 2:

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/config.py

@@ -47,23 +47,6 @@ def sections(issuer: str, vo: str = DEFAULT_VO) -> list[str]:
         return config.sections(session=session)
 
 
-def add_section(section: str, issuer: str, vo: str = DEFAULT_VO) -> None:
-    """
-    Add a section to the configuration.
-
-    :param section: The name of the section.
-    :param issuer: The issuer account.
-    :param vo: The VO to act on.
-    """
-
-    kwargs = {'issuer': issuer, 'section': section}
-    with db_session(DatabaseOperationType.WRITE) as session:
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='config_add_section', kwargs=kwargs, session=session)
-        if not auth_result.allowed:
-            raise exception.AccessDenied('%s cannot add section %s. %s' % (issuer, section, auth_result.message))
-        return config.add_section(section, session=session)
-
-
 def has_section(section: str, issuer: str, vo: str = DEFAULT_VO) -> bool:
     """
     Indicates whether the named section is present in the configuration.
@@ -79,25 +62,7 @@ def has_section(section: str, issuer: str, vo: str = DEFAULT_VO) -> bool:
         auth_result = permission.has_permission(issuer=issuer, vo=vo, action='config_has_section', kwargs=kwargs, session=session)
         if not auth_result.allowed:
             raise exception.AccessDenied('%s cannot check existence of section %s. %s' % (issuer, section, auth_result.message))
-        return config.has_section(section, session=session)
-
-
-def options(section: str, issuer: str, vo: str = DEFAULT_VO) -> list[str]:
-    """
-    Returns a list of options available in the specified section.
-
-    :param section: The name of the section.
-    :param issuer: The issuer account.
-    :param vo: The VO to act on.
-    :returns: ['option', ...]
-    """
-
-    kwargs = {'issuer': issuer, 'section': section}
-    with db_session(DatabaseOperationType.READ) as session:
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='config_options', kwargs=kwargs, session=session)
-        if auth_result.allowed:
-            raise exception.AccessDenied('%s cannot retrieve options from section %s. %s' % (issuer, section, auth_result.message))
-        return config.options(section, session=session)
+        return config.has_section(section, session=session, use_cache=False)
 
 
 def has_option(section: str, option: str, issuer: str, vo: str = DEFAULT_VO) -> bool:
@@ -116,7 +81,7 @@ def has_option(section: str, option: str, issuer: str, vo: str = DEFAULT_VO) ->
         auth_result = permission.has_permission(issuer=issuer, vo=vo, action='config_has_option', kwargs=kwargs, session=session)
         if not auth_result.allowed:
             raise exception.AccessDenied('%s cannot check existence of option %s from section %s. %s' % (issuer, option, section, auth_result.message))
-        return config.has_option(section, option, session=session)
+        return config.has_option(section, option, session=session, use_cache=False)
 
 
 def get(section: str, option: str, issuer: str, vo: str = DEFAULT_VO) -> Any:

rucio/gateway/opendata.py

@@ -151,7 +151,7 @@ def update_opendata_did(
         meta: Optional[dict] = None,
         doi: Optional[str] = None,
         vo: str = DEFAULT_VO,
-) -> None:
+) -> dict[str, Any]:
     """
     Update an existing Opendata DID in the Opendata catalog.
 
@@ -164,7 +164,7 @@ def update_opendata_did(
         vo: The virtual organization.
 
     Returns:
-        None
+        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:
         ValueError: If meta is a string and cannot be parsed as valid JSON.

rucio/gateway/request.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from rucio.common import exception
 from rucio.common.constants import DEFAULT_VO, TransferLimitDirection
-from rucio.common.types import InternalAccount, InternalScope, RequestGatewayDict
+from rucio.common.types import InternalScope
 from rucio.common.utils import gateway_update_return_dict
 from rucio.core import request
 from rucio.core.rse import get_rse_id
@@ -31,122 +31,7 @@ from rucio.gateway import permission
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Sequence
 
-    from rucio.db.sqla.constants import RequestState, RequestType
-
-
-def queue_requests(
-    requests: "Iterable[RequestGatewayDict]",
-    issuer: str,
-    vo: str = DEFAULT_VO,
-) -> list[dict[str, Any]]:
-    """
-    Submit transfer or deletion requests on destination RSEs for data identifiers.
-
-    :param requests: List of dictionaries containing 'scope', 'name', 'dest_rse_id', 'request_type', 'attributes'
-    :param issuer: Issuing account as a string.
-    :param vo: The VO to act on.
-    :returns: List of Request-IDs as 32 character hex strings
-    """
-
-    kwargs = {'requests': requests, 'issuer': issuer}
-    with db_session(DatabaseOperationType.WRITE) as session:
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='queue_requests', kwargs=kwargs, session=session)
-        if not auth_result.allowed:
-            raise exception.AccessDenied(f'{issuer} can not queue request. {auth_result.message}')
-
-        for req in requests:
-            req['scope'] = InternalScope(req['scope'], vo=vo)  # type: ignore (type reassignment)
-            if 'account' in req:
-                req['account'] = InternalAccount(req['account'], vo=vo)  # type: ignore (type reassignment)
-
-        new_requests = request.queue_requests(requests, session=session)
-        return [gateway_update_return_dict(r, session=session) for r in new_requests]
-
-
-def cancel_request(
-    request_id: str,
-    issuer: str,
-    account: str,
-    vo: str = DEFAULT_VO,
-) -> None:
-    """
-    Cancel a request.
-
-    :param request_id: Request Identifier as a 32 character hex string.
-    :param issuer: Issuing account as a string.
-    :param account: Account identifier as a string.
-    :param vo: The VO to act on.
-    """
-
-    kwargs = {'account': account, 'issuer': issuer, 'request_id': request_id}
-    with db_session(DatabaseOperationType.WRITE) as session:
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='cancel_request_', kwargs=kwargs, session=session)
-    if not auth_result.allowed:
-        raise exception.AccessDenied('%s cannot cancel request %s. %s' % (account, request_id, auth_result.message))
-
-    raise NotImplementedError
-
-
-def cancel_request_did(
-    scope: str,
-    name: str,
-    dest_rse: str,
-    request_type: str,
-    issuer: str,
-    account: str,
-    vo: str = DEFAULT_VO,
-) -> dict[str, Any]:
-    """
-    Cancel a request based on a DID and request type.
-
-    :param scope: Data identifier scope as a string.
-    :param name: Data identifier name as a string.
-    :param dest_rse: RSE name as a string.
-    :param request_type: Type of the request as a string.
-    :param issuer: Issuing account as a string.
-    :param account: Account identifier as a string.
-    :param vo: The VO to act on.
-    """
-
-    with db_session(DatabaseOperationType.WRITE) as session:
-        dest_rse_id = get_rse_id(rse=dest_rse, vo=vo, session=session)
-
-        kwargs = {'account': account, 'issuer': issuer}
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='cancel_request_did', kwargs=kwargs, session=session)
-        if not auth_result.allowed:
-            raise exception.AccessDenied(f'{account} cannot cancel {request_type} request for {scope}:{name}. {auth_result.message}')
-
-        internal_scope = InternalScope(scope, vo=vo)
-        return request.cancel_request_did(internal_scope, name, dest_rse_id, request_type, session=session)
-
-
-def get_next(
-    request_type: "RequestType",
-    state: "RequestState",
-    issuer: str,
-    account: str,
-    vo: str = DEFAULT_VO,
-) -> list[dict[str, Any]]:
-    """
-    Retrieve the next request matching the request type and state.
-
-    :param request_type: Type of the request as a string.
-    :param state: State of the request as a string.
-    :param issuer: Issuing account as a string.
-    :param account: Account identifier as a string.
-    :param vo: The VO to act on.
-    :returns: Request as a dictionary.
-    """
-
-    kwargs = {'account': account, 'issuer': issuer, 'request_type': request_type, 'state': state}
-
-    with db_session(DatabaseOperationType.WRITE) as session:
-        auth_result = permission.has_permission(issuer=issuer, vo=vo, action='get_next', kwargs=kwargs, session=session)
-        if not auth_result.allowed:
-            raise exception.AccessDenied(f'{account} cannot get the next request of type {request_type} in state {state}. {auth_result.message}')
-
-        reqs = request.get_and_mark_next(request_type, state, session=session)
-        return [gateway_update_return_dict(r, session=session) for r in reqs]
+    from rucio.db.sqla.constants import RequestState
 
 
 def get_request_by_did(