rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/core/lock.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,28 +13,30 @@
 # limitations under the License.
 
 import logging
+from collections.abc import Iterable, Iterator
 from datetime import datetime
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlalchemy.exc import DatabaseError
-from sqlalchemy.sql.expression import and_, or_
+from sqlalchemy.sql.expression import and_, or_, select, true, update
 
 import rucio.core.did
 import rucio.core.rule
+from rucio.common.constants import RseAttr
 from rucio.common.exception import DataIdentifierNotFound
-from rucio.common.types import InternalScope
+from rucio.common.types import InternalScope, LoggerFunction
 from rucio.core.lifetime_exception import define_eol
 from rucio.core.rse import get_rse_attribute, get_rse_name
-from rucio.db.sqla import models, filter_thread_work
-from rucio.db.sqla.constants import LockState, RuleState, RuleGrouping, DIDType, RuleNotification
-from rucio.db.sqla.session import read_session, transactional_session, stream_session
+from rucio.db.sqla import filter_thread_work, models
+from rucio.db.sqla.constants import DIDType, LockState, RuleGrouping, RuleNotification, RuleState
+from rucio.db.sqla.session import read_session, stream_session, transactional_session
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
 
 @stream_session
-def get_dataset_locks(scope, name, *, session: "Session"):
+def get_dataset_locks(scope: InternalScope, name: str, *, session: "Session") -> Iterator[dict[str, Any]]:
     """
     Get the dataset locks of a dataset
 
@@ -45,17 +46,22 @@ def get_dataset_locks(scope, name, *, session: "Session"):
     :return:               List of dicts {'rse_id': ..., 'state': ...}
     """
 
-    query = session.query(models.DatasetLock.rse_id,
-                          models.DatasetLock.scope,
-                          models.DatasetLock.name,
-                          models.DatasetLock.rule_id,
-                          models.DatasetLock.account,
-                          models.DatasetLock.state,
-                          models.DatasetLock.length,
-                          models.DatasetLock.bytes,
-                          models.DatasetLock.accessed_at).filter_by(scope=scope, name=name)
-
-    for rse_id, scope, name, rule_id, account, state, length, bytes_, accessed_at in query.yield_per(500):
+    stmt = select(
+        models.DatasetLock.rse_id,
+        models.DatasetLock.scope,
+        models.DatasetLock.name,
+        models.DatasetLock.rule_id,
+        models.DatasetLock.account,
+        models.DatasetLock.state,
+        models.DatasetLock.length,
+        models.DatasetLock.bytes,
+        models.DatasetLock.accessed_at
+    ).where(
+        and_(models.DatasetLock.scope == scope,
+             models.DatasetLock.name == name)
+    )
+
+    for rse_id, scope, name, rule_id, account, state, length, bytes_, accessed_at in session.execute(stmt).yield_per(500):
         yield {'rse_id': rse_id,
                'rse': get_rse_name(rse_id, session=session),
                'scope': scope,
@@ -69,7 +75,7 @@ def get_dataset_locks(scope, name, *, session: "Session"):
 
 
 @stream_session
-def get_dataset_locks_bulk(dids, *, session: "Session"):
+def get_dataset_locks_bulk(dids: Iterable[dict[str, Any]], *, session: "Session") -> Iterator[dict[str, Any]]:
     """
     Get the dataset locks of a list of datasets or containers, recursively
 
@@ -81,7 +87,8 @@ def get_dataset_locks_bulk(dids, *, session: "Session"):
 
     for did in dids:
         scope = did["scope"]
-        assert isinstance(scope, InternalScope)
+        if not isinstance(scope, InternalScope):
+            raise ValueError("Scope must be passed as an InternalScope object.")
         name = did["name"]
         did_type = did.get("type")
         if not did_type:
@@ -90,19 +97,21 @@ def get_dataset_locks_bulk(dids, *, session: "Session"):
             except DataIdentifierNotFound:
                 continue
             did_type = did_info["type"]
-        assert did_type in (DIDType.DATASET, DIDType.CONTAINER)
+
         if did_type == DIDType.DATASET:
             for lock_dict in get_dataset_locks(scope, name, session=session):
                 yield lock_dict
-        else:
+        elif did_type == DIDType.CONTAINER:
             for dataset_info in rucio.core.did.list_child_datasets(scope, name, session=session):
                 dataset_scope, dataset_name = dataset_info["scope"], dataset_info["name"]
                 for lock_dict in get_dataset_locks(dataset_scope, dataset_name, session=session):
                     yield lock_dict
+        else:
+            raise ValueError("Can only get locks for datasets and containers.")
 
 
 @stream_session
-def get_dataset_locks_by_rse_id(rse_id, *, session: "Session"):
+def get_dataset_locks_by_rse_id(rse_id: str, *, session: "Session") -> Iterator[dict[str, Any]]:
     """
     Get the dataset locks of an RSE.
 
@@ -110,18 +119,25 @@ def get_dataset_locks_by_rse_id(rse_id, *, session: "Session"):
     :param session:        The db session.
     :return:               List of dicts {'rse_id': ..., 'state': ...}
     """
-    query = session.query(models.DatasetLock.rse_id,
-                          models.DatasetLock.scope,
-                          models.DatasetLock.name,
-                          models.DatasetLock.rule_id,
-                          models.DatasetLock.account,
-                          models.DatasetLock.state,
-                          models.DatasetLock.length,
-                          models.DatasetLock.bytes,
-                          models.DatasetLock.accessed_at).filter_by(rse_id=rse_id).\
-        with_hint(models.DatasetLock, "index(DATASET_LOCKS DATASET_LOCKS_RSE_ID_IDX)", 'oracle')
-
-    for rse_id, scope, name, rule_id, account, state, length, bytes_, accessed_at in query.yield_per(500):
+    stmt = select(
+        models.DatasetLock.rse_id,
+        models.DatasetLock.scope,
+        models.DatasetLock.name,
+        models.DatasetLock.rule_id,
+        models.DatasetLock.account,
+        models.DatasetLock.state,
+        models.DatasetLock.length,
+        models.DatasetLock.bytes,
+        models.DatasetLock.accessed_at
+    ).with_hint(
+        models.DatasetLock,
+        'INDEX(DATASET_LOCKS DATASET_LOCKS_RSE_ID_IDX)',
+        'oracle'
+    ).where(
+        models.DatasetLock.rse_id == rse_id
+    )
+
+    for rse_id, scope, name, rule_id, account, state, length, bytes_, accessed_at in session.execute(stmt).yield_per(500):
         yield {'rse_id': rse_id,
                'rse': get_rse_name(rse_id, session=session),
                'scope': scope,
@@ -135,7 +151,7 @@ def get_dataset_locks_by_rse_id(rse_id, *, session: "Session"):
 
 
 @read_session
-def get_replica_locks(scope, name, nowait=False, restrict_rses=None, *, session: "Session"):
+def get_replica_locks(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional[Iterable[str]] = None, *, session: "Session") -> list[models.ReplicaLock]:
     """
     Get the active replica locks for a file
 
@@ -148,19 +164,29 @@ def get_replica_locks(scope, name, nowait=False, restrict_rses=None, *, session:
     :raises:               NoResultFound
     """
 
-    query = session.query(models.ReplicaLock).filter_by(scope=scope, name=name)
+    stmt = select(
+        models.ReplicaLock
+    ).where(
+        and_(models.ReplicaLock.scope == scope,
+             models.ReplicaLock.name == name)
+    )
     if restrict_rses is not None:
         rse_clause = []
         for rse_id in restrict_rses:
             rse_clause.append(models.ReplicaLock.rse_id == rse_id)
         if rse_clause:
-            query = query.filter(or_(*rse_clause))
+            stmt = stmt.where(
+                or_(*rse_clause)
+            )
 
-    return query.with_for_update(nowait=nowait).all()
+    stmt = stmt.with_for_update(
+        nowait=nowait
+    )
+    return list(session.execute(stmt).scalars().all())
 
 
 @read_session
-def get_replica_locks_for_rule_id(rule_id, *, session: "Session"):
+def get_replica_locks_for_rule_id(rule_id: str, *, session: "Session") -> list[dict[str, Any]]:
     """
     Get the active replica locks for a rule_id.
 
@@ -172,9 +198,13 @@ def get_replica_locks_for_rule_id(rule_id, *, session: "Session"):
 
     locks = []
 
-    query = session.query(models.ReplicaLock).filter_by(rule_id=rule_id)
+    stmt = select(
+        models.ReplicaLock
+    ).where(
+        models.ReplicaLock.rule_id == rule_id
+    )
 
-    for row in query:
+    for row in session.execute(stmt).scalars().all():
         locks.append({'scope': row.scope,
                       'name': row.name,
                       'rse_id': row.rse_id,
@@ -186,7 +216,7 @@ def get_replica_locks_for_rule_id(rule_id, *, session: "Session"):
 
 
 @read_session
-def get_replica_locks_for_rule_id_per_rse(rule_id, *, session: "Session"):
+def get_replica_locks_for_rule_id_per_rse(rule_id: str, *, session: "Session") -> list[dict[str, str]]:
     """
     Get the active replica locks for a rule_id per rse.
 
@@ -198,24 +228,30 @@ def get_replica_locks_for_rule_id_per_rse(rule_id, *, session: "Session"):
 
     locks = []
 
-    query = session.query(models.ReplicaLock.rse_id).filter_by(rule_id=rule_id).group_by(models.ReplicaLock.rse_id)
+    stmt = select(
+        models.ReplicaLock.rse_id
+    ).where(
+        models.ReplicaLock.rule_id == rule_id
+    ).group_by(
+        models.ReplicaLock.rse_id
+    )
 
-    for row in query:
-        locks.append({'rse_id': row.rse_id,
-                      'rse': get_rse_name(rse_id=row.rse_id, session=session)})
+    for rse_id in session.execute(stmt).scalars().all():
+        locks.append({'rse_id': rse_id,
+                      'rse': get_rse_name(rse_id=rse_id, session=session)})
 
     return locks
 
 
 @read_session
-def get_files_and_replica_locks_of_dataset(scope, name, nowait=False, restrict_rses=None, only_stuck=False,
-                                           total_threads=None, thread_id=None,
-                                           *, session: "Session"):
+def get_files_and_replica_locks_of_dataset(scope: InternalScope, name: str, nowait: bool = False, restrict_rses: Optional[Iterable[str]] = None, only_stuck: bool = False,
+                                           total_threads: Optional[int] = None, thread_id: Optional[int] = None,
+                                           *, session: "Session") -> dict[tuple[InternalScope, str], Union[models.ReplicaLock, list[models.ReplicaLock]]]:
     """
     Get all the files of a dataset and, if existing, all locks of the file.
 
     :param scope:          Scope of the dataset
-    :param name:           Name of the datset
+    :param name:           Name of the dataset
     :param nowait:         Nowait parameter for the FOR UPDATE statement
     :param restrict_rses:  Possible RSE_ids to filter on.
     :param only_stuck:     If true, only get STUCK locks.
@@ -227,83 +263,60 @@ def get_files_and_replica_locks_of_dataset(scope, name, nowait=False, restrict_r
     :raises:               NoResultFound
     """
     locks = {}
-    if session.bind.dialect.name == 'postgresql':
-        content_query = session.query(models.DataIdentifierAssociation.child_scope,
-                                      models.DataIdentifierAssociation.child_name).\
-            with_hint(models.DataIdentifierAssociation,
-                      "INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)",
-                      'oracle').\
-            filter(models.DataIdentifierAssociation.scope == scope,
-                   models.DataIdentifierAssociation.name == name)
 
+    rse_clause = [true()]
+    if restrict_rses is not None:
+        rse_clause = [models.ReplicaLock.rse_id == rse_id for rse_id in restrict_rses]
+
+    base_stmt = select(
+        models.DataIdentifierAssociation.child_scope,
+        models.DataIdentifierAssociation.child_name
+    ).where(
+        and_(models.DataIdentifierAssociation.scope == scope,
+             models.DataIdentifierAssociation.name == name)
+    )
+    stmt = base_stmt.add_columns(
+        models.ReplicaLock
+    ).with_for_update(
+        nowait=nowait,
+        of=models.ReplicaLock.state
+    )
+
+    if session.bind.dialect.name == 'postgresql':
         if total_threads and total_threads > 1:
-            content_query = filter_thread_work(session=session, query=content_query, total_threads=total_threads,
-                                               thread_id=thread_id, hash_variable='child_name')
+            base_stmt = filter_thread_work(session=session, query=base_stmt, total_threads=total_threads,
+                                           thread_id=thread_id, hash_variable='child_name')
 
-        for child_scope, child_name in content_query.yield_per(1000):
+        for child_scope, child_name in session.execute(base_stmt).yield_per(1000):
             locks[(child_scope, child_name)] = []
 
-        query = session.query(models.DataIdentifierAssociation.child_scope,
-                              models.DataIdentifierAssociation.child_name,
-                              models.ReplicaLock).\
-            with_hint(models.DataIdentifierAssociation,
-                      "INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)",
-                      'oracle').\
-            filter(and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
-                        models.DataIdentifierAssociation.child_name == models.ReplicaLock.name))\
-            .filter(models.DataIdentifierAssociation.scope == scope,
-                    models.DataIdentifierAssociation.name == name)
-
-        if restrict_rses is not None:
-            rse_clause = []
-            for rse_id in restrict_rses:
-                rse_clause.append(models.ReplicaLock.rse_id == rse_id)
-            if rse_clause:
-                query = session.query(models.DataIdentifierAssociation.child_scope,
-                                      models.DataIdentifierAssociation.child_name,
-                                      models.ReplicaLock).\
-                    with_hint(models.DataIdentifierAssociation, "INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)", 'oracle').\
-                    filter(and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
-                                models.DataIdentifierAssociation.child_name == models.ReplicaLock.name,
-                                or_(*rse_clause)))\
-                    .filter(models.DataIdentifierAssociation.scope == scope,
-                            models.DataIdentifierAssociation.name == name)
+        stmt = stmt.where(
+            and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
+                 models.DataIdentifierAssociation.child_name == models.ReplicaLock.name,
+                 or_(*rse_clause))
+        )
     else:
-        query = session.query(models.DataIdentifierAssociation.child_scope,
-                              models.DataIdentifierAssociation.child_name,
-                              models.ReplicaLock).\
-            with_hint(models.DataIdentifierAssociation, "INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)", 'oracle').\
-            outerjoin(models.ReplicaLock,
-                      and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
-                           models.DataIdentifierAssociation.child_name == models.ReplicaLock.name))\
-            .filter(models.DataIdentifierAssociation.scope == scope, models.DataIdentifierAssociation.name == name)
-
-        if restrict_rses is not None:
-            rse_clause = []
-            for rse_id in restrict_rses:
-                rse_clause.append(models.ReplicaLock.rse_id == rse_id)
-            if rse_clause:
-                query = session.query(models.DataIdentifierAssociation.child_scope,
-                                      models.DataIdentifierAssociation.child_name,
-                                      models.ReplicaLock).\
-                    with_hint(models.DataIdentifierAssociation, "INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)", 'oracle').\
-                    outerjoin(models.ReplicaLock,
-                              and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
-                                   models.DataIdentifierAssociation.child_name == models.ReplicaLock.name,
-                                   or_(*rse_clause)))\
-                    .filter(models.DataIdentifierAssociation.scope == scope,
-                            models.DataIdentifierAssociation.name == name)
+        stmt = stmt.with_hint(
+            models.DataIdentifierAssociation,
+            'INDEX_RS_ASC(CONTENTS CONTENTS_PK) NO_INDEX_FFS(CONTENTS CONTENTS_PK)',
+            'oracle'
+        ).outerjoin(
+            models.ReplicaLock,
+            and_(models.DataIdentifierAssociation.child_scope == models.ReplicaLock.scope,
+                 models.DataIdentifierAssociation.child_name == models.ReplicaLock.name,
+                 or_(*rse_clause))
+        )
 
     if only_stuck:
-        query = query.filter(models.ReplicaLock.state == LockState.STUCK)
+        stmt = stmt.where(
+            models.ReplicaLock.state == LockState.STUCK
+        )
 
     if total_threads and total_threads > 1:
-        query = filter_thread_work(session=session, query=query, total_threads=total_threads,
-                                   thread_id=thread_id, hash_variable='child_name')
-
-    query = query.with_for_update(nowait=nowait, of=models.ReplicaLock.state)
+        stmt = filter_thread_work(session=session, query=stmt, total_threads=total_threads,
+                                  thread_id=thread_id, hash_variable='child_name')
 
-    for child_scope, child_name, lock in query:
+    for child_scope, child_name, lock in session.execute(stmt).all():
         if (child_scope, child_name) not in locks:
             if lock is None:
                 locks[(child_scope, child_name)] = []
@@ -316,7 +329,7 @@ def get_files_and_replica_locks_of_dataset(scope, name, nowait=False, restrict_r
 
 
 @transactional_session
-def successful_transfer(scope, name, rse_id, nowait, *, session: "Session", logger=logging.log):
+def successful_transfer(scope: InternalScope, name: str, rse_id: str, nowait: bool, *, session: "Session", logger: LoggerFunction = logging.log) -> None:
     """
     Update the state of all replica locks because of an successful transfer
 
@@ -327,13 +340,28 @@ def successful_transfer(scope, name, rse_id, nowait, *, session: "Session", logg
     :param session:  DB Session.
     """
 
-    locks = session.query(models.ReplicaLock).with_for_update(nowait=nowait).filter_by(scope=scope, name=name, rse_id=rse_id)
-    for lock in locks:
+    stmt = select(
+        models.ReplicaLock
+    ).where(
+        and_(models.ReplicaLock.scope == scope,
+             models.ReplicaLock.name == name,
+             models.ReplicaLock.rse_id == rse_id)
+    ).with_for_update(
+        nowait=nowait
+    )
+    for lock in session.execute(stmt).scalars().all():
         if lock.state == LockState.OK:
             continue
         logger(logging.DEBUG, 'Marking lock %s:%s for rule %s on rse %s as OK' % (lock.scope, lock.name, str(lock.rule_id), get_rse_name(rse_id=lock.rse_id, session=session)))
         # Update the rule counters
-        rule = session.query(models.ReplicationRule).with_for_update(nowait=nowait).filter_by(id=lock.rule_id).one()
+        stmt = select(
+            models.ReplicationRule
+        ).where(
+            models.ReplicationRule.id == lock.rule_id
+        ).with_for_update(
+            nowait=nowait
+        )
+        rule = session.execute(stmt).scalar_one()
         logger(logging.DEBUG, 'Updating rule counters for rule %s [%d/%d/%d]' % (str(rule.id), rule.locks_ok_cnt, rule.locks_replicating_cnt, rule.locks_stuck_cnt))
 
         if lock.state == LockState.REPLICATING:
@@ -367,8 +395,14 @@ def successful_transfer(scope, name, rse_id, nowait, *, session: "Session", logg
             rule.state = RuleState.OK
             # Try to update the DatasetLocks
             if rule.grouping != RuleGrouping.NONE:
-                ds_locks = session.query(models.DatasetLock).with_for_update(nowait=nowait).filter_by(rule_id=rule.id)
-                for ds_lock in ds_locks:
+                stmt = select(
+                    models.DatasetLock
+                ).where(
+                    models.DatasetLock.rule_id == rule.id
+                ).with_for_update(
+                    nowait=nowait
+                )
+                for ds_lock in session.execute(stmt).scalars().all():
                     ds_lock.state = LockState.OK
                 session.flush()
             rucio.core.rule.generate_rule_notifications(rule=rule, replicating_locks_before=rule.locks_replicating_cnt + 1, session=session)
@@ -385,7 +419,8 @@ def successful_transfer(scope, name, rse_id, nowait, *, session: "Session", logg
 
 
 @transactional_session
-def failed_transfer(scope, name, rse_id, error_message=None, broken_rule_id=None, broken_message=None, nowait=True, *, session: "Session", logger=logging.log):
+def failed_transfer(scope: InternalScope, name: str, rse_id: str, error_message: Optional[str] = None, broken_rule_id: Optional[str] = None,
+                    broken_message: Optional[str] = None, nowait: bool = True, *, session: "Session", logger: LoggerFunction = logging.log) -> None:
     """
     Update the state of all replica locks because of a failed transfer.
     If a transfer is permanently broken for a rule, the broken_rule_id should be filled which puts this rule into the SUSPENDED state.
@@ -400,20 +435,44 @@ def failed_transfer(scope, name, rse_id, error_message=None, broken_rule_id=None
     :param session:         The database session in use.
     """
 
-    staging_required = get_rse_attribute(rse_id, 'staging_required', session=session)
+    staging_required = get_rse_attribute(rse_id, RseAttr.STAGING_REQUIRED, session=session)
     if staging_required:
         rse_name = get_rse_name(rse_id=rse_id, session=session)
         logger(logging.DEBUG, f'Destination RSE {rse_name} is type staging_required so do not update other OK replica locks.')
-        locks = session.query(models.ReplicaLock).with_for_update(nowait=nowait).filter_by(scope=scope, name=name, rse_id=rse_id, state=LockState.REPLICATING)
+        stmt = select(
+            models.ReplicaLock
+        ).where(
+            and_(models.ReplicaLock.scope == scope,
+                 models.ReplicaLock.name == name,
+                 models.ReplicaLock.rse_id == rse_id,
+                 models.ReplicaLock.state == LockState.REPLICATING)
+        ).with_for_update(
+            nowait=nowait
+        )
     else:
-        locks = session.query(models.ReplicaLock).with_for_update(nowait=nowait).filter_by(scope=scope, name=name, rse_id=rse_id)
-
-    for lock in locks:
+        stmt = select(
+            models.ReplicaLock
+        ).where(
+            and_(models.ReplicaLock.scope == scope,
+                 models.ReplicaLock.name == name,
+                 models.ReplicaLock.rse_id == rse_id)
+        ).with_for_update(
+            nowait=nowait
+        )
+
+    for lock in session.execute(stmt).scalars().all():
         if lock.state == LockState.STUCK:
             continue
         logger(logging.DEBUG, 'Marking lock %s:%s for rule %s on rse %s as STUCK' % (lock.scope, lock.name, str(lock.rule_id), get_rse_name(rse_id=lock.rse_id, session=session)))
         # Update the rule counters
-        rule = session.query(models.ReplicationRule).with_for_update(nowait=nowait).filter_by(id=lock.rule_id).one()
+        stmt = select(
+            models.ReplicationRule
+        ).where(
+            models.ReplicationRule.id == lock.rule_id
+        ).with_for_update(
+            nowait=nowait
+        )
+        rule = session.execute(stmt).scalar_one()
         logger(logging.DEBUG, 'Updating rule counters for rule %s [%d/%d/%d]' % (str(rule.id), rule.locks_ok_cnt, rule.locks_replicating_cnt, rule.locks_stuck_cnt))
         if lock.state == LockState.REPLICATING:
             rule.locks_replicating_cnt -= 1
@@ -428,29 +487,47 @@ def failed_transfer(scope, name, rse_id, error_message=None, broken_rule_id=None
             pass
         elif lock.rule_id == broken_rule_id:
             rule.state = RuleState.SUSPENDED
-            rule.error = (broken_message[:245] + '...') if len(broken_message) > 245 else broken_message
+            if broken_message is not None and len(broken_message) > 245:
+                rule.error = (broken_message[:245] + '...')
+            else:
+                rule.error = broken_message
             # Try to update the DatasetLocks
             if rule.grouping != RuleGrouping.NONE:
-                ds_locks = session.query(models.DatasetLock).with_for_update(nowait=nowait).filter_by(rule_id=rule.id)
-                for ds_lock in ds_locks:
+                stmt = select(
+                    models.DatasetLock
+                ).where(
+                    models.DatasetLock.rule_id == rule.id
+                ).with_for_update(
+                    nowait=nowait
+                )
+                for ds_lock in session.execute(stmt).scalars().all():
                     ds_lock.state = LockState.STUCK
         elif rule.locks_stuck_cnt > 0:
             if rule.state != RuleState.STUCK:
                 rule.state = RuleState.STUCK
                 # Try to update the DatasetLocks
                 if rule.grouping != RuleGrouping.NONE:
-                    ds_locks = session.query(models.DatasetLock).with_for_update(nowait=nowait).filter_by(rule_id=rule.id)
-                    for ds_lock in ds_locks:
+                    stmt = select(
+                        models.DatasetLock
+                    ).where(
+                        models.DatasetLock.rule_id == rule.id
+                    ).with_for_update(
+                        nowait=nowait
+                    )
+                    for ds_lock in session.execute(stmt).scalars().all():
                         ds_lock.state = LockState.STUCK
             if rule.error != error_message:
-                rule.error = (error_message[:245] + '...') if len(error_message) > 245 else error_message
+                if error_message is not None and len(error_message) > 245:
+                    rule.error = (error_message[:245] + '...')
+                else:
+                    rule.error = error_message
 
         # Insert rule history
         rucio.core.rule.insert_rule_history(rule=rule, recent=True, longterm=False, session=session)
 
 
 @transactional_session
-def touch_dataset_locks(dataset_locks, *, session: "Session"):
+def touch_dataset_locks(dataset_locks: Iterable[dict[str, Any]], *, session: "Session") -> bool:
     """
     Update the accessed_at timestamp of the given dataset locks + eol_at.
 
@@ -464,10 +541,35 @@ def touch_dataset_locks(dataset_locks, *, session: "Session"):
     for dataset_lock in dataset_locks:
         eol_at = define_eol(dataset_lock['scope'], dataset_lock['name'], rses=[{'id': dataset_lock['rse_id']}], session=session)
         try:
-            session.query(models.DatasetLock).filter_by(scope=dataset_lock['scope'], name=dataset_lock['name'], rse_id=dataset_lock['rse_id']).\
-                update({'accessed_at': dataset_lock.get('accessed_at') or now}, synchronize_session=False)
-            for res in session.query(models.DatasetLock.rule_id).filter_by(scope=dataset_lock['scope'], name=dataset_lock['name'], rse_id=dataset_lock['rse_id']):
-                session.query(models.ReplicationRule).filter_by(id=res[0]).update({'eol_at': eol_at}, synchronize_session=False)
+            stmt = update(
+                models.DatasetLock
+            ).where(
+                and_(models.DatasetLock.scope == dataset_lock['scope'],
+                     models.DatasetLock.name == dataset_lock['name'],
+                     models.DatasetLock.rse_id == dataset_lock['rse_id'])
+            ).values({
+                models.DatasetLock.accessed_at: dataset_lock.get('accessed_at') or now
+            }).execution_options(
+                synchronize_session=False
+            )
+            subq = select(
+                models.DatasetLock.rule_id
+            ).where(
+                and_(models.DatasetLock.scope == dataset_lock['scope'],
+                     models.DatasetLock.name == dataset_lock['name'],
+                     models.DatasetLock.rse_id == dataset_lock['rse_id'])
+            )
+
+            stmt = update(
+                models.ReplicationRule
+            ).where(
+                models.ReplicationRule.id.in_(subq)
+            ).values({
+                models.ReplicationRule.eol_at: eol_at
+            }).execution_options(
+                synchronize_session=False
+            )
+            session.execute(stmt)
         except DatabaseError:
             return False