rucio 37.7.1__py3-none-any.whl → 38.0.0__py3-none-any.whl

rucio/core/rule.py

@@ -100,21 +100,22 @@ class AutoApprove(PolicyPackageAlgorithms):
 
     _algorithm_type = 'auto_approve'
 
-    def __init__(self, rule: models.ReplicationRule, did: models.DataIdentifier, session: 'Session') -> None:
+    def __init__(self, rule: models.ReplicationRule, did: models.DataIdentifier, session: 'Session', vo: str = DEFAULT_VO) -> None:
         super().__init__()
         self.rule = rule
         self.did = did
         self.session = session
+        self.vo = vo
         self.register("default", self.default)
 
     def evaluate(self) -> bool:
         """
         Evaluate the auto-approve algorithm
         """
-        return self.get_configured_algorithm()(self.rule, self.did, self.session)
+        return self.get_configured_algorithm(self.vo)(self.rule, self.did, self.session)
 
     @classmethod
-    def get_configured_algorithm(cls: type[AutoApproveT]) -> "Callable[[models.ReplicationRule, models.DataIdentifier, Session], bool]":
+    def get_configured_algorithm(cls: type[AutoApproveT], vo: str) -> "Callable[[models.ReplicationRule, models.DataIdentifier, Session], bool]":
         """
         Get the configured auto-approve algorithm
         """
@@ -123,7 +124,12 @@ class AutoApprove(PolicyPackageAlgorithms):
         except (NoOptionError, NoSectionError, RuntimeError):
             configured_algorithm = 'default'
 
-        return super()._get_one_algorithm(cls._algorithm_type, configured_algorithm)
+        result = None
+        if configured_algorithm == 'default':
+            result = super()._get_default_algorithm(cls._algorithm_type, vo)
+        if result is None:
+            result = super()._get_one_algorithm(cls._algorithm_type, configured_algorithm)
+        return result
 
     @classmethod
     def register(cls: type[AutoApproveT], name: str, fn_auto_approve: "Callable[[models.ReplicationRule, models.DataIdentifier, Session], bool]") -> None:
@@ -390,7 +396,7 @@ def add_rule(
             if ask_approval:
                 new_rule.state = RuleState.WAITING_APPROVAL
                 # Use the new rule as the argument here
-                auto_approver = AutoApprove(new_rule, did, session=session)
+                auto_approver = AutoApprove(new_rule, did, session=session, vo=account.vo)
                 if auto_approver.evaluate():
                     logger(logging.DEBUG, "Auto approving rule %s", str(new_rule.id))
                     logger(logging.DEBUG, "Created rule %s for injection", str(new_rule.id))
@@ -1261,6 +1267,7 @@ def repair_rule(
     #     created.
     # (C) Transfers fail and mark locks (and the rule) as STUCK. All STUCK locks have to be repaired.
     # (D) Files are declared as BAD.
+    # (E) Stuck locks are found on RSEs that do not belong to the target RSEs.
 
     # start_time = time.time()
     try:
@@ -1314,6 +1321,43 @@ def repair_rule(
             logger(logging.DEBUG, '%s while repairing rule %s', str(error), rule_id)
             return
 
+        # Get all stuck locks for this rule ID
+        stmt = select(
+            models.ReplicaLock.rse_id,
+            func.count().label('lock_count')
+        ).where(
+            and_(models.ReplicaLock.rule_id == rule.id,
+                 models.ReplicaLock.state == LockState.STUCK)
+        ).group_by(
+            models.ReplicaLock.rse_id
+        )
+        stuck_locks_by_rse = session.execute(stmt).all()
+
+        stuck_locks_on_nontarget_rses = []
+
+        # Check if any of the locks found are not on our target RSEs
+        target_rse_ids = {rse['id'] for rse in target_rses}
+        for stuck_lock in stuck_locks_by_rse:
+            if stuck_lock.rse_id not in target_rse_ids:
+                rse_name = get_rse_name(rse_id=stuck_lock.rse_id, session=session)
+                stuck_locks_on_nontarget_rses.append({
+                    'rse_id': stuck_lock.rse_id,
+                    'rse_name': rse_name,
+                    'lock_count': stuck_lock.lock_count
+                })
+
+        # Add to rule error if found
+        if stuck_locks_on_nontarget_rses:
+            error_msg = "Found stuck locks on RSEs not matching target expression: "
+            error_msg += ", ".join([f"{rse['rse_name']} ({rse['lock_count']})" for rse in stuck_locks_on_nontarget_rses])
+
+            if rule.error:
+                error_msg = rule.error + '|' + error_msg
+
+            rule.error = (error_msg[:245] + '...') if len(error_msg) > 245 else error_msg
+
+            logger(logging.WARNING, "Rule %s: %s", str(rule.id), error_msg)
+
         # Create the RSESelector
         try:
             rseselector = RSESelector(account=rule.account,
@@ -1324,7 +1368,12 @@ def repair_rule(
                                       session=session)
         except (InvalidRuleWeight, InsufficientTargetRSEs, InsufficientAccountLimit) as error:
             rule.state = RuleState.STUCK
-            rule.error = (str(error)[:245] + '...') if len(str(error)) > 245 else str(error)
+
+            error_msg = str(error)
+            if rule.error:
+                error_msg = rule.error + '|' + error_msg
+            rule.error = (error_msg[:245] + '...') if len(error_msg) > 245 else error_msg
+
             rule.save(session=session)
             # Insert rule history
             insert_rule_history(rule=rule, recent=True, longterm=False, session=session)
@@ -1410,7 +1459,10 @@ def repair_rule(
                                                      session=session)
             except (InsufficientAccountLimit, InsufficientTargetRSEs) as error:
                 rule.state = RuleState.STUCK
-                rule.error = (str(error)[:245] + '...') if len(str(error)) > 245 else str(error)
+                error_msg = str(error)
+                if rule.error:
+                    error_msg = rule.error + '|' + error_msg
+                rule.error = (error_msg[:245] + '...') if len(error_msg) > 245 else error_msg
                 rule.save(session=session)
                 # Insert rule history
                 insert_rule_history(rule=rule, recent=True, longterm=False, session=session)
@@ -1450,7 +1502,10 @@ def repair_rule(
                                                session=session)
         except (InsufficientAccountLimit, InsufficientTargetRSEs) as error:
             rule.state = RuleState.STUCK
-            rule.error = (str(error)[:245] + '...') if len(str(error)) > 245 else str(error)
+            error_msg = str(error)
+            if rule.error:
+                error_msg = rule.error + '|' + error_msg
+            rule.error = (error_msg[:245] + '...') if len(error_msg) > 245 else error_msg
             rule.save(session=session)
             # Insert rule history
             insert_rule_history(rule=rule, recent=True, longterm=False, session=session)

rucio/core/transfer.py

@@ -239,7 +239,7 @@ class DirectTransferImplementation(DirectTransfer):
             # DQ2 path always starts with /, but prefix might not end with /
             naming_convention = dst.rse.attributes.get(RseAttr.NAMING_CONVENTION, None)
             if rws.scope.external is not None:
-                dest_path = construct_non_deterministic_pfn(dsn, rws.scope.external, rws.name, naming_convention)
+                dest_path = construct_non_deterministic_pfn(dsn, rws.scope.external, rws.name, naming_convention, rws.scope.vo)
             if dst.rse.is_tape():
                 if rws.retry_count or rws.activity == 'Recovery':
                     dest_path = '%s_%i' % (dest_path, int(time.time()))

rucio/daemons/common.py

@@ -118,7 +118,7 @@ def _activity_looper(
         sleep_time: int,
         activities: Optional['Sequence[str]'],
         heartbeat_handler: HeartbeatHandler,
-) -> 'Generator[tuple[str, float], tuple[float, bool], None]':
+) -> 'Generator[tuple[Optional[str], float], tuple[float, bool], None]':
     """
     Generator which loops (either once, or indefinitely) over all activities while ensuring that `sleep_time`
     passes between handling twice the same activity.

rucio/daemons/conveyor/finisher.py

@@ -66,7 +66,7 @@ def _fetch_requests(
         set_last_processed_by: bool,
         cached_topology: Optional[ExpiringObjectCache],
         heartbeat_handler: "HeartbeatHandler",
-        activity: str,
+        activity: Optional[str],
 ) -> tuple[bool, tuple[list[dict[str, Any]], Topology]]:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
@@ -184,7 +184,7 @@ def finisher(
     )
     def _db_producer(
         *,
-        activity: str,
+        activity: Optional[str],
         heartbeat_handler: "HeartbeatHandler"
     ) -> tuple[bool, tuple[list[dict[str, Any]], Topology]]:
         return _fetch_requests(

rucio/daemons/conveyor/poller.py

@@ -66,7 +66,7 @@ def _fetch_requests(
         transfertool: Optional[str],
         filter_transfertool: Optional[str],
         cached_topology: Optional[ExpiringObjectCache],
-        activity: str,
+        activity: Optional[str],
         set_last_processed_by: bool,
         heartbeat_handler: "HeartbeatHandler"
 ) -> tuple[bool, list[dict[str, Any]]]:
@@ -196,7 +196,7 @@ def poller(
     )
     def _db_producer(
         *,
-        activity: str,
+        activity: Optional[str],
         heartbeat_handler: "HeartbeatHandler"
     ) -> tuple[bool, list[dict[str, Any]]]:
         return _fetch_requests(

rucio/daemons/conveyor/preparer.py

@@ -100,7 +100,7 @@ def preparer(
         sleep_time=sleep_time)
     def _db_producer(
         *,
-        activity: str,
+        activity: Optional[str],
         heartbeat_handler: "HeartbeatHandler"
     ) -> tuple[bool, tuple[Topology, dict[str, RequestWithSources]]]:
         return _fetch_requests(

rucio/daemons/conveyor/submitter.py

@@ -55,7 +55,7 @@ TRANSFER_TYPE = config_get('conveyor', 'transfertype', False, 'single')
 def _fetch_requests(
         partition_hash_var: Optional[str],
         bulk: int,
-        activity: str,
+        activity: Optional[str],
         rse_ids: Optional[list[str]],
         request_type: list[RequestType],
         ignore_availability: bool,
@@ -285,7 +285,7 @@ def submitter(
         activities=activities)
     def _db_producer(
         *,
-        activity: str,
+        activity: Optional[str],
         heartbeat_handler: "HeartbeatHandler"
     ) -> tuple[bool, tuple[Topology, dict[str, RequestWithSources]]]:
         return _fetch_requests(

rucio/daemons/conveyor/throttler.py

@@ -102,7 +102,7 @@ def throttler(
         sleep_time=sleep_time)
     def _db_producer(
             *,
-            activity: str,
+            activity: Optional[str],
             heartbeat_handler: "HeartbeatHandler"
     ) -> tuple[bool, Optional["ReleaseGroupsDict"]]:
         worker_number, total_workers, logger = heartbeat_handler.live()

rucio/db/sqla/constants.py

@@ -84,6 +84,12 @@ class DIDType(Enum):
     DELETED_CONTAINER = 'Z'
 
 
+class OpenDataDIDState(Enum):
+    PUBLIC = 'P'
+    DRAFT = 'D'
+    SUSPENDED = 'S'
+
+
 class IdentityType(Enum):
     X509 = 'X509'
     GSS = 'GSS'

rucio/db/sqla/migrate_repo/versions/a62db546a1f1_opendata_initial_model.py

@@ -0,0 +1,85 @@
+# 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.
+
+"""Opendata initial model"""  # noqa: D400, D415
+
+import sqlalchemy as sa
+from alembic import op
+
+from rucio.common.schema import get_schema_value
+from rucio.db.sqla.constants import OpenDataDIDState
+from rucio.db.sqla.types import JSON
+
+# Alembic revision identifiers
+revision = 'a62db546a1f1'
+down_revision = '30d5206e9cad'
+
+
+def upgrade():
+    op.create_table(
+        'dids_opendata',
+        sa.Column('scope', sa.String(length=get_schema_value('SCOPE_LENGTH')), nullable=False),
+        sa.Column('name', sa.String(length=get_schema_value('NAME_LENGTH')), nullable=False),
+        sa.Column('state', sa.Enum(OpenDataDIDState, name='DID_OPENDATA_STATE_CHK',
+                                   values_callable=lambda obj: [e.value for e in obj]), nullable=True,
+                  server_default=OpenDataDIDState.DRAFT.value),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.Column('updated_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('scope', 'name', name='OPENDATA_DID_PK'),
+        sa.ForeignKeyConstraint(['scope', 'name'], ['dids.scope', 'dids.name'],
+                                ondelete='CASCADE', name='OPENDATA_DID_FK')
+    )
+    op.create_index('OPENDATA_DID_UPDATED_AT_IDX', 'dids_opendata', ['updated_at'])
+    op.create_index('OPENDATA_DID_CREATED_AT_IDX', 'dids_opendata', ['created_at'])
+    op.create_index('OPENDATA_DID_STATE_IDX', 'dids_opendata', ['state'])
+    op.create_index('OPENDATA_DID_STATE_UPDATED_AT_IDX', 'dids_opendata', ['state', 'updated_at'])
+
+    op.create_table(
+        'dids_opendata_doi',
+        sa.Column('scope', sa.String(length=get_schema_value('SCOPE_LENGTH')), nullable=False),
+        sa.Column('name', sa.String(length=get_schema_value('NAME_LENGTH')), nullable=False),
+        sa.Column('doi', sa.String(length=255), nullable=False, unique=True),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.Column('updated_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('scope', 'name', name='OPENDATA_DOI_PK'),
+        sa.ForeignKeyConstraint(['scope', 'name'], ['dids_opendata.scope', 'dids_opendata.name'],
+                                ondelete='CASCADE', name='OPENDATA_DOI_FK')
+    )
+    op.create_index('OPENDATA_DOI_UPDATED_AT_IDX', 'dids_opendata_doi', ['updated_at'])
+    op.create_index('OPENDATA_DOI_CREATED_AT_IDX', 'dids_opendata_doi', ['created_at'])
+
+    op.create_table(
+        'dids_opendata_meta',
+        sa.Column('scope', sa.String(length=get_schema_value('SCOPE_LENGTH')), nullable=False),
+        sa.Column('name', sa.String(length=get_schema_value('NAME_LENGTH')), nullable=False),
+        sa.Column('meta', JSON(), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.Column('updated_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('scope', 'name', name='OPENDATA_META_PK'),
+        sa.ForeignKeyConstraint(['scope', 'name'], ['dids_opendata.scope', 'dids_opendata.name'],
+                                ondelete='CASCADE', name='OPENDATA_META_FK')
+    )
+
+
+def downgrade():
+    op.drop_table('dids_opendata_meta')
+    op.drop_table('dids_opendata_doi')
+    op.drop_index('OPENDATA_DID_STATE_UPDATED_AT_IDX', table_name='dids_opendata')
+    op.drop_index('OPENDATA_DID_STATE_IDX', table_name='dids_opendata')
+    op.drop_index('OPENDATA_DID_CREATED_AT_IDX', table_name='dids_opendata')
+    op.drop_index('OPENDATA_DID_UPDATED_AT_IDX', table_name='dids_opendata')
+    op.drop_table('dids_opendata')
+
+    # Drop enum if created in this migration
+    sa.Enum(name='DID_OPENDATA_STATE_CHK').drop(op.get_bind(), checkfirst=True)

rucio/db/sqla/models.py

@@ -43,6 +43,7 @@ from rucio.db.sqla.constants import (
     KeyType,
     LifetimeExceptionsState,
     LockState,
+    OpenDataDIDState,
     ReplicaState,
     RequestState,
     RequestType,
@@ -468,6 +469,74 @@ class DataIdentifier(BASE, ModelBase):
                    Index('DIDS_EXPIRED_AT_IDX', 'expired_at'))
 
 
+class OpenDataDid(BASE, ModelBase):
+    """DIDs which are part of OpenData"""
+    __tablename__ = 'dids_opendata'
+
+    scope: Mapped[InternalScope] = mapped_column(InternalScopeString(common_schema.get_schema_value('SCOPE_LENGTH')))
+    name: Mapped[str] = mapped_column(String(common_schema.get_schema_value('NAME_LENGTH')))
+    state: Mapped[Optional[OpenDataDIDState]] = mapped_column(Enum(OpenDataDIDState, name='DID_OPENDATA_STATE_CHK',
+                                                                   create_constraint=True,
+                                                                   values_callable=lambda obj: [e.value for e in obj]),
+                                                              default=OpenDataDIDState.DRAFT)
+
+    __table_args__ = (
+        PrimaryKeyConstraint('scope', 'name', name='OPENDATA_DID_PK'),
+        ForeignKeyConstraint(
+            ['scope', 'name'],
+            ['dids.scope', 'dids.name'],
+            name='OPENDATA_DID_FK',
+            ondelete='CASCADE',
+        ),
+        Index('OPENDATA_DID_UPDATED_AT_IDX', 'updated_at'),
+        Index('OPENDATA_DID_CREATED_AT_IDX', 'created_at'),
+        Index('OPENDATA_DID_STATE_IDX', 'state'),
+        Index('OPENDATA_DID_STATE_UPDATED_AT_IDX', 'state', 'updated_at'),
+    )
+
+
+class OpenDataDOI(BASE, ModelBase):
+    """Mapping between OpenData DIDs and DOIs"""
+    __tablename__ = 'dids_opendata_doi'
+
+    scope: Mapped[InternalScope] = mapped_column(InternalScopeString(common_schema.get_schema_value('SCOPE_LENGTH')))
+    name: Mapped[str] = mapped_column(String(common_schema.get_schema_value('NAME_LENGTH')))
+    doi: Mapped[str] = mapped_column(String(255), unique=True)
+
+    __table_args__ = (
+        PrimaryKeyConstraint('scope', 'name', name='OPENDATA_DOI_PK'),
+        ForeignKeyConstraint(
+            ['scope', 'name'],
+            ['dids_opendata.scope', 'dids_opendata.name'],
+            name='OPENDATA_DOI_FK',
+            ondelete='CASCADE',
+        ),
+        # Not working on all DB, we add the constraint on insert
+        # CheckConstraint("doi ~* '^10\\.[0-9]{4,9}/[-._;()/:A-Z0-9]+$'", name='OPENDATA_DOI_FORMAT_CHK'),
+        Index('OPENDATA_DOI_UPDATED_AT_IDX', 'updated_at'),
+        Index('OPENDATA_DOI_CREATED_AT_IDX', 'created_at'),
+    )
+
+
+class OpenDataMeta(BASE, ModelBase):
+    """Mapping between OpenData DIDs and DOIs"""
+    __tablename__ = 'dids_opendata_meta'
+
+    scope: Mapped[InternalScope] = mapped_column(InternalScopeString(common_schema.get_schema_value('SCOPE_LENGTH')))
+    name: Mapped[str] = mapped_column(String(common_schema.get_schema_value('NAME_LENGTH')))
+    meta = mapped_column(JSON(), nullable=False)
+
+    __table_args__ = (
+        PrimaryKeyConstraint('scope', 'name', name='OPENDATA_META_PK'),
+        ForeignKeyConstraint(
+            ['scope', 'name'],
+            ['dids_opendata.scope', 'dids_opendata.name'],
+            name='OPENDATA_META_FK',
+            ondelete='CASCADE',
+        ),
+    )
+
+
 class VirtualPlacements(BASE, ModelBase):
     """Represents virtual placements"""
     __tablename__ = 'virtual_placements'

rucio/db/sqla/session.py

@@ -38,6 +38,8 @@ from rucio.db.sqla.constants import DatabaseOperationType
 
 EXTRA_MODULES = import_extras(['MySQLdb', 'pymysql'])
 
+LOG = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
     from typing import Optional, ParamSpec, TypeVar
@@ -71,7 +73,6 @@ DEFAULT_SCHEMA_NAME = config_get(DATABASE_SECTION, 'schema',
 _METADATA = MetaData(schema=DEFAULT_SCHEMA_NAME)
 _MAKER, _ENGINE, _LOCK = None, None, Lock()
 
-
 SQLA_CONFIG_POOLCLASS_MAPPING = {
     'queuepool': QueuePool,
     'singletonthreadpool': SingletonThreadPool,
@@ -218,6 +219,12 @@ def get_engine() -> 'Engine':
         if 'mysql' in sql_connection:
             conv = mysql_convert_decimal_to_float(pymysql=sql_connection.startswith('mysql+pymysql'))
             params['connect_args'] = {'conv': conv}
+        elif 'oracle' in sql_connection:
+            try:
+                import oracledb  # pylint: disable=import-error
+                oracledb.init_oracle_client()
+            except Exception as err:
+                LOG.warning('Could not start Oracle thick mode; falling back to thin: %s', err)
         for param, param_type in config_params:
             try:
                 params[param] = param_type(config_get(DATABASE_SECTION, param, check_config_table=False))

rucio/db/sqla/util.py

@@ -81,7 +81,7 @@ def dump_schema() -> None:
     models.register_models(engine)
 
 
-def destroy_database() -> None:
+def drop_orm_tables() -> None:
     """ Removes the schema from the database. Only useful for test cases or malicious intents. """
     engine = get_engine()
 
@@ -91,7 +91,7 @@ def destroy_database() -> None:
         print('Cannot destroy schema -- assuming already gone, continuing:', e)
 
 
-def drop_everything() -> None:
+def purge_db() -> None:
     """
     Pre-gather all named constraints and table names, and drop everything.
     This is better than using metadata.reflect(); metadata.drop_all()

rucio/gateway/dirac.py

@@ -56,7 +56,7 @@ def add_files(
         dids = []
         rses = {}
         for lfn in lfns:
-            scope, name = extract_scope(lfn['lfn'], scopes)
+            scope, name = extract_scope(lfn['lfn'], scopes, vo=vo)
             dids.append({'scope': scope, 'name': name})
             rse = lfn['rse']
             if rse not in rses:

rucio/gateway/opendata.py

@@ -0,0 +1,190 @@
+# 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 json
+from typing import TYPE_CHECKING, Any, Optional
+
+from rucio.common.constants import DEFAULT_VO
+from rucio.common.types import InternalScope
+from rucio.common.utils import gateway_update_return_dict
+from rucio.core import opendata
+from rucio.core.opendata import opendata_state_str_to_enum, validate_opendata_did_state
+from rucio.db.sqla.constants import DatabaseOperationType
+from rucio.db.sqla.session import db_session
+
+if TYPE_CHECKING:
+    from rucio.common.constants import OPENDATA_DID_STATE_LITERAL
+
+
+def list_opendata_dids(
+        *,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        state: Optional["OPENDATA_DID_STATE_LITERAL"] = None,
+) -> dict[str, list[dict[str, Any]]]:
+    """
+    List Opendata DIDs from the Opendata catalog.
+
+    Parameters:
+        limit: Maximum number of DIDs to return.
+        offset: Number of DIDs to skip before starting to collect the result set.
+        state: Filter DIDs by their state.
+
+    Returns:
+        A dictionary with a list of DIDs matching the criteria.
+    """
+
+    state_enum = None
+    if state is not None:
+        state = validate_opendata_did_state(state)
+        state_enum = opendata_state_str_to_enum(state)
+    with db_session(DatabaseOperationType.READ) as session:
+        result = opendata.list_opendata_dids(limit=limit, offset=offset, state=state_enum, session=session)
+    return result
+
+
+def get_opendata_did(
+        *,
+        scope: str,
+        name: str,
+        state: Optional["OPENDATA_DID_STATE_LITERAL"] = None,
+        include_files: bool = True,
+        include_metadata: bool = False,
+        include_doi: bool = True,
+        vo: str = DEFAULT_VO,
+) -> dict[str, Any]:
+    """
+    Retrieve a specific Opendata DID from the Opendata catalog.
+
+    Parameters:
+        scope: The scope of the DID.
+        name: The name of the DID.
+        state: Optional state to filter the DID.
+        include_files: Whether to include files in the result.
+        include_metadata: Whether to include metadata in the result.
+        include_doi: Whether to include DOI information in the result.
+        vo: The virtual organization.
+
+    Returns:
+        A dictionary containing the details of the requested DID.
+    """
+
+    internal_scope = InternalScope(scope, vo=vo)
+    state_enum = None
+    if state is not None:
+        state = validate_opendata_did_state(state)
+        state_enum = opendata_state_str_to_enum(state)
+
+    with db_session(DatabaseOperationType.READ) as session:
+        result = opendata.get_opendata_did(scope=internal_scope,
+                                           name=name,
+                                           state=state_enum,
+                                           include_files=include_files,
+                                           include_metadata=include_metadata,
+                                           include_doi=include_doi,
+                                           session=session)
+        return gateway_update_return_dict(result, session=session)
+
+
+def add_opendata_did(
+        *,
+        scope: str,
+        name: str,
+        vo: str = DEFAULT_VO,
+) -> None:
+    """
+    Add a new Opendata DID to the Opendata catalog.
+
+    Parameters:
+        scope: The scope of the DID.
+        name: The name of the DID.
+        vo: The virtual organization.
+
+    Returns:
+        None
+    """
+
+    internal_scope = InternalScope(scope, vo=vo)
+    with db_session(DatabaseOperationType.WRITE) as session:
+        return opendata.add_opendata_did(scope=internal_scope, name=name, session=session)
+
+
+def delete_opendata_did(
+        *,
+        scope: str,
+        name: str,
+        vo: str = DEFAULT_VO,
+) -> None:
+    """
+    Delete an Opendata DID from the Opendata catalog.
+
+    Parameters:
+        scope: The scope of the DID.
+        name: The name of the DID.
+        vo: The virtual organization.
+
+    Returns:
+        None
+    """
+
+    internal_scope = InternalScope(scope, vo=vo)
+    with db_session(DatabaseOperationType.WRITE) as session:
+        return opendata.delete_opendata_did(scope=internal_scope, name=name, session=session)
+
+
+def update_opendata_did(
+        *,
+        scope: str,
+        name: str,
+        state: Optional["OPENDATA_DID_STATE_LITERAL"] = None,
+        meta: Optional[dict] = None,
+        doi: Optional[str] = None,
+        vo: str = DEFAULT_VO,
+) -> None:
+    """
+    Update an existing Opendata DID in the Opendata catalog.
+
+    Parameters:
+        scope: The scope of the DID.
+        name: The name of the DID.
+        state: Optional new state for the DID.
+        meta: Optional metadata dictionary or JSON string.
+        doi: Optional DOI string.
+        vo: The virtual organization.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If meta is a string and cannot be parsed as valid JSON.
+    """
+
+    internal_scope = InternalScope(scope, vo=vo)
+    state_enum = None
+    if state is not None:
+        state = validate_opendata_did_state(state)
+        state_enum = opendata_state_str_to_enum(state)
+    if isinstance(meta, str):
+        try:
+            meta = json.loads(meta)
+        except ValueError as error:
+            raise ValueError(f"Invalid JSON: {error}")
+
+    with db_session(DatabaseOperationType.WRITE) as session:
+        return opendata.update_opendata_did(scope=internal_scope,
+                                            name=name,
+                                            state=state_enum,
+                                            meta=meta,
+                                            doi=doi,
+                                            session=session)