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

rucio/daemons/conveyor/stager.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");
@@ -19,8 +18,7 @@ Conveyor stager is a daemon to manage stagein file transfers.
 
 import logging
 import threading
-from types import FrameType
-from typing import Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 import rucio.db.sqla.util
 from rucio.common import exception
@@ -32,22 +30,28 @@ from rucio.daemons.conveyor.submitter import submitter
 from rucio.db.sqla.constants import RequestType
 from rucio.transfertool.fts3 import FTS3Transfertool
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+    from types import FrameType
+
+    from rucio.common.types import RSESettingsDict
+
 METRICS = MetricManager(module=__name__)
 GRACEFUL_STOP = threading.Event()
 DAEMON_NAME = 'conveyor-stager'
 
 
 def stager(
-        once=False,
-        rses=None,
-        bulk=100,
-        group_bulk=1,
-        group_policy='rule',
-        source_strategy=None,
-        activities=None,
-        sleep_time=600,
-        total_threads=1
-):
+        once: bool = False,
+        rses: Optional[list["RSESettingsDict"]] = None,
+        bulk: int = 100,
+        group_bulk: int = 1,
+        group_policy: str = 'rule',
+        source_strategy: Optional[str] = None,
+        activities: Optional[list[str]] = None,
+        sleep_time: int = 600,
+        total_threads: int = 1
+) -> None:
 
     submitter(
         once=once,
@@ -71,7 +75,7 @@ def stager(
     )
 
 
-def stop(signum: Optional[int] = None, frame: Optional[FrameType] = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -80,22 +84,23 @@ def stop(signum: Optional[int] = None, frame: Optional[FrameType] = None) -> Non
 
 
 def run(
-        once=False,
-        total_threads=1,
-        group_bulk=1,
-        group_policy='rule',
-        rses=None,
-        include_rses=None,
-        exclude_rses=None,
-        vos=None,
-        bulk=100,
-        source_strategy=None,
-        activities=[],
-        sleep_time=600
-):
+    once: bool = False,
+    total_threads: int = 1,
+    group_bulk: int = 1,
+    group_policy: str = 'rule',
+    rses: Optional["Sequence[Mapping[str, Any]]"] = None,
+    include_rses: Optional[str] = None,
+    exclude_rses: Optional[str] = None,
+    vos: Optional[list[str]] = None,
+    bulk: int = 100,
+    source_strategy: Optional[str] = None,
+    activities: Optional[list[str]] = None,
+    sleep_time: int = 600
+) -> None:
     """
-    Starts up the conveyer threads.
+    Starts up the conveyor threads.
     """
+    activities = activities or []
     setup_logging(process_name=DAEMON_NAME)
 
     if rucio.db.sqla.util.is_old_db():

rucio/daemons/conveyor/submitter.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");
@@ -19,27 +18,28 @@ Conveyor transfer submitter is a daemon to manage non-tape file transfers.
 import logging
 import threading
 from collections.abc import Mapping
-from types import FrameType
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Optional
 
 import rucio.db.sqla.util
 from rucio.common import exception
-from rucio.common.config import config_get, config_get_bool, config_get_int, config_get_list, config_get_float
+from rucio.common.config import config_get, config_get_bool, config_get_float, config_get_int, config_get_list
 from rucio.common.logging import setup_logging
 from rucio.common.schema import get_schema_value
 from rucio.common.stopwatch import Stopwatch
 from rucio.core.monitor import MetricManager
-from rucio.core.request import list_and_mark_transfer_requests_and_source_replicas
-from rucio.core.topology import Topology, ExpiringObjectCache
-from rucio.core.transfer import DEFAULT_MULTIHOP_TOMBSTONE_DELAY, list_transfer_admin_accounts, transfer_path_str, \
-    TRANSFERTOOL_CLASSES_BY_NAME, ProtocolFactory
-from rucio.daemons.common import db_workqueue, ProducerConsumerDaemon
-from rucio.daemons.conveyor.common import submit_transfer, get_conveyor_rses, pick_and_prepare_submission_path
-from rucio.db.sqla.constants import RequestType, RequestState
+from rucio.core.request import RequestWithSources, list_and_mark_transfer_requests_and_source_replicas
+from rucio.core.topology import ExpiringObjectCache, Topology
+from rucio.core.transfer import DEFAULT_MULTIHOP_TOMBSTONE_DELAY, TRANSFERTOOL_CLASSES_BY_NAME, ProtocolFactory, list_transfer_admin_accounts, transfer_path_str
+from rucio.daemons.common import ProducerConsumerDaemon, db_workqueue
+from rucio.daemons.conveyor.common import get_conveyor_rses, pick_and_prepare_submission_path, submit_transfer
+from rucio.db.sqla.constants import RequestState, RequestType
 from rucio.transfertool.fts3 import FTS3Transfertool
 from rucio.transfertool.globus import GlobusTransferTool
 
 if TYPE_CHECKING:
+    from types import FrameType
+
+    from rucio.common.types import LoggerFunction, RSESettingsDict
     from rucio.daemons.common import HeartbeatHandler
 
 METRICS = MetricManager(module=__name__)
@@ -60,16 +60,16 @@ def _fetch_requests(
         ignore_availability: bool,
         filter_transfertool: Optional[str],
         metrics: MetricManager,
-        cached_topology,
+        cached_topology: Optional[ExpiringObjectCache],
         set_last_processed_by: bool,
         heartbeat_handler: "HeartbeatHandler",
-):
+) -> tuple[bool, tuple[Topology, dict[str, RequestWithSources]]]:
     """
     Fetches requests to be handled from the database
     """
     worker_number, total_workers, logger = heartbeat_handler.live()
 
-    topology = cached_topology.get() if cached_topology else Topology(ignore_availability=ignore_availability)
+    topology: Topology = cached_topology.get() if cached_topology else Topology(ignore_availability=ignore_availability)
     topology.configure_multihop(logger=logger)
     stopwatch = Stopwatch()
 
@@ -114,17 +114,17 @@ def _fetch_requests(
 
 
 def _handle_requests(
-        batch,
+        batch: tuple[Topology, Mapping[str, RequestWithSources]],
         *,
         transfertools: list[str],
         schemes: Optional[list[str]],
         failover_schemes: Optional[list[str]],
         max_sources: int,
         timeout: Optional[float],
-        transfertool_kwargs,
+        transfertool_kwargs: dict,
         metrics: MetricManager,
-        logger=logging.log,
-):
+        logger: "LoggerFunction" = logging.log,
+) -> None:
     topology, requests_with_sources = batch
 
     protocol_factory = ProtocolFactory()
@@ -168,7 +168,7 @@ def _handle_requests(
         for job in grouped_jobs:
             logger(logging.DEBUG, 'submitjob: transfers=%s, job_params=%s' % ([str(t) for t in job['transfers']], job['job_params']))
             submit_transfer(transfertool_obj=transfertool_obj, transfers=job['transfers'], job_params=job['job_params'],
-                            timeout=timeout, logger=logger)
+                            timeout=timeout, logger=logger)  # type: ignore (unclear whether timeout is supposed to be float or int)
 
 
 def _get_max_time_in_queue_conf() -> dict[str, int]:
@@ -189,7 +189,7 @@ def _get_max_time_in_queue_conf() -> dict[str, int]:
 
 def submitter(
         once: bool = False,
-        rses: Optional[list[Mapping[str, Any]]] = None,
+        rses: Optional[list["RSESettingsDict"]] = None,
         partition_wait_time: int = 10,
         bulk: int = 100,
         group_bulk: int = 1,
@@ -207,9 +207,9 @@ def submitter(
         request_type: Optional[list[RequestType]] = None,
         default_lifetime: int = 172800,
         metrics: MetricManager = METRICS,
-        cached_topology=None,
+        cached_topology: Optional[ExpiringObjectCache] = None,
         total_threads: int = 1,
-):
+) -> None:
     """
     Main loop to submit a new transfer primitive to a transfertool.
     """
@@ -219,8 +219,28 @@ def submitter(
 
     partition_hash_var = config_get('conveyor', 'partition_hash_var', default=None, raise_exception=False)
 
-    schemes = config_get_list('conveyor', 'scheme', default=None, raise_exception=False)
-    failover_schemes = config_get_list('conveyor', 'failover_scheme', default=None, raise_exception=False)
+    config_schemes = set(config_get_list('conveyor', 'scheme', raise_exception=False) or [])
+    config_failover_schemes = set(config_get_list('conveyor', 'failover_scheme', raise_exception=False) or [])
+
+    schemes_supported_by_tt = set()
+    for transfertool in transfertools:
+        schemes_supported_by_tt.update(TRANSFERTOOL_CLASSES_BY_NAME[transfertool].supported_schemes)
+
+    schemes = config_schemes.intersection(schemes_supported_by_tt)
+    failover_schemes = config_failover_schemes.intersection(schemes_supported_by_tt)
+
+    if config_schemes and not schemes:
+        logging.critical(f'None of the configured schemes ({list(config_schemes)}) is supported '
+                         f'by any configured transfertool ({transfertools}). This configuration is invalid. Aborting')
+        return
+    if config_failover_schemes and not failover_schemes:
+        logging.critical(f'None of the configured failover schemes ({list(config_failover_schemes)}) is supported '
+                         f'by any configured transfertool ({transfertools}). This configuration is invalid. Aborting')
+        return
+    if config_schemes.difference(schemes):
+        logging.info(f'Following schemes filtered out: {list(config_schemes.difference(schemes))}')
+    if config_failover_schemes.difference(failover_schemes):
+        logging.info(f'Following failover schemes filtered out: {list(config_failover_schemes.difference(failover_schemes))}')
 
     timeout = config_get_float('conveyor', 'submit_timeout', default=None, raise_exception=False)
 
@@ -262,7 +282,11 @@ def submitter(
         partition_wait_time=partition_wait_time,
         sleep_time=sleep_time,
         activities=activities)
-    def _db_producer(*, activity, heartbeat_handler):
+    def _db_producer(
+        *,
+        activity: str,
+        heartbeat_handler: "HeartbeatHandler"
+    ) -> tuple[bool, tuple[Topology, dict[str, RequestWithSources]]]:
         return _fetch_requests(
             bulk=bulk,
             filter_transfertool=filter_transfertool,
@@ -277,12 +301,12 @@ def submitter(
             heartbeat_handler=heartbeat_handler,
         )
 
-    def _consumer(batch):
+    def _consumer(batch: tuple[Topology, Mapping[str, RequestWithSources]]) -> None:
         return _handle_requests(
             batch,
             transfertools=transfertools,
-            schemes=schemes,
-            failover_schemes=failover_schemes,
+            schemes=list(schemes),
+            failover_schemes=list(failover_schemes),
             max_sources=max_sources,
             timeout=timeout,
             transfertool_kwargs=transfertool_kwargs,
@@ -296,7 +320,7 @@ def submitter(
     ).run()
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -304,26 +328,26 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
 
 
 def run(
-        once=False,
-        group_bulk=1,
-        group_policy='rule',
-        rses=None,
-        include_rses=None,
-        exclude_rses=None,
-        vos=None,
-        bulk=100,
-        source_strategy=None,
-        activities=None,
-        exclude_activities=None,
-        ignore_availability=False,
-        sleep_time=600,
-        max_sources=4,
-        archive_timeout_override=None,
-        total_threads=1,
+        once: bool = False,
+        group_bulk: int = 1,
+        group_policy: str = 'rule',
+        rses: Optional[list["RSESettingsDict"]] = None,
+        include_rses: Optional[str] = None,
+        exclude_rses: Optional[str] = None,
+        vos: Optional[list[str]] = None,
+        bulk: int = 100,
+        source_strategy: Optional[str] = None,
+        activities: Optional[list[str]] = None,
+        exclude_activities: Optional[list[str]] = None,
+        ignore_availability: bool = False,
+        sleep_time: int = 600,
+        max_sources: int = 4,
+        archive_timeout_override: Optional[int] = None,
+        total_threads: int = 1,
         **_kwargs
-):
+) -> None:
     """
-    Starts up the conveyer threads.
+    Starts up the conveyor threads.
     """
     setup_logging(process_name=DAEMON_NAME)
 

rucio/daemons/conveyor/throttler.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");
@@ -17,39 +16,77 @@
 Conveyor throttler is a daemon to manage rucio internal queue.
 """
 import logging
+import math
 import threading
 import traceback
 from collections import defaultdict
-from types import FrameType
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, TypedDict, Union
 
-import math
 from sqlalchemy import null
 
 import rucio.db.sqla.util
 from rucio.common import exception
 from rucio.common.logging import setup_logging
 from rucio.core.monitor import MetricManager
-from rucio.core.request import (get_request_stats, release_all_waiting_requests, release_waiting_requests_fifo,
-                                release_waiting_requests_grouped_fifo, set_transfer_limit_stats, re_sync_all_transfer_limits)
-from rucio.core.rse import RseCollection
+from rucio.core.request import get_request_stats, re_sync_all_transfer_limits, release_all_waiting_requests, release_waiting_requests_fifo, release_waiting_requests_grouped_fifo, reset_stale_waiting_requests, set_transfer_limit_stats
+from rucio.core.rse import RseCollection, RseData
 from rucio.core.transfer import applicable_rse_transfer_limits
-from rucio.daemons.common import db_workqueue, ProducerConsumerDaemon
+from rucio.daemons.common import ProducerConsumerDaemon, db_workqueue
 from rucio.db.sqla.constants import RequestState, TransferLimitDirection
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from types import FrameType
+
+    from rucio.common.types import InternalAccount, LoggerFunction
     from rucio.daemons.common import HeartbeatHandler
 
+    class LimitDict(TypedDict):
+        activity: Optional[str]
+        direction: TransferLimitDirection
+        waitings: int
+        transfers: int
+        max_transfers: int
+        rse_expression: str
+        strategy: str
+        volume: int
+        deadline: int
+
+    class AccountStatDict(TypedDict):
+        waiting: int
+        active: int
+        residual_capacity: float
+
+    class StatDict(TypedDict):
+        accounts: AccountStatDict
+        residual_capacity: float
+        waiting: int
+        active: int
+
+    class LimitStatDict(TypedDict):
+        limit: LimitDict
+        stat: StatDict
+
+    ReleaseGroupsDict = dict[
+        tuple[
+            RseData,         # source_rse
+            RseData,         # dest_rse
+            str,             # activity
+        ],
+        list[LimitStatDict]  # applicable_limits
+    ]
+
+
 GRACEFUL_STOP = threading.Event()
 METRICS = MetricManager(module=__name__)
 DAEMON_NAME = 'conveyor-throttler'
 
 
 def throttler(
-        once=False,
-        sleep_time=600,
-        partition_wait_time=10
-):
+        once: bool = False,
+        sleep_time: int = 600,
+        partition_wait_time: int = 10
+) -> None:
     """
     Main loop to check rse transfer limits.
     """
@@ -62,7 +99,11 @@ def throttler(
         executable=DAEMON_NAME,
         partition_wait_time=partition_wait_time,
         sleep_time=sleep_time)
-    def _db_producer(*, activity: str, heartbeat_handler: "HeartbeatHandler"):
+    def _db_producer(
+            *,
+            activity: str,
+            heartbeat_handler: "HeartbeatHandler"
+    ) -> tuple[bool, Optional["ReleaseGroupsDict"]]:
         worker_number, total_workers, logger = heartbeat_handler.live()
         if worker_number != 0:
             logger(logging.INFO, 'Throttler thread id is not 0, will sleep. Only thread 0 will work')
@@ -73,7 +114,7 @@ def throttler(
         release_groups = _get_request_stats(rse_collection, logger=logger)
         return True, release_groups
 
-    def _consumer(release_groups):
+    def _consumer(release_groups: Optional["ReleaseGroupsDict"]) -> None:
         if release_groups is None:
             return
         logger = logging.log
@@ -82,6 +123,7 @@ def throttler(
             _handle_requests(release_groups, logger=logger)
         except Exception:
             logger(logging.CRITICAL, "Failed to schedule requests, error: %s" % (traceback.format_exc()))
+        reset_stale_waiting_requests()
 
     ProducerConsumerDaemon(
         producers=[_db_producer],
@@ -90,7 +132,7 @@ def throttler(
     ).run()
 
 
-def stop(signum: Optional[int] = None, frame: Optional[FrameType] = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -98,9 +140,12 @@ def stop(signum: Optional[int] = None, frame: Optional[FrameType] = None) -> Non
     GRACEFUL_STOP.set()
 
 
-def run(once=False, sleep_time=600):
+def run(
+        once: bool = False,
+        sleep_time: int = 600
+) -> None:
     """
-    Starts up the conveyer threads.
+    Starts up the conveyor threads.
     """
     setup_logging(process_name=DAEMON_NAME)
 
@@ -114,19 +159,25 @@ class RequestGrouper:
 
     class RseStatistic:
         def __init__(self):
-            self.sources_with_limits = set()
-            self.destinations_with_limits = set()
-            self.unavailable_sources = set()
-            self.unavailable_destinations = set()
+            self.sources_with_limits: set[RseData] = set()
+            self.destinations_with_limits: set[RseData] = set()
+            self.unavailable_sources: set[RseData] = set()
+            self.unavailable_destinations: set[RseData] = set()
             self.has_any_per_activity_limit = False
             self.any_source_has_per_activity_limit = False
             self.any_destination_has_per_activity_limit = False
 
     def __init__(self):
-        self.waiting_transfer_groups = {}
+        self.waiting_transfer_groups: 'ReleaseGroupsDict' = {}
         self.rse_stats = defaultdict(self.RseStatistic)
 
-    def record_waiting_request_group(self, source_rse, dest_rse, activity, applicable_limits):
+    def record_waiting_request_group(
+            self,
+            source_rse: RseData,
+            dest_rse: RseData,
+            activity: str,
+            applicable_limits: list['LimitStatDict']
+    ) -> None:
         """
         Record a group of requests in waiting state, while computing some statistics about them.
         """
@@ -152,12 +203,12 @@ class RequestGrouper:
 
         self.waiting_transfer_groups[source_rse, dest_rse, activity] = applicable_limits
 
-    def merged_groups(self):
+    def merged_groups(self) -> "ReleaseGroupsDict":
         """
         Merge groups which can be handled together
         """
 
-        merged_groups = {}
+        merged_groups: "ReleaseGroupsDict" = {}
         for (source_rse, dest_rse, activity), applicable_limits in self.waiting_transfer_groups.items():
 
             src_info = self.rse_stats[source_rse]
@@ -187,12 +238,16 @@ class RequestGrouper:
                 if not src_info.has_any_per_activity_limit and not src_info.any_destination_has_per_activity_limit:
                     activity = None
 
-            merged_groups.setdefault((source_rse, dest_rse, activity), applicable_limits)
+            merged_groups.setdefault((source_rse, dest_rse, activity), applicable_limits)  # type: ignore
 
         return merged_groups
 
 
-def _get_request_stats(rse_collection: RseCollection, *, logger=logging.log):
+def _get_request_stats(
+        rse_collection: RseCollection,
+        *,
+        logger: "LoggerFunction" = logging.log
+) -> "ReleaseGroupsDict":
     """
     Group waiting requests into arbitrary groups for bulk handling.
     The current grouping (source rse + dest rse + activity) was dictated
@@ -209,7 +264,7 @@ def _get_request_stats(rse_collection: RseCollection, *, logger=logging.log):
     """
     logging.info("Throttler retrieve requests statistics")
 
-    db_stats = get_request_stats(
+    db_stats = get_request_stats(  # type: ignore (Session parameter is missing)
         state=[RequestState.QUEUED,
                RequestState.SUBMITTING,
                RequestState.SUBMITTED,
@@ -278,7 +333,7 @@ def _get_request_stats(rse_collection: RseCollection, *, logger=logging.log):
 
             if state == RequestState.WAITING:
                 grouper.record_waiting_request_group(
-                    source_rse=source_rse,
+                    source_rse=source_rse,  # type: ignore
                     dest_rse=dest_rse,
                     activity=activity,
                     applicable_limits=applicable_limits,
@@ -322,14 +377,17 @@ def _get_request_stats(rse_collection: RseCollection, *, logger=logging.log):
         if waiting != limit['waitings'] or active != limit['transfers']:
             set_transfer_limit_stats(limit['id'], waitings=waiting, transfers=active)
 
-        for account, to_release_for_account in _split_threshold_per_account(stat['accounts'], total_to_release=residual_capacity):
+        for account, to_release_for_account in _split_threshold_per_account(stat['accounts'], total_to_release=residual_capacity):  # type: ignore (stat['accounts'] is not None)
             stat['accounts'][account]['residual_capacity'] = to_release_for_account
 
     release_groups = grouper.merged_groups()
     return release_groups
 
 
-def _split_threshold_per_account(per_account_stats, total_to_release):
+def _split_threshold_per_account(
+        per_account_stats: dict["InternalAccount", dict[str, float]],
+        total_to_release: float
+) -> Union[tuple[None, int], "Iterator[tuple[InternalAccount, float]]"]:
     """
     Compute how many requests to release for each account. Try to achieve a fair share of transfers between accounts.
     :param per_account_stats: a dict with how many active and waiting transfers each account has
@@ -355,7 +413,9 @@ def _split_threshold_per_account(per_account_stats, total_to_release):
         remaining_to_release -= to_release_for_account
 
 
-def _combine_limits(applicable_limits):
+def _combine_limits(
+        applicable_limits: list['LimitStatDict']
+) -> tuple[float, str, Optional[int], Optional[int]]:
     """
     Take multiple limits and combines them into one single (strictest) limit which
     respects the constraints of each initial limits. This is to handle cases like:
@@ -391,7 +451,10 @@ def _combine_limits(applicable_limits):
     return to_release, strategy, volume, deadline
 
 
-def _handle_requests(release_groups, logger):
+def _handle_requests(
+        release_groups: "ReleaseGroupsDict",
+        logger: "LoggerFunction"
+) -> None:
     """
     Release (set to queued state) waiting requests in groups defined by release_groups.
 
@@ -440,8 +503,9 @@ def _handle_requests(release_groups, logger):
             to_release_for_account = {}
             limits_by_account = {}
             for limit_stat in applicable_limits:
-                for account, account_limit in limit_stat['stat']['accounts'].items():
-                    to_release_for_account[account] = min(to_release_for_account.get(account, to_release), account_limit['residual_capacity'])
+                acc_dict = limit_stat['stat']['accounts']
+                for account, account_limit in acc_dict.items():
+                    to_release_for_account[account] = min(to_release_for_account.get(account, to_release), account_limit['residual_capacity'])  # type: ignore (Issue with TypedDict.__getitem__)
                     limits_by_account.setdefault(account, []).append(account_limit)
 
             for account, to_release_account in to_release_for_account.items():

rucio/daemons/follower/__init__.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");

rucio/daemons/follower/follower.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");
@@ -25,7 +24,7 @@ from rucio.common import exception
 from rucio.common.logging import setup_logging
 from rucio.common.utils import get_thread_with_periodic_running_function
 from rucio.core.did import create_reports
-from rucio.core.heartbeat import live, die, sanity_check
+from rucio.core.heartbeat import die, live, sanity_check
 
 if TYPE_CHECKING:
     from types import FrameType
@@ -35,7 +34,9 @@ graceful_stop = threading.Event()
 DAEMON_NAME = 'rucio-follower'
 
 
-def aggregate_events(once=False):
+def aggregate_events(
+        once: bool = False
+) -> None:
     """
     Collect all the events affecting the dids followed by the corresponding account.
     """
@@ -70,7 +71,10 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
     graceful_stop.set()
 
 
-def run(once=False, threads=1):
+def run(
+        once: bool = False,
+        threads: int = 1
+) -> None:
     """
     Starts up the follower threads
     """
@@ -88,10 +92,10 @@ def run(once=False, threads=1):
     else:
         logging.info("starting follower threads")
         # Run the follower daemon thrice a day
-        threads = [get_thread_with_periodic_running_function(28800, aggregate_events, graceful_stop) for i in range(threads)]
-        [t.start() for t in threads]
+        thread_list = [get_thread_with_periodic_running_function(28800, aggregate_events, graceful_stop) for i in range(threads)]
+        [t.start() for t in thread_list]
 
         logging.info("waiting for interrupts")
         # Interruptible joins require a timeout.
-        while threads[0].is_alive():
-            [t.join(timeout=3.14) for t in threads]
+        while thread_list[0].is_alive():
+            [t.join(timeout=3.14) for t in thread_list]

rucio/daemons/hermes/__init__.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");