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

rucio/core/did_meta_plugins/did_column_meta.py

@@ -14,7 +14,7 @@
 
 import operator
 from datetime import datetime, timedelta
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from sqlalchemy import inspect, update
 from sqlalchemy.exc import CompileError, InvalidRequestError, NoResultFound
@@ -30,46 +30,95 @@ from rucio.db.sqla.constants import DIDType
 from rucio.db.sqla.session import read_session, stream_session, transactional_session
 
 if TYPE_CHECKING:
-    from typing import Optional
+    from collections.abc import Iterator
+    from typing import Literal, Optional, Union
 
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalScope
+
 
 class DidColumnMeta(DidMetaPlugin):
     """
     A metadata plugin to interact with the base DID table metadata.
     """
-    def __init__(self):
+
+    def __init__(self) -> None:
+        """Initialize the DID column metadata plugin."""
         super(DidColumnMeta, self).__init__()
         self.plugin_name = "DID_COLUMN"
 
     @read_session
-    def get_metadata(self, scope, name, *, session: "Session"):
+    def get_metadata(
+            self,
+            scope: "InternalScope",
+            name: str,
+            *,
+            session: "Session",
+    ) -> dict[str, Any]:
         """
-        Get data identifier metadata.
+        Get all the metadata of some data identifier.
 
-        :param scope: The scope name.
-        :param name: The data identifier name.
+        :param scope: The scope of the DID.
+        :param name: The name of the DID.
         :param session: The database session in use.
+        :returns: DID metadata as a dictionary.
         """
         try:
-            row = session.query(models.DataIdentifier).filter_by(scope=scope, name=name).\
+            row = session.query(models.DataIdentifier).filter_by(scope=scope, name=name). \
                 with_hint(models.DataIdentifier, "INDEX(DIDS DIDS_PK)", 'oracle').one()
             return row.to_dict()
         except NoResultFound:
             raise exception.DataIdentifierNotFound(f"Data identifier '{scope}:{name}' not found")
 
     @transactional_session
-    def set_metadata(self, scope, name, key, value, recursive=False, *, session: "Session"):
+    def set_metadata(
+            self,
+            scope: "InternalScope",
+            name: str,
+            key: str,
+            value: Any,
+            recursive: bool = False,
+            *,
+            session: "Session",
+    ) -> None:
+        """
+        Add a single key-value metadata pair to a data identifier.
+
+        :param scope: The scope of the DID.
+        :param name: The name of the DID.
+        :param key: The metadata key.
+        :param value: The metadata value.
+        :param recursive: Option to propagate the metadata updates to child content.
+        :param session: The database session in use.
+        """
         self.set_metadata_bulk(scope=scope, name=name, metadata={key: value}, recursive=recursive, session=session)
 
     @transactional_session
-    def set_metadata_bulk(self, scope, name, metadata, recursive=False, *, session: "Session"):
-        did_query = session.query(models.DataIdentifier).with_hint(models.DataIdentifier, "INDEX(DIDS DIDS_PK)", 'oracle').filter_by(scope=scope, name=name)
+    def set_metadata_bulk(
+            self,
+            scope: "InternalScope",
+            name: str,
+            metadata: dict[str, Any],
+            recursive: bool = False,
+            *,
+            session: "Session",
+    ) -> None:
+        """
+        Add multiple key-value metadata pairs to a data identifier.
+
+        :param scope: The scope of the DID.
+        :param name: The name of the DID.
+        :param metadata: All key-value metadata pairs to set.
+        :param recursive: Option to propagate the metadata updates to child content.
+        :param session: The database session in use.
+        """
+        did_query = session.query(models.DataIdentifier).with_hint(models.DataIdentifier, "INDEX(DIDS DIDS_PK)",
+                                                                   'oracle').filter_by(scope=scope, name=name)
         if did_query.one_or_none() is None:
             raise exception.DataIdentifierNotFound("Data identifier '%s:%s' not found" % (scope, name))
 
-        remainder = {}
+        remainder: dict[Any, Any] = {}
         for key, value in metadata.items():
             if key == 'eol_at' and isinstance(value, str):
                 try:
@@ -92,51 +141,106 @@ class DidColumnMeta(DidMetaPlugin):
                     # check for DID presence
                     raise exception.UnsupportedOperation('%s for %s:%s cannot be updated' % (key, scope, name))
             elif key in ['guid', 'events']:
-                rowcount = did_query.filter_by(did_type=DIDType.FILE).update({key: value}, synchronize_session=False)
+                rowcount = did_query \
+                    .filter_by(did_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
                 if not rowcount:
                     # check for DID presence
                     raise exception.UnsupportedOperation('%s for %s:%s cannot be updated' % (key, scope, name))
 
-                session.query(models.DataIdentifierAssociation).filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE).update({key: value}, synchronize_session=False)
+                session.query(models.DataIdentifierAssociation) \
+                    .filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
                 if key == 'events':
-                    for parent_scope, parent_name in session.query(models.DataIdentifierAssociation.scope, models.DataIdentifierAssociation.name).filter_by(child_scope=scope, child_name=name):
-                        events = session.query(func.sum(models.DataIdentifierAssociation.events)).filter_by(scope=parent_scope, name=parent_name).one()[0]
-                        session.query(models.DataIdentifier).filter_by(scope=parent_scope, name=parent_name).update({'events': events}, synchronize_session=False)
+                    for parent_scope, parent_name \
+                            in session.query(models.DataIdentifierAssociation.scope,
+                                             models.DataIdentifierAssociation.name
+                                             ).filter_by(child_scope=scope, child_name=name):
+                        events = session.query(func.sum(models.DataIdentifierAssociation.events)) \
+                            .filter_by(scope=parent_scope, name=parent_name).one()[0]
+                        session.query(models.DataIdentifier) \
+                            .filter_by(scope=parent_scope, name=parent_name) \
+                            .update({'events': events}, synchronize_session=False)
             elif key == 'adler32':
-                rowcount = did_query.filter_by(did_type=DIDType.FILE).update({key: value}, synchronize_session=False)
+                rowcount = did_query \
+                    .filter_by(did_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
                 if not rowcount:
                     # check for DID presence
                     raise exception.UnsupportedOperation('%s for %s:%s cannot be updated' % (key, scope, name))
 
-                session.query(models.DataIdentifierAssociation).filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE).update({key: value}, synchronize_session=False)
-                session.query(models.Request).filter_by(scope=scope, name=name).update({key: value}, synchronize_session=False)
-                session.query(models.RSEFileAssociation).filter_by(scope=scope, name=name).update({key: value}, synchronize_session=False)
+                session.query(models.DataIdentifierAssociation) \
+                    .filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
+                session.query(models.Request) \
+                    .filter_by(scope=scope, name=name) \
+                    .update({key: value}, synchronize_session=False)
+                session.query(models.RSEFileAssociation) \
+                    .filter_by(scope=scope, name=name) \
+                    .update({key: value}, synchronize_session=False)
             elif key == 'bytes':
-                rowcount = did_query.filter_by(did_type=DIDType.FILE).update({key: value}, synchronize_session=False)
+                rowcount = did_query \
+                    .filter_by(did_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
                 if not rowcount:
                     # check for DID presence
                     raise exception.UnsupportedOperation('%s for %s:%s cannot be updated' % (key, scope, name))
 
-                session.query(models.DataIdentifierAssociation).filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE).update({key: value}, synchronize_session=False)
-                session.query(models.Request).filter_by(scope=scope, name=name).update({key: value}, synchronize_session=False)
-
-                for account, bytes_, rse_id, rule_id in session.query(models.ReplicaLock.account, models.ReplicaLock.bytes, models.ReplicaLock.rse_id, models.ReplicaLock.rule_id).filter_by(scope=scope, name=name):
-                    session.query(models.ReplicaLock).filter_by(scope=scope, name=name, rule_id=rule_id, rse_id=rse_id).update({key: value}, synchronize_session=False)
+                session.query(models.DataIdentifierAssociation) \
+                    .filter_by(child_scope=scope, child_name=name, child_type=DIDType.FILE) \
+                    .update({key: value}, synchronize_session=False)
+                session.query(models.Request) \
+                    .filter_by(scope=scope, name=name) \
+                    .update({key: value}, synchronize_session=False)
+
+                for account, bytes_, rse_id, rule_id \
+                        in session.query(models.ReplicaLock.account,
+                                         models.ReplicaLock.bytes,
+                                         models.ReplicaLock.rse_id,
+                                         models.ReplicaLock.rule_id
+                                         ).filter_by(scope=scope, name=name):
+                    session.query(models.ReplicaLock) \
+                        .filter_by(scope=scope, name=name, rule_id=rule_id, rse_id=rse_id) \
+                        .update({key: value}, synchronize_session=False)
                     account_counter.decrease(rse_id=rse_id, account=account, files=1, bytes_=bytes_, session=session)
                     account_counter.increase(rse_id=rse_id, account=account, files=1, bytes_=value, session=session)
 
-                for bytes_, rse_id in session.query(models.RSEFileAssociation.bytes, models.RSEFileAssociation.rse_id).filter_by(scope=scope, name=name):
-                    session.query(models.RSEFileAssociation).filter_by(scope=scope, name=name, rse_id=rse_id).update({key: value}, synchronize_session=False)
+                for bytes_, rse_id \
+                        in session.query(models.RSEFileAssociation.bytes,
+                                         models.RSEFileAssociation.rse_id
+                                         ).filter_by(scope=scope, name=name):
+                    session.query(models.RSEFileAssociation) \
+                        .filter_by(scope=scope, name=name, rse_id=rse_id) \
+                        .update({key: value}, synchronize_session=False)
                     rse_counter.decrease(rse_id=rse_id, files=1, bytes_=bytes_, session=session)
                     rse_counter.increase(rse_id=rse_id, files=1, bytes_=value, session=session)
 
-                for parent_scope, parent_name in session.query(models.DataIdentifierAssociation.scope, models.DataIdentifierAssociation.name).filter_by(child_scope=scope, child_name=name):
-                    values = {}
-                    values['length'], values['bytes'], values['events'] = session.query(func.count(models.DataIdentifierAssociation.scope),
-                                                                                        func.sum(models.DataIdentifierAssociation.bytes),
-                                                                                        func.sum(models.DataIdentifierAssociation.events)).filter_by(scope=parent_scope, name=parent_name).one()
-                    session.query(models.DataIdentifier).filter_by(scope=parent_scope, name=parent_name).update(values, synchronize_session=False)
-                    session.query(models.DatasetLock).filter_by(scope=parent_scope, name=parent_name).update({'length': values['length'], 'bytes': values['bytes']}, synchronize_session=False)
+                for parent_scope, parent_name \
+                        in session.query(models.DataIdentifierAssociation.scope,
+                                         models.DataIdentifierAssociation.name
+                                         ).filter_by(child_scope=scope, child_name=name):
+                    values: dict[Any, Any] = {
+                        'length': (session
+                                   .query(func.count(models.DataIdentifierAssociation.scope),
+                                          func.sum(models.DataIdentifierAssociation.bytes),
+                                          func.sum(models.DataIdentifierAssociation.events))
+                                   .filter_by(scope=parent_scope, name=parent_name).one())[0],
+                        'bytes': (session
+                                  .query(func.count(models.DataIdentifierAssociation.scope),
+                                         func.sum(models.DataIdentifierAssociation.bytes),
+                                         func.sum(models.DataIdentifierAssociation.events))
+                                  .filter_by(scope=parent_scope, name=parent_name).one())[1],
+                        'events': (session
+                                   .query(func.count(models.DataIdentifierAssociation.scope),
+                                          func.sum(models.DataIdentifierAssociation.bytes),
+                                          func.sum(models.DataIdentifierAssociation.events))
+                                   .filter_by(scope=parent_scope, name=parent_name).one())[2]}
+                    session.query(models.DataIdentifier) \
+                        .filter_by(scope=parent_scope, name=parent_name) \
+                        .update(values, synchronize_session=False)
+                    session.query(models.DatasetLock) \
+                        .filter_by(scope=parent_scope, name=parent_name) \
+                        .update({'length': values['length'], 'bytes': values['bytes']}, synchronize_session=False)
             else:
                 remainder[key] = value
 
@@ -148,42 +252,63 @@ class DidColumnMeta(DidMetaPlugin):
             except InvalidRequestError:
                 raise exception.InvalidMetadata("Some of the keys are not accepted: " + str(list(remainder.keys())))
             if not rowcount:
-                raise exception.UnsupportedOperation('Some of the keys for %s:%s cannot be updated: %s' % (scope, name, str(list(remainder.keys()))))
+                raise exception.UnsupportedOperation(
+                    'Some of the keys for %s:%s cannot be updated: %s' % (scope, name, str(list(remainder.keys()))))
 
             # propagate metadata updates to child content
             if recursive:
-                content_query = session.query(models.DataIdentifierAssociation.child_scope, models.DataIdentifierAssociation.child_name)
-                content_query = content_query.with_hint(models.DataIdentifierAssociation, "INDEX(CONTENTS CONTENTS_PK)", 'oracle').filter_by(scope=scope, name=name)
+                content_query = session.query(models.DataIdentifierAssociation.child_scope,
+                                              models.DataIdentifierAssociation.child_name)
+                content_query = content_query.with_hint(models.DataIdentifierAssociation, "INDEX(CONTENTS CONTENTS_PK)",
+                                                        'oracle').filter_by(scope=scope, name=name)
 
                 for child_scope, child_name in content_query:
                     try:
-                        stmt = update(models.DataIdentifier)\
-                            .prefix_with("/*+ INDEX(DIDS DIDS_PK) */", dialect='oracle')\
-                            .filter_by(scope=child_scope, name=child_name)\
-                            .execution_options(synchronize_session='fetch')\
+                        stmt = update(models.DataIdentifier) \
+                            .prefix_with("/*+ INDEX(DIDS DIDS_PK) */", dialect='oracle') \
+                            .filter_by(scope=child_scope, name=child_name) \
+                            .execution_options(synchronize_session='fetch') \
                             .values(remainder)
                         session.execute(stmt)
                     except CompileError as error:
                         raise exception.InvalidMetadata(error)
                     except InvalidRequestError:
-                        raise exception.InvalidMetadata("Some of the keys are not accepted recursively: " + str(list(remainder.keys())))
+                        raise exception.InvalidMetadata(
+                            "Some of the keys are not accepted recursively: " + str(list(remainder.keys())))
 
     @stream_session
-    def list_dids(self, scope, filters, did_type='collection', ignore_case=False, limit=None,
-                  offset=None, long=False, recursive=False, ignore_dids=None, *, session: "Session"):
+    def list_dids(
+            self,
+            scope: "InternalScope",
+            filters: "Union[dict[str, Any], list[dict[str, Any]]]",
+            did_type: "Literal['all', 'collection', 'dataset', 'container', 'file']" = 'collection',
+            ignore_case: bool = False,
+            limit: "Optional[int]" = None,
+            offset: "Optional[int]" = None,
+            long: bool = False,
+            recursive: bool = False,
+            ignore_dids: "Optional[set[str]]" = None,
+            *,
+            session: "Session",
+    ) -> "Iterator[Union[str, dict[str, Any]]]":
         """
         Search data identifiers.
 
-        :param scope: the scope name.
-        :param filters: dictionary of attributes by which the results should be filtered.
-        :param did_type: the type of the DID: all(container, dataset, file), collection(dataset or container), dataset, container, file.
-        :param ignore_case: ignore case distinctions.
-        :param limit: limit number.
-        :param offset: offset number.
-        :param long: Long format option to display more information for each DID.
+        :param scope: The scope of the DIDs to list.
+        :param filters: A single dict or a list of dicts representing OR groups (disjunction).
+            Each group can include a semantic 'type' expanded into did_type filters.
+        :param did_type: Option to filter by a specific DID type:
+            all(container, dataset, file), collection(dataset or container), dataset, container, file.
+        :param ignore_case: Has no effect.
+        :param limit: Option to limit the number of returned results.
+        :param offset: Has no effect.
+        :param long: Option to display more information for each DID.
+        :param recursive: Option to recursively list child-DIDs content.
+        :param ignore_dids: A set of 'scope:name' strings to de-duplicate results across OR groups and recursion.
         :param session: The database session in use.
-        :param recursive: Recursively list DIDs content.
-        :param ignore_dids: List of DIDs to refrain from yielding.
+        :yields:
+            - If long is False: DID names (str).
+            - If long is True: dicts with keys: {'scope', 'name', 'did_type', 'bytes', 'length'}.
         """
         if not ignore_dids:
             ignore_dids = set()
@@ -202,7 +327,8 @@ class DidColumnMeta(DidMetaPlugin):
             filters = [filters]
 
         # for each or_group, make sure there is a mapped "did_type" filter.
-        # if type maps to many DIDTypes, the corresponding or_group will be copied the required number of times to satisfy all the logical possibilities.
+        # if type maps to many DIDTypes, the corresponding or_group will be copied the
+        # required number of times to satisfy all the logical possibilities.
         filters_tmp = []
         for or_group in filters:
             if 'type' not in or_group:
@@ -210,7 +336,8 @@ class DidColumnMeta(DidMetaPlugin):
             else:
                 or_group_type = or_group.pop('type').lower()
             if or_group_type not in type_to_did_type_mapping.keys():
-                raise exception.UnsupportedOperation('{} is not a valid type. Valid types are {}'.format(or_group_type, type_to_did_type_mapping.keys()))
+                raise exception.UnsupportedOperation(
+                    '{} is not a valid type. Valid types are {}'.format(or_group_type, type_to_did_type_mapping.keys()))
 
             for mapped_did_type in type_to_did_type_mapping[or_group_type]:
                 or_group['did_type'] = mapped_did_type
@@ -245,24 +372,32 @@ class DidColumnMeta(DidMetaPlugin):
         if recursive:
             from rucio.core.did import list_content
 
-            # Get attached DIDs and save in list because query has to be finished before starting a new one in the recursion
+            # Get attached DIDs and save in a list because the query has to be finished before starting a new one in the recursion
             collections_content = []
             for did in session.execute(stmt).yield_per(100):
-                if (did.did_type == DIDType.CONTAINER or did.did_type == DIDType.DATASET):
+                if did.did_type == DIDType.CONTAINER or did.did_type == DIDType.DATASET:
                     collections_content += [d for d in list_content(scope=did.scope, name=did.name)]
 
             # Replace any name filtering with recursed DID names.
             for did in collections_content:
                 for or_group in filters:
                     or_group['name'] = did['name']
-                for result in self.list_dids(scope=did['scope'], filters=filters, recursive=True, did_type=did_type, limit=limit, offset=offset,
-                                             long=long, ignore_dids=ignore_dids, session=session):
+                for result in self.list_dids(scope=did['scope'],
+                                             filters=filters,
+                                             recursive=True,
+                                             did_type=did_type,
+                                             limit=limit,
+                                             offset=offset,
+                                             long=long,
+                                             ignore_dids=ignore_dids,
+                                             session=session):
                     yield result
 
-        for did in session.execute(stmt).yield_per(5):                  # don't unpack this as it makes it dependent on query return order!
+        for did in session.execute(stmt).yield_per(
+                5):  # don't unpack this as it makes it dependent on query return order!
             if long:
                 did_full = "{}:{}".format(did.scope, did.name)
-                if did_full not in ignore_dids:         # concatenating results of OR clauses may contain duplicate DIDs if query result sets not mutually exclusive.
+                if did_full not in ignore_dids:  # concatenating results of OR clauses may contain duplicate DIDs if the query result sets not mutually exclusive.
                     ignore_dids.add(did_full)
                     yield {
                         'scope': did.scope,
@@ -273,21 +408,41 @@ class DidColumnMeta(DidMetaPlugin):
                     }
             else:
                 did_full = "{}:{}".format(did.scope, did.name)
-                if did_full not in ignore_dids:         # concatenating results of OR clauses may contain duplicate DIDs if query result sets not mutually exclusive.
+                if did_full not in ignore_dids:  # concatenating results of OR clauses may contain duplicate DIDs if the query result sets not mutually exclusive.
                     ignore_dids.add(did_full)
                     yield did.name
 
-    def delete_metadata(self, scope, name, key, *, session: "Optional[Session]" = None):
+    def delete_metadata(
+            self,
+            scope: "InternalScope",
+            name: str,
+            key: str,
+            *,
+            session: "Optional[Session]" = None,
+    ) -> None:
         """
-        Deletes the metadata stored for the given key.
+        Deletes the metadata stored for the given key. (Currently not implemented)
 
         :param scope: The scope of the DID.
         :param name: The name of the DID.
         :param key: Key of the metadata.
+        :param session: The database session in use.
         """
         raise NotImplementedError('The DidColumnMeta plugin does not currently support deleting metadata.')
 
-    def manages_key(self, key, *, session: "Optional[Session]" = None):
+    def manages_key(
+            self,
+            key: str,
+            *,
+            session: "Optional[Session]" = None,
+    ) -> bool:
+        """
+        Return whether a metadata key is managed by this plugin.
+
+        :param key: Key of the metadata.
+        :param session: Unused; accepted for interface compatibility.
+        :returns: ``True`` if the key is managed by this plugin, else ``False``.
+        """
         # Build list of which keys are managed by this plugin.
         #
         all_did_table_columns = []
@@ -323,9 +478,11 @@ class DidColumnMeta(DidMetaPlugin):
 
         return key in hardcoded_keys
 
-    def get_plugin_name(self):
+    def get_plugin_name(
+            self
+    ) -> str:
         """
-        Returns a unique identifier for this plugin. This can be later used for filtering down results to this plugin only.
+        Return a unique identifier for this plugin.
         :returns: The name of the plugin.
         """
         return self.plugin_name

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

@@ -22,6 +22,7 @@ import threading
 import traceback
 from abc import ABCMeta, abstractmethod
 from collections import defaultdict, namedtuple
+from collections.abc import Sized
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional, Union
 
@@ -310,7 +311,11 @@ def queue_requests(
     :param logger:    Optional decorated logger that can be passed from the calling daemons or servers.
     :returns:         List of Request-IDs as 32 character hex strings.
     """
-    logger(logging.DEBUG, "queue requests")
+
+    if isinstance(requests, Sized):
+        logger(logging.DEBUG, "Queuing %d requests", len(requests))
+    else:
+        logger(logging.DEBUG, "Queuing requests")
 
     request_clause = []
     rses = {}
@@ -1508,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

@@ -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/daemons/abacus/account.py

@@ -66,7 +66,7 @@ def run_once(
 
     # If the list is empty, sent the worker to sleep
     if not updated_account_counters:
-        logger(logging.INFO, 'did not get any work')
+        logger(logging.INFO, 'Did not get any work')
         return
 
     for account_counter in updated_account_counters:

rucio/daemons/abacus/collection_replica.py

@@ -71,7 +71,7 @@ def run_once(
     logger(logging.DEBUG, 'Index query time %f size=%d' % (time.time() - start, len(replicas)))
     # If the list is empty, sent the worker to sleep
     if not replicas:
-        logger(logging.INFO, 'did not get any work')
+        logger(logging.INFO, 'Did not get any work')
         must_sleep = True
         return must_sleep
 

rucio/daemons/abacus/rse.py

@@ -67,7 +67,7 @@ def run_once(
 
     # If the list is empty, sent the worker to sleep
     if not rse_ids:
-        logger(logging.INFO, 'did not get any work')
+        logger(logging.INFO, 'Did not get any work')
         return
 
     for rse_id in rse_ids:

rucio/daemons/common.py

@@ -200,7 +200,7 @@ def db_workqueue(
 
             with HeartbeatHandler(executable=executable, renewal_interval=sleep_time - 1) as heartbeat_handler:
                 logger = heartbeat_handler.logger
-                logger(logging.INFO, 'started')
+                logger(logging.INFO, 'Daemon started')
 
                 if partition_wait_time:
                     graceful_stop.wait(partition_wait_time)

rucio/daemons/hermes/hermes.py

@@ -799,19 +799,20 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
             except Exception as error:
                 logger(logging.ERROR, "Error sending to ActiveMQ : %s", str(error))
 
-    logger(logging.INFO, "Deleting %s messages", len(to_delete))
-    to_delete = [
-        {
-            "id": message["id"],
-            "created_at": message["created_at"],
-            "updated_at": message["created_at"],
-            "payload": str(message["payload"]),
-            "event_type": message["event_type"],
-            "services": message["services"]
-        }
-        for message in to_delete
-    ]
-    delete_messages(messages=to_delete)
+        logger(logging.INFO, "Deleting %s messages", len(to_delete))
+        to_delete = [
+            {
+                "id": message["id"],
+                "created_at": message["created_at"],
+                "updated_at": message["created_at"],
+                "payload": str(message["payload"]),
+                "event_type": message["event_type"],
+                "services": message["services"]
+            }
+            for message in to_delete
+        ]
+        delete_messages(messages=to_delete)
+
     must_sleep = True
     return must_sleep
 

rucio/daemons/judge/cleaner.py

@@ -85,10 +85,10 @@ def run_once(
                               worker_number=worker_number,
                               limit=200,
                               blocked_rules=[key for key in paused_rules])
-    logger(logging.DEBUG, 'index query time %f fetch size is %d' % (time.time() - start, len(rules)))
+    logger(logging.DEBUG, 'Index query time %f fetch size is %d' % (time.time() - start, len(rules)))
 
     if not rules:
-        logger(logging.DEBUG, 'did not get any work (paused_rules=%s)' % str(len(paused_rules)))
+        logger(logging.DEBUG, 'Did not get any work (paused_rules=%s)' % str(len(paused_rules)))
         return
 
     for rule in rules: