rucio 37.7.1__py3-none-any.whl → 38.0.0rc1__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/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,72 @@ 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/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)

rucio/gateway/subscription.py

@@ -21,7 +21,7 @@ from rucio.common.exception import AccessDenied, InvalidObject
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount, InternalScope
 from rucio.core import subscription
-from rucio.db.sqla.constants import DatabaseOperationType
+from rucio.db.sqla.constants import DatabaseOperationType, SubscriptionState
 from rucio.db.sqla.session import db_session
 from rucio.gateway.permission import has_permission
 
@@ -110,7 +110,7 @@ def update_subscription(
 
     :param name: Name of the subscription
     :param account: Account identifier
-    :param metadata: Dictionary of metadata to update. Supported keys : filter, replication_rules, comments, lifetime, retroactive, dry_run, priority, last_processed
+    :param metadata: Dictionary of metadata to update. Supported keys : filter, replication_rules, comments, lifetime, retroactive, dry_run, priority, last_processed, state
     :param issuer: The account issuing this operation.
     :param vo: The VO to act on.
     :raises: SubscriptionNotFound if subscription is not found
@@ -132,6 +132,9 @@ def update_subscription(
                 else:
                     for rule in metadata['replication_rules']:
                         validate_schema(name='activity', obj=rule.get('activity', 'default'), vo=vo)
+            if 'state' in metadata and metadata['state'] is not None:
+                metadata['state'] = SubscriptionState(metadata['state'])
+
         except ValueError as error:
             raise TypeError(error)
 
@@ -148,7 +151,6 @@ def update_subscription(
                         filter_[_key] = [_type(val, vo=vo).internal for val in filter_[_key]]
                     else:
                         filter_[_key] = _type(filter_[_key], vo=vo).internal
-
         return subscription.update_subscription(name=name, account=internal_account, metadata=metadata, session=session)
 
 

rucio/rse/protocols/protocol.py

@@ -69,11 +69,15 @@ class RSEProtocol(ABC):
         self.rse = rse_settings
         self.logger = logger
         if self.rse['deterministic']:
-            self.translator = RSEDeterministicTranslation(self.rse['rse'], rse_settings, self.attributes)
-            if getattr(rsemanager, 'CLIENT_MODE', None) and \
-                    not RSEDeterministicTranslation.supports(self.rse.get('lfn2pfn_algorithm')):
-                # Remote server has an algorithm we don't understand; always make the server do the lookup.
-                setattr(self, 'lfns2pfns', self.__lfns2pfns_client)
+            if getattr(rsemanager, 'SERVER_MODE', None):
+                vo = get_rse_vo(self.rse['id'])
+            if getattr(rsemanager, 'CLIENT_MODE', None):
+                # assume client has only one VO policy package configured
+                vo = ''
+                if not RSEDeterministicTranslation.supports(self.rse.get('lfn2pfn_algorithm')):
+                    # Remote server has an algorithm we don't understand; always make the server do the lookup.
+                    setattr(self, 'lfns2pfns', self.__lfns2pfns_client)
+            self.translator = RSEDeterministicTranslation(self.rse['rse'], rse_settings, self.attributes, vo)
         else:
             if getattr(rsemanager, 'CLIENT_MODE', None):
                 setattr(self, 'lfns2pfns', self.__lfns2pfns_client)

rucio/rse/translation.py

@@ -50,7 +50,7 @@ class RSEDeterministicScopeTranslation(PolicyPackageAlgorithms):
                 algorithm_name = "def"
             logger.debug("PFN2LFN: Falling back to %s algorithm.", 'default' if algorithm_name == 'def' else algorithm_name)
 
-        self.parser = self.get_parser(algorithm_name)
+        self.parser = self.get_parser(algorithm_name, vo)
 
     @classmethod
     def _module_init_(cls) -> None:
@@ -60,8 +60,14 @@ class RSEDeterministicScopeTranslation(PolicyPackageAlgorithms):
         cls.register(cls._default, "def")
 
     @classmethod
-    def get_parser(cls, algorithm_name: str) -> 'Callable[..., Any]':
-        return super()._get_one_algorithm(cls._algorithm_type, algorithm_name)
+    def get_parser(cls, algorithm_name: str, vo: str) -> 'Callable[..., Any]':
+        result = None
+        if algorithm_name == vo:
+            # default algorithm for VO
+            result = super()._get_default_algorithm(RSEDeterministicScopeTranslation._algorithm_type, vo)
+        if result is None:
+            result = super()._get_one_algorithm(cls._algorithm_type, algorithm_name)
+        return result
 
     @classmethod
     def register(
@@ -111,7 +117,8 @@ class RSEDeterministicTranslation(PolicyPackageAlgorithms):
             self,
             rse: Optional[str] = None,
             rse_attributes: Optional["RSESettingsDict"] = None,
-            protocol_attributes: Optional[dict[str, Any]] = None
+            protocol_attributes: Optional[dict[str, Any]] = None,
+            vo: str = DEFAULT_VO
     ):
         """
         Initialize a translator object from the RSE, its attributes, and the protocol-specific
@@ -125,6 +132,7 @@ class RSEDeterministicTranslation(PolicyPackageAlgorithms):
         self.rse = rse
         self.rse_attributes = rse_attributes if rse_attributes else {}
         self.protocol_attributes = protocol_attributes if protocol_attributes else {}
+        self.vo = vo
 
     @classmethod
     def supports(
@@ -251,9 +259,12 @@ class RSEDeterministicTranslation(PolicyPackageAlgorithms):
             :returns: RSE specific URI of the physical file
         """
         algorithm = self.rse_attributes.get(RseAttr.LFN2PFN_ALGORITHM, 'default')
-        if algorithm == 'default':
+        algorithm_callable = None
+        if algorithm == 'default' or algorithm == RSEDeterministicTranslation._DEFAULT_LFN2PFN:
             algorithm = RSEDeterministicTranslation._DEFAULT_LFN2PFN
-        algorithm_callable = super()._get_one_algorithm(RSEDeterministicTranslation._algorithm_type, algorithm)
+            algorithm_callable = super()._get_default_algorithm(RSEDeterministicTranslation._algorithm_type, self.vo)
+        if algorithm_callable is None:
+            algorithm_callable = super()._get_one_algorithm(RSEDeterministicTranslation._algorithm_type, algorithm)
         return algorithm_callable(scope, name, self.rse, self.rse_attributes, self.protocol_attributes)
 
 

rucio/transfertool/fts3.py

@@ -1046,6 +1046,7 @@ class FTS3Transfertool(Transfertool):
                 t_file['scitag'] = self.scitags_exp_id << 6 | activity_id
 
         if t_file['metadata']['dst_type'] == 'TAPE':
+            t_file['metadata']['vo'] = rws.scope.vo
             for plugin in self.tape_metadata_plugins:
                 t_file = deep_merge_dict(source=plugin.hints(t_file['metadata']), destination=t_file)