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

rucio/daemons/common.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");
@@ -22,13 +21,16 @@ import socket
 import threading
 import time
 from collections.abc import Callable, Generator, Iterator, Sequence
-from typing import Any, Generic, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
 
 from rucio.common.logging import formatted_logger
 from rucio.common.utils import PriorityQueue
 from rucio.core import heartbeat as heartbeat_core
 from rucio.core.monitor import MetricManager
 
+if TYPE_CHECKING:
+    from rucio.common.types import LoggerFunction
+
 T = TypeVar('T')
 METRICS = MetricManager(module=__name__)
 
@@ -42,7 +44,7 @@ class HeartbeatHandler:
         """
         :param executable: the executable name which will be set in heartbeats
         :param renewal_interval: the interval at which the heartbeat will be renewed in the database.
-        Calls to live() in-between intervals will re-use the locally cached heartbeat.
+        Calls to live() in-between intervals will reuse the locally cached heartbeat.
         """
         self.executable = executable
         self._hash_executable = None
@@ -58,28 +60,32 @@ class HeartbeatHandler:
         self.last_time = None
         self.last_payload = None
 
-    def __enter__(self):
+    def __enter__(self) -> 'HeartbeatHandler':
         heartbeat_core.sanity_check(executable=self.executable, hostname=self.hostname)
         self.live()
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         if self.last_heart_beat:
             heartbeat_core.die(self.executable, self.hostname, self.pid, self.hb_thread)
             if self.logger:
                 self.logger(logging.INFO, 'Heartbeat cleaned up')
 
     @property
-    def hash_executable(self):
+    def hash_executable(self) -> str:
         if not self._hash_executable:
             self._hash_executable = heartbeat_core.calc_hash(self.executable)
         return self._hash_executable
 
     @property
-    def short_executable(self):
+    def short_executable(self) -> str:
         return min(self.executable, self.hash_executable, key=len)
 
-    def live(self, force_renew: bool = False, payload: Optional[str] = None):
+    def live(
+            self,
+            force_renew: bool = False,
+            payload: Optional[str] = None
+    ) -> tuple[int, int, Callable]:
         """
         :return: a tuple: <the number of the current worker>, <total number of workers>, <decorated logger>
         """
@@ -171,7 +177,18 @@ def db_workqueue(
         partition_wait_time: int,
         sleep_time: int,
         activities: Optional[Sequence[str]] = None,
-):
+) -> Callable[
+    [
+        Callable[
+            ...,
+            Union[bool, tuple[bool, T], None]
+        ]
+    ],
+    Callable[
+        [],
+        Iterator[Union[T, None]]
+    ]
+]:
     """
     Used to wrap a function for interacting with the database as a work queue: i.e. to select
     a set of rows and perform some work on those rows while ensuring that two instances running in parallel don't
@@ -180,7 +197,7 @@ def db_workqueue(
 
     :param once: Whether to stop after one iteration
     :param graceful_stop: the threading.Event() object used for graceful stop of the daemon
-    :param executable: the name of the executable used for hearbeats
+    :param executable: the name of the executable used for heartbeats
     :param partition_wait_time: time to wait for database partition rebalancing before starting the actual daemon loop
     :param sleep_time: time to sleep between the iterations of the daemon
     :param activities: optional list of activities on which to work. The run_once_fnc will be called on activities one by one.
@@ -189,7 +206,7 @@ def db_workqueue(
     def _decorate(run_once_fnc: Callable[..., Optional[Union[bool, tuple[bool, T]]]]) -> Callable[[], Iterator[Optional[T]]]:
 
         @functools.wraps(run_once_fnc)
-        def _generator():
+        def _generator() -> Iterator[T]:
 
             with HeartbeatHandler(executable=executable, renewal_interval=sleep_time - 1) as heartbeat_handler:
                 logger = heartbeat_handler.logger
@@ -254,7 +271,8 @@ def run_daemon(
         partition_wait_time: int,
         sleep_time: int,
         run_once_fnc: Callable[..., Optional[Union[bool, tuple[bool, Any]]]],
-        activities: Optional[list[str]] = None):
+        activities: Optional[list[str]] = None
+) -> None:
     """
     Run the daemon loop and call the function run_once_fnc at each iteration
     """
@@ -277,7 +295,13 @@ class ProducerConsumerDaemon(Generic[T]):
     Daemon which connects N producers with M consumers via a queue.
     """
 
-    def __init__(self, producers, consumers, graceful_stop, logger=logging.log):
+    def __init__(
+            self,
+            producers: Sequence[Callable[[], Iterator[T]]],
+            consumers: Sequence[Callable[..., None]],
+            graceful_stop: threading.Event,
+            logger: "LoggerFunction" = logging.log
+    ):
         self.producers = producers
         self.consumers = consumers
 
@@ -292,7 +316,7 @@ class ProducerConsumerDaemon(Generic[T]):
             self,
             it: Callable[[], Iterator[T]],
             wait_for_consumers: bool = False
-    ):
+    ) -> None:
         """
         Iterate over the generator function and put the extracted elements into the queue.
 
@@ -328,7 +352,7 @@ class ProducerConsumerDaemon(Generic[T]):
     def _consume(
             self,
             fnc: Callable[[T], Any]
-    ):
+    ) -> None:
         """
         Wait for elements to arrive via the queue and call the given function on each element.
 
@@ -349,9 +373,9 @@ class ProducerConsumerDaemon(Generic[T]):
             finally:
                 self.queue.task_done()
 
-    def run(self):
+    def run(self) -> None:
 
-        producer_threads = []
+        producer_threads: list[threading.Thread] = []
         for i, producer in enumerate(self.producers):
             thread = threading.Thread(
                 target=self._produce,
@@ -364,7 +388,7 @@ class ProducerConsumerDaemon(Generic[T]):
             thread.start()
             producer_threads.append(thread)
 
-        consumer_threads = []
+        consumer_threads: list[threading.Thread] = []
         for i, consumer in enumerate(self.consumers):
             thread = threading.Thread(
                 target=self._consume,

rucio/daemons/conveyor/__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/conveyor/common.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");
@@ -22,37 +21,52 @@ import functools
 import itertools
 import logging
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 from rucio.common.config import config_get_bool
-from rucio.common.exception import (InvalidRSEExpression, TransferToolTimeout, TransferToolWrongAnswer, RequestNotFound,
-                                    DuplicateFileTransferSubmission, VONotFound, DatabaseException)
+from rucio.common.constants import RseAttr
+from rucio.common.exception import DatabaseException, DuplicateFileTransferSubmission, InvalidRSEExpression, RequestNotFound, TransferToolTimeout, TransferToolWrongAnswer, VONotFound
 from rucio.common.stopwatch import Stopwatch
-from rucio.core import request as request_core, transfer as transfer_core
+from rucio.core import request as request_core
+from rucio.core import transfer as transfer_core
 from rucio.core.monitor import MetricManager
 from rucio.core.replica import add_replicas, tombstone_from_delay, update_replica_state
-from rucio.core.request import set_request_state, queue_requests
+from rucio.core.request import queue_requests, transition_request_state
 from rucio.core.rse import list_rses
 from rucio.core.rse_expression_parser import parse_expression
 from rucio.core.transfer import build_transfer_paths
 from rucio.core.vo import list_vos
 from rucio.db.sqla import models
-from rucio.db.sqla.constants import RequestState, ReplicaState
+from rucio.db.sqla.constants import ReplicaState, RequestState
 from rucio.db.sqla.session import transactional_session
 from rucio.rse import rsemanager as rsemgr
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
-    from typing import Optional
-    from rucio.core.transfer import DirectTransferDefinition
-    from rucio.transfertool.transfertool import TransferToolBuilder
+    from collections.abc import Iterable, Mapping, Sequence
+
     from sqlalchemy.orm import Session
 
+    from rucio.common.types import InternalAccount, LoggerFunction, RSESettingsDict
+    from rucio.core.request import DirectTransfer, RequestWithSources
+    from rucio.core.topology import Topology
+    from rucio.core.transfer import ProtocolFactory
+    from rucio.transfertool.transfertool import Transfertool, TransferToolBuilder
+
 METRICS = MetricManager(module=__name__)
 
 
-def pick_and_prepare_submission_path(requests_with_sources, topology, protocol_factory, default_tombstone_delay=transfer_core.DEFAULT_MULTIHOP_TOMBSTONE_DELAY,
-                                     admin_accounts=None, schemes=None, failover_schemes=None, max_sources=4, transfertools=None, logger=logging.log):
+def pick_and_prepare_submission_path(
+        requests_with_sources: "Mapping[str, RequestWithSources]",
+        topology: "Topology",
+        protocol_factory: "ProtocolFactory",
+        default_tombstone_delay: int = transfer_core.DEFAULT_MULTIHOP_TOMBSTONE_DELAY,
+        admin_accounts: Optional[set["InternalAccount"]] = None,
+        schemes: Optional["Sequence[str]"] = None,
+        failover_schemes: Optional["Sequence[str]"] = None,
+        max_sources: int = 4,
+        transfertools: Optional["Sequence[str]"] = None,
+        logger: "LoggerFunction" = logging.log
+) -> dict["TransferToolBuilder", list[list["DirectTransfer"]]]:
     """
     For each transfer, pick a (sub)path; and a transfertool to be used to submit that (sub)path
     """
@@ -119,22 +133,22 @@ def pick_and_prepare_submission_path(requests_with_sources, topology, protocol_f
     reqs_no_source.update(reqs_no_host)
     if reqs_no_source:
         logger(logging.INFO, "Marking requests as no-sources: %s", reqs_no_source)
-        request_core.set_requests_state_if_possible(reqs_no_source, RequestState.NO_SOURCES, logger=logger)
+        request_core.transition_requests_state_if_possible(reqs_no_source, RequestState.NO_SOURCES, logger=logger)
     if reqs_only_tape_source:
         logger(logging.INFO, "Marking requests as only-tape-sources: %s", reqs_only_tape_source)
-        request_core.set_requests_state_if_possible(reqs_only_tape_source, RequestState.ONLY_TAPE_SOURCES, logger=logger)
+        request_core.transition_requests_state_if_possible(reqs_only_tape_source, RequestState.ONLY_TAPE_SOURCES, logger=logger)
     if reqs_scheme_mismatch:
         logger(logging.INFO, "Marking requests as scheme-mismatch: %s", reqs_scheme_mismatch)
-        request_core.set_requests_state_if_possible(reqs_scheme_mismatch, RequestState.MISMATCH_SCHEME, logger=logger)
+        request_core.transition_requests_state_if_possible(reqs_scheme_mismatch, RequestState.MISMATCH_SCHEME, logger=logger)
 
     return paths_by_transfertool_builder
 
 
 def __assign_to_transfertool(
-        transfer_path: "list[DirectTransferDefinition]",
-        transfertools: "Optional[list[str]]",
-        logger: "Callable",
-) -> "list[tuple[list[DirectTransferDefinition], Optional[TransferToolBuilder]]]":
+        transfer_path: list["DirectTransfer"],
+        transfertools: Optional["Iterable[str]"],
+        logger: "LoggerFunction",
+) -> list[tuple[list["DirectTransfer"], Optional["TransferToolBuilder"]]]:
     """
     Iterate over a multihop path and assign sub-paths to transfertools in chucks from left to right.
 
@@ -174,11 +188,11 @@ def __assign_to_transfertool(
 
 
 def assign_paths_to_transfertool_and_create_hops(
-        candidate_paths_by_request_id: "dict[str: list[DirectTransferDefinition]]",
+        candidate_paths_by_request_id: "Mapping[str, Sequence[DirectTransfer]]",
         default_tombstone_delay: int,
-        transfertools: "Optional[list[str]]" = None,
-        logger: "Callable" = logging.log,
-) -> "tuple[dict[TransferToolBuilder, list[DirectTransferDefinition]], set[str]]":
+        transfertools: Optional["Sequence[str]"] = None,
+        logger: "LoggerFunction" = logging.log,
+) -> "tuple[dict[TransferToolBuilder, list[list[DirectTransfer]]], set[str]]":
     """
     for each request, pick the first path which can be submitted by one of the transfertools.
     If the chosen path is multihop, create all missing intermediate requests and replicas.
@@ -214,13 +228,13 @@ def assign_paths_to_transfertool_and_create_hops(
 @transactional_session
 def __assign_paths_to_transfertool_and_create_hops(
         request_id: str,
-        candidate_paths: "Sequence[list[DirectTransferDefinition]]",
+        candidate_paths: "Sequence[list[DirectTransfer]]",
         default_tombstone_delay: int,
-        transfertools: "Optional[list[str]]" = None,
+        transfertools: "Optional[Sequence[str]]" = None,
         *,
-        logger: "Callable" = logging.log,
+        logger: "LoggerFunction" = logging.log,
         session: "Session",
-) -> "tuple[Optional[list[DirectTransferDefinition]], Optional[TransferToolBuilder]]":
+) -> "tuple[Optional[list[DirectTransfer]], Optional[TransferToolBuilder]]":
     """
     Out of a sequence of candidate paths for the given request, pick the first path which can
     be submitted by one of the transfertools.
@@ -231,9 +245,9 @@ def __assign_paths_to_transfertool_and_create_hops(
 
     # Selects the first path which can be submitted using a chain of supported transfertools
     # and for which the creation of intermediate hops (if it is a multihop) works correctly
-    best_path = None
+    best_path = []
     builder_to_use = None
-    hops_to_submit = None
+    hops_to_submit = []
     must_skip_submission = False
 
     tt_assignments = [(transfer_path, __assign_to_transfertool(transfer_path, transfertools, logger=logger))
@@ -290,10 +304,10 @@ def __assign_paths_to_transfertool_and_create_hops(
 
 @transactional_session
 def __create_missing_replicas_and_requests(
-        transfer_path: "list[DirectTransferDefinition]",
+        transfer_path: "list[DirectTransfer]",
         default_tombstone_delay: int,
         *,
-        logger: "Callable",
+        logger: "LoggerFunction",
         session: "Session"
 ) -> tuple[bool, bool]:
     """
@@ -310,7 +324,7 @@ def __create_missing_replicas_and_requests(
         if rws.request_id:
             continue
 
-        tombstone_delay = rws.dest_rse.attributes.get('multihop_tombstone_delay', default_tombstone_delay)
+        tombstone_delay = rws.dest_rse.attributes.get(RseAttr.MULTIHOP_TOMBSTONE_DELAY, default_tombstone_delay)
         try:
             tombstone = tombstone_from_delay(tombstone_delay)
         except ValueError:
@@ -376,7 +390,13 @@ def __create_missing_replicas_and_requests(
     return creation_successful, must_skip_submission
 
 
-def submit_transfer(transfertool_obj, transfers, job_params, timeout=None, logger=logging.log):
+def submit_transfer(
+        transfertool_obj: "Transfertool",
+        transfers: "Sequence[DirectTransfer]",
+        job_params: dict[str, str],
+        timeout: Optional[int] = None,
+        logger: "LoggerFunction" = logging.log
+) -> None:
     """
     Submit a transfer or staging request
 
@@ -396,7 +416,7 @@ def submit_transfer(transfertool_obj, transfers, job_params, timeout=None, logge
             return
         except Exception:
             logger(logging.ERROR, 'Failed to prepare requests %s state to SUBMITTING. Mark it SUBMISSION_FAILED and abort submission.' % [str(t.rws) for t in transfers], exc_info=True)
-            set_request_state(request_id=transfer.rws.request_id, state=RequestState.SUBMISSION_FAILED)
+            transition_request_state(request_id=transfer.rws.request_id, state=RequestState.SUBMISSION_FAILED)
             return
 
     try:
@@ -408,7 +428,13 @@ def submit_transfer(transfertool_obj, transfers, job_params, timeout=None, logge
             _submit_transfers(transfertool_obj, [transfer], job_params, timeout, logger)
 
 
-def _submit_transfers(transfertool_obj, transfers, job_params, timeout=None, logger=logging.log):
+def _submit_transfers(
+        transfertool_obj: "Transfertool",
+        transfers: "Sequence[DirectTransfer]",
+        job_params: dict[str, str],
+        timeout: Optional[int] = None,
+        logger: "LoggerFunction" = logging.log
+) -> None:
     """
     helper function for submit_transfers. Performs the actual submission of one or more transfers.
 
@@ -470,7 +496,13 @@ def _submit_transfers(transfertool_obj, transfers, job_params, timeout=None, log
                     logger(logging.ERROR, 'Failed to cancel transfers %s on %s with error' % (eid, transfertool_obj), exc_info=True)
 
 
-def get_conveyor_rses(rses=None, include_rses=None, exclude_rses=None, vos=None, logger=logging.log):
+def get_conveyor_rses(
+        rses: Optional["Sequence[Mapping[str, Any]]"] = None,
+        include_rses: Optional[str] = None,
+        exclude_rses: Optional[str] = None,
+        vos: Optional["Sequence[str]"] = None,
+        logger: "LoggerFunction" = logging.log
+) -> list["RSESettingsDict"]:
     """
     Get a list of rses for conveyor
 

rucio/daemons/conveyor/finisher.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");
@@ -23,8 +22,7 @@ import logging
 import os
 import re
 import threading
-from types import FrameType
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional
 from urllib.parse import urlparse
 
 from dogpile.cache.api import NoValue
@@ -32,22 +30,27 @@ from sqlalchemy.exc import DatabaseError
 
 import rucio.db.sqla.util
 from rucio.common.cache import make_region_memcached
-from rucio.common.config import config_get_list, config_get_bool
-from rucio.common.exception import DatabaseException, UnsupportedOperation, ReplicaNotFound, RequestNotFound, RSEProtocolNotSupported
+from rucio.common.config import config_get_bool, config_get_list
+from rucio.common.exception import DatabaseException, ReplicaNotFound, RequestNotFound, RSEProtocolNotSupported, UnsupportedOperation
 from rucio.common.logging import setup_logging
 from rucio.common.stopwatch import Stopwatch
-from rucio.common.types import InternalAccount
+from rucio.common.types import InternalAccount, LoggerFunction, RequestDict
 from rucio.common.utils import chunks
-from rucio.core import request as request_core, replica as replica_core
+from rucio.core import replica as replica_core
+from rucio.core import request as request_core
 from rucio.core.monitor import MetricManager
 from rucio.core.rse import list_rses
+from rucio.core.topology import ExpiringObjectCache, Topology
 from rucio.core.transfer import ProtocolFactory
-from rucio.core.topology import Topology, ExpiringObjectCache
-from rucio.daemons.common import db_workqueue, ProducerConsumerDaemon
-from rucio.db.sqla.constants import RequestState, RequestType, ReplicaState, BadFilesStatus
+from rucio.daemons.common import ProducerConsumerDaemon, db_workqueue
+from rucio.db.sqla.constants import MYSQL_LOCK_WAIT_TIMEOUT_EXCEEDED, ORACLE_DEADLOCK_DETECTED_REGEX, ORACLE_RESOURCE_BUSY_REGEX, BadFilesStatus, ReplicaState, RequestState, RequestType
 from rucio.db.sqla.session import transactional_session
 
 if TYPE_CHECKING:
+    from types import FrameType
+
+    from sqlalchemy.orm import Session
+
     from rucio.daemons.common import HeartbeatHandler
 
 GRACEFUL_STOP = threading.Event()
@@ -59,12 +62,12 @@ FAILED_DURING_SUBMISSION_DELAY = datetime.timedelta(minutes=120)
 
 
 def _fetch_requests(
-        db_bulk,
+        db_bulk: int,
         set_last_processed_by: bool,
-        cached_topology,
-        heartbeat_handler,
-        activity,
-):
+        cached_topology: Optional[ExpiringObjectCache],
+        heartbeat_handler: "HeartbeatHandler",
+        activity: str,
+) -> tuple[bool, tuple[list[dict[str, Any]], Topology]]:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
     logger(logging.DEBUG, 'Working on activity %s', activity)
@@ -109,13 +112,13 @@ def _fetch_requests(
 
 
 def _handle_requests(
-        batch,
-        bulk,
-        suspicious_patterns,
-        retry_protocol_mismatches,
+        batch: tuple[list[RequestDict], Topology],
+        bulk: int,
+        suspicious_patterns: list[re.Pattern],
+        retry_protocol_mismatches: bool,
         *,
-        logger=logging.log,
-):
+        logger: LoggerFunction = logging.log,
+) -> None:
     reqs, topology = batch
     if not reqs:
         return
@@ -137,22 +140,22 @@ def _handle_requests(
         logger(logging.DEBUG, 'Finish to update %s finished requests in %s seconds', len(reqs), total_stopwatch.elapsed)
 
     except (DatabaseException, DatabaseError) as error:
-        if re.match('.*ORA-00054.*', error.args[0]) or re.match('.*ORA-00060.*', error.args[0]) or 'ERROR 1205 (HY000)' in error.args[0]:
+        if re.match(ORACLE_RESOURCE_BUSY_REGEX, error.args[0]) or re.match(ORACLE_DEADLOCK_DETECTED_REGEX, error.args[0]) or MYSQL_LOCK_WAIT_TIMEOUT_EXCEEDED in error.args[0]:
             logger(logging.WARNING, 'Lock detected when handling request - skipping: %s', str(error))
         else:
             raise
 
 
 def finisher(
-        once=False,
-        sleep_time=60,
-        activities=None,
-        bulk=100,
-        db_bulk=1000,
-        partition_wait_time=10,
-        cached_topology=None,
-        total_threads=1,
-):
+        once: bool = False,
+        sleep_time: int = 60,
+        activities: Optional[list[str]] = None,
+        bulk: int = 100,
+        db_bulk: int = 1000,
+        partition_wait_time: int = 10,
+        cached_topology: Optional[ExpiringObjectCache] = None,
+        total_threads: int = 1,
+) -> None:
     """
     Main loop to update the replicas and rules based on finished requests.
     """
@@ -176,7 +179,11 @@ def finisher(
         sleep_time=sleep_time,
         activities=activities,
     )
-    def _db_producer(*, activity: str, heartbeat_handler: "HeartbeatHandler"):
+    def _db_producer(
+        *,
+        activity: str,
+        heartbeat_handler: "HeartbeatHandler"
+    ) -> tuple[bool, tuple[list[dict[str, Any]], Topology]]:
         return _fetch_requests(
             db_bulk=db_bulk,
             cached_topology=cached_topology,
@@ -185,7 +192,7 @@ def finisher(
             heartbeat_handler=heartbeat_handler,
         )
 
-    def _consumer(batch):
+    def _consumer(batch: tuple[list[RequestDict], Topology]) -> None:
         return _handle_requests(
             batch=batch,
             bulk=bulk,
@@ -200,7 +207,7 @@ def finisher(
     ).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.
     """
@@ -208,9 +215,16 @@ def stop(signum: Optional[int] = None, frame: Optional[FrameType] = None) -> Non
     GRACEFUL_STOP.set()
 
 
-def run(once=False, total_threads=1, sleep_time=60, activities=None, bulk=100, db_bulk=1000):
+def run(
+        once: bool = False,
+        total_threads: int = 1,
+        sleep_time: int = 60,
+        activities: Optional[list[str]] = None,
+        bulk: int = 100,
+        db_bulk: int = 1000
+) -> None:
     """
-    Starts up the conveyer threads.
+    Starts up the conveyor threads.
     """
     setup_logging(process_name=DAEMON_NAME)
 
@@ -229,7 +243,13 @@ def run(once=False, total_threads=1, sleep_time=60, activities=None, bulk=100, d
     )
 
 
-def _finish_requests(topology: "Topology", reqs, suspicious_patterns, retry_protocol_mismatches, logger=logging.log):
+def _finish_requests(
+        topology: Topology,
+        reqs: list[RequestDict],
+        suspicious_patterns: list[re.Pattern],
+        retry_protocol_mismatches: bool,
+        logger: LoggerFunction = logging.log
+) -> None:
     """
     Used by finisher to handle terminated requests,
 
@@ -325,11 +345,11 @@ def _finish_requests(topology: "Topology", reqs, suspicious_patterns, retry_prot
     __handle_terminated_replicas(replicas, logger=logger)
 
 
-def __get_undeterministic_rses(logger=logging.log):
+def __get_undeterministic_rses(logger: LoggerFunction = logging.log) -> list[str]:
     """
     Get the undeterministic rses from the database
 
-    :returns:  List of undeterministc rses
+    :returns:  List of undeterministic rses
     """
     key = 'undeterministic_rses'
     result = REGION.get(key)
@@ -343,7 +363,11 @@ def __get_undeterministic_rses(logger=logging.log):
     return result
 
 
-def __check_suspicious_files(req, suspicious_patterns, logger=logging.log):
+def __check_suspicious_files(
+        req: RequestDict,
+        suspicious_patterns: list[re.Pattern],
+        logger: LoggerFunction = logging.log
+) -> bool:
     """
     Check suspicious files when a transfer failed.
 
@@ -376,7 +400,10 @@ def __check_suspicious_files(req, suspicious_patterns, logger=logging.log):
     return is_suspicious
 
 
-def __handle_terminated_replicas(replicas, logger=logging.log):
+def __handle_terminated_replicas(
+        replicas: dict[str, dict[str, list[dict[str, Any]]]],
+        logger: LoggerFunction = logging.log
+) -> None:
     """
     Used by finisher to handle available and unavailable replicas.
 
@@ -394,14 +421,14 @@ def __handle_terminated_replicas(replicas, logger=logging.log):
                     try:
                         __update_replica(replica, logger=logger)
                     except (DatabaseException, DatabaseError) as error:
-                        if re.match('.*ORA-00054.*', error.args[0]) or re.match('.*ORA-00060.*', error.args[0]) or 'ERROR 1205 (HY000)' in error.args[0]:
+                        if re.match(ORACLE_RESOURCE_BUSY_REGEX, error.args[0]) or re.match(ORACLE_DEADLOCK_DETECTED_REGEX, error.args[0]) or MYSQL_LOCK_WAIT_TIMEOUT_EXCEEDED in error.args[0]:
                             logger(logging.WARNING, "Locks detected when handling replica %s:%s at RSE %s", replica['scope'], replica['name'], replica['rse_id'])
                         else:
                             logger(logging.ERROR, "Could not finish handling replicas %s:%s at RSE %s", replica['scope'], replica['name'], replica['rse_id'], exc_info=True)
                     except Exception as error:
                         logger(logging.ERROR, "Something unexpected happened when updating replica state for transfer %s:%s at %s (%s)", replica['scope'], replica['name'], replica['rse_id'], str(error))
             except (DatabaseException, DatabaseError) as error:
-                if re.match('.*ORA-00054.*', error.args[0]) or re.match('.*ORA-00060.*', error.args[0]) or 'ERROR 1205 (HY000)' in error.args[0]:
+                if re.match(ORACLE_RESOURCE_BUSY_REGEX, error.args[0]) or re.match(ORACLE_DEADLOCK_DETECTED_REGEX, error.args[0]) or MYSQL_LOCK_WAIT_TIMEOUT_EXCEEDED in error.args[0]:
                     logger(logging.WARNING, "Locks detected when handling replicas on %s rule %s, update updated time.", req_type, rule_id)
                     try:
                         request_core.touch_requests_by_rule(rule_id)
@@ -414,9 +441,14 @@ def __handle_terminated_replicas(replicas, logger=logging.log):
 
 
 @transactional_session
-def __update_bulk_replicas(replicas, *, session, logger=logging.log):
+def __update_bulk_replicas(
+    replicas: list[dict[str, Any]],
+    *,
+    session: "Session",
+    logger: LoggerFunction = logging.log
+) -> Literal[True]:
     """
-    Used by finisher to handle available and unavailable replicas blongs to same rule in bulk way.
+    Used by finisher to handle available and unavailable replicas belongs to same rule in bulk way.
 
     :param replicas:              List of replicas.
     :param session:               The database session to use.
@@ -436,7 +468,12 @@ def __update_bulk_replicas(replicas, *, session, logger=logging.log):
 
 
 @transactional_session
-def __update_replica(replica, *, session, logger=logging.log):
+def __update_replica(
+    replica: dict[str, Any],
+    *,
+    session: "Session",
+    logger: LoggerFunction = logging.log
+) -> None:
     """
     Used by finisher to update a replica to a finished state.