rucio 35.7.0__py3-none-any.whl → 37.0.0__py3-none-any.whl

rucio/daemons/conveyor/poller.py

@@ -23,7 +23,6 @@ import logging
 import re
 import threading
 import time
-from collections.abc import Mapping, Sequence
 from itertools import groupby
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -31,11 +30,10 @@ from requests.exceptions import RequestException
 from sqlalchemy.exc import DatabaseError
 
 import rucio.db.sqla.util
-from rucio.common.config import config_get, config_get_bool
+from rucio.common.config import config_get, config_get_bool, config_get_float
 from rucio.common.exception import DatabaseException, TransferToolTimeout, TransferToolWrongAnswer
 from rucio.common.logging import setup_logging
 from rucio.common.stopwatch import Stopwatch
-from rucio.common.types import InternalAccount, LoggerFunction
 from rucio.common.utils import dict_chunks
 from rucio.core import request as request_core
 from rucio.core import transfer as transfer_core
@@ -44,12 +42,14 @@ from rucio.core.topology import ExpiringObjectCache, Topology
 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, RequestState, RequestType
 from rucio.transfertool.fts3 import FTS3Transfertool
-from rucio.transfertool.transfertool import Transfertool
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
     from types import FrameType
 
+    from rucio.common.types import LoggerFunction
     from rucio.daemons.common import HeartbeatHandler
+    from rucio.transfertool.transfertool import Transfertool
 
 GRACEFUL_STOP = threading.Event()
 METRICS = MetricManager(module=__name__)
@@ -62,7 +62,7 @@ FILTER_TRANSFERTOOL = config_get('conveyor', 'filter_transfertool', False, None)
 def _fetch_requests(
         db_bulk: int,
         older_than: int,
-        activity_shares: Optional[Mapping[str, float]],
+        activity_shares: Optional['Mapping[str, float]'],
         transfertool: Optional[str],
         filter_transfertool: Optional[str],
         cached_topology: Optional[ExpiringObjectCache],
@@ -116,9 +116,9 @@ def _handle_requests(
         timeout: Optional[int],
         transfertool: str,
         transfer_stats_manager: request_core.TransferStatsManager,
-        oidc_account: Optional[str],
+        oidc_support: bool,
         *,
-        logger: LoggerFunction = logging.log,
+        logger: "LoggerFunction" = logging.log,
 ) -> None:
     transfs.sort(key=lambda t: (t['external_host'] or '',
                                 t['scope'].vo if multi_vo else '',
@@ -136,15 +136,9 @@ def _handle_requests(
 
                 transfertool_kwargs = {}
                 if transfertool_cls.external_name == FTS3Transfertool.external_name:
-                    account = None
-                    if oidc_account:
-                        if vo:
-                            account = InternalAccount(oidc_account, vo=vo)
-                        else:
-                            account = InternalAccount(oidc_account)
                     transfertool_kwargs.update({
                         'vo': vo,
-                        'oidc_account': account,
+                        'oidc_support': oidc_support,
                     })
 
                 transfertool_obj = transfertool_cls(external_host=external_host, **transfertool_kwargs)
@@ -161,12 +155,12 @@ def _handle_requests(
 
 def poller(
         once: bool = False,
-        activities: Optional[Sequence[str]] = None,
+        activities: Optional['Sequence[str]'] = None,
         sleep_time: int = 60,
         fts_bulk: int = 100,
         db_bulk: int = 1000,
         older_than: int = 60,
-        activity_shares: Optional[Mapping[str, float]] = None,
+        activity_shares: Optional['Mapping[str, float]'] = None,
         partition_wait_time: int = 10,
         transfertool: Optional[str] = TRANSFER_TOOL,
         filter_transfertool: Optional[str] = FILTER_TRANSFERTOOL,
@@ -176,13 +170,9 @@ def poller(
     """
     Main loop to check the status of a transfer primitive with a transfertool.
     """
-
-    timeout = config_get('conveyor', 'poll_timeout', default=None, raise_exception=False)
-    if timeout:
-        timeout = float(timeout)
-
+    timeout = config_get_float('conveyor', 'poll_timeout', default=None, raise_exception=False)
     multi_vo = config_get_bool('common', 'multi_vo', False, None)
-    oidc_account = config_get('conveyor', 'poller_oidc_account', False, None)
+    oidc_support = config_get_bool('conveyor', 'poller_oidc_support', default=False, raise_exception=False)
 
     executable = DAEMON_NAME
 
@@ -227,7 +217,7 @@ def poller(
             fts_bulk=fts_bulk,
             multi_vo=multi_vo,
             timeout=timeout,  # type: ignore (unclear if timeout is meant to be int or float)
-            oidc_account=oidc_account,
+            oidc_support=oidc_support,
             transfertool=transfertool,  # type: ignore (transfertool is not None)
             transfer_stats_manager=transfer_stats_manager,
         )
@@ -251,7 +241,7 @@ def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> N
 def run(
         once: bool = False,
         sleep_time: int = 60,
-        activities: Optional[Sequence[str]] = None,
+        activities: Optional['Sequence[str]'] = None,
         fts_bulk: int = 100,
         db_bulk: int = 1000,
         older_than: int = 60,
@@ -301,8 +291,8 @@ def run(
 
 
 def poll_transfers(
-        transfertool_obj: Transfertool,
-        transfers_by_eid: Mapping[str, Mapping[str, Any]],
+        transfertool_obj: 'Transfertool',
+        transfers_by_eid: 'Mapping[str, Mapping[str, Any]]',
         transfer_stats_manager: request_core.TransferStatsManager,
         timeout: "Optional[int]" = None,
         logger: "LoggerFunction" = logging.log
@@ -328,8 +318,8 @@ def poll_transfers(
 
 
 def _poll_transfers(
-        transfertool_obj: Transfertool,
-        transfers_by_eid: Mapping[str, Mapping[str, Any]],
+        transfertool_obj: 'Transfertool',
+        transfers_by_eid: 'Mapping[str, Mapping[str, Any]]',
         transfer_stats_manager: request_core.TransferStatsManager,
         timeout: "Optional[int]" = None,
         logger: "LoggerFunction" = logging.log

rucio/daemons/conveyor/receiver.py

@@ -28,7 +28,7 @@ import stomp
 
 import rucio.db.sqla.util
 from rucio.common import exception
-from rucio.common.config import config_get, config_get_bool, config_get_int
+from rucio.common.config import config_get, config_get_bool, config_get_int, config_get_list
 from rucio.common.logging import setup_logging
 from rucio.common.policy import get_policy
 from rucio.core import request as request_core
@@ -134,7 +134,7 @@ def receiver(
     brokers_alias = []
     brokers_resolved = []
     try:
-        brokers_alias = [b.strip() for b in config_get('messaging-fts3', 'brokers').split(',')]
+        brokers_alias = config_get_list('messaging-fts3', 'brokers')
     except Exception:
         raise Exception('Could not load brokers from configuration')
 

rucio/daemons/conveyor/stager.py

@@ -36,6 +36,7 @@ if TYPE_CHECKING:
 
     from rucio.common.types import RSESettingsDict
 
+
 METRICS = MetricManager(module=__name__)
 GRACEFUL_STOP = threading.Event()
 DAEMON_NAME = 'conveyor-stager'

rucio/daemons/conveyor/submitter.py

@@ -17,7 +17,6 @@ Conveyor transfer submitter is a daemon to manage non-tape file transfers.
 """
 import logging
 import threading
-from collections.abc import Mapping
 from typing import TYPE_CHECKING, Optional
 
 import rucio.db.sqla.util
@@ -37,6 +36,7 @@ from rucio.transfertool.fts3 import FTS3Transfertool
 from rucio.transfertool.globus import GlobusTransferTool
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
     from types import FrameType
 
     from rucio.common.types import LoggerFunction, RSESettingsDict
@@ -114,7 +114,7 @@ def _fetch_requests(
 
 
 def _handle_requests(
-        batch: tuple[Topology, Mapping[str, RequestWithSources]],
+        batch: tuple[Topology, 'Mapping[str, RequestWithSources]'],
         *,
         transfertools: list[str],
         schemes: Optional[list[str]],
@@ -301,7 +301,7 @@ def submitter(
             heartbeat_handler=heartbeat_handler,
         )
 
-    def _consumer(batch: tuple[Topology, Mapping[str, RequestWithSources]]) -> None:
+    def _consumer(batch: tuple[Topology, 'Mapping[str, RequestWithSources]']) -> None:
         return _handle_requests(
             batch,
             transfertools=transfertools,

rucio/daemons/hermes/hermes.py

@@ -114,10 +114,7 @@ def setup_activemq(
     brokers_alias = []
     brokers_resolved = []
     try:
-        brokers_alias = [
-            broker.strip()
-            for broker in config_get("messaging-hermes", "brokers").split(",")
-        ]
+        brokers_alias = config_get_list("messaging-hermes", "brokers")
     except:
         raise Exception("Could not load brokers from configuration")
 
@@ -408,7 +405,7 @@ def submit_to_elastic(
 
 def aggregate_to_influx(
     messages: "Iterable[dict[str, Any]]",
-    bin_size: int,
+    bin_size: str,
     endpoint: str,
     logger: "LoggerFunction"
 ) -> int:
@@ -517,6 +514,69 @@ def aggregate_to_influx(
     return 204
 
 
+def build_message_dict(
+        bulk: int,
+        thread: int,
+        total_threads: int,
+        message_dict: dict[str, list[dict[str, Any]]],
+        logger: "LoggerFunction",
+        service: Optional[str] = None,
+) -> None:
+    """
+    Retrieves messages from the database and builds a dictionary with the keys being the services, and the values a list of the messages (built up of dictionary / json information)
+
+    :param bulk:               Integer for number of messages to retrieve.
+    :param thread:             Passed to thread in retrieve_messages for Identifier of the caller thread as an integer.
+    :param total_threads:      Passed to total_threads for Maximum number of threads as an integer.
+    :param message_dict:       Either empty dictionary to be built, or build upon when using query_by_service.
+    :param logger:             The logger object.
+    :param service:            When passed, only returns messages table for this specific service.
+
+    :returns:                  None, but builds on the dictionary message_dict passed to this fuction (for when querying multiple services).
+    """
+    start_time = time.time()
+    messages = retrieve_messages(
+        bulk=bulk,
+        old_mode=False,
+        thread=thread,
+        total_threads=total_threads,
+        service_filter=service,
+    )
+
+    if messages:
+        if service is not None:
+            # query_by_service dictionary build behaviour
+            message_dict[service] = messages.copy()
+            logger(
+                logging.DEBUG,
+                "Retrieved %i messages retrieved in %s seconds for %s service.",
+                len(messages),
+                time.time() - start_time,
+                service,
+            )
+
+        else:
+            # default dictionary build behaviour
+            for message in messages:
+                service = message["services"]
+                if service is not None:
+                    if service not in message_dict:
+                        message_dict[service] = []
+                    message_dict[service].append(message)
+        logger(
+            logging.DEBUG,
+            "Retrieved %i messages retrieved in %s seconds",
+            len(messages),
+            time.time() - start_time,
+        )
+    else:
+        logger(
+            logging.INFO,
+            "No messages retrieved in %s seconds",
+            time.time() - start_time,
+        )
+
+
 def hermes(once: bool = False, bulk: int = 1000, sleep_time: int = 10) -> None:
     """
     Creates a Hermes Worker that can submit messages to different services (InfluXDB, ElasticSearch, ActiveMQ)
@@ -571,7 +631,6 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                 )
         except Exception as err:
             logger(logging.ERROR, str(err))
-    conns = None
     if "activemq" in services_list:
         try:
             conns, destination, username, password, use_ssl = setup_activemq(logger)
@@ -585,30 +644,31 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
 
     worker_number, total_workers, logger = heartbeat_handler.live()
     message_dict = {}
-    message_ids = []
-    start_time = time.time()
-    messages = retrieve_messages(
-        bulk=bulk,
-        old_mode=False,
-        thread=worker_number,
-        total_threads=total_workers,
-    )
-
-    to_delete = []
-    if messages:
-        for message in messages:
-            service = message["services"]
-            if service not in message_dict:
-                message_dict[service] = []
-            message_dict[service].append(message)
-            message_ids.append(message["id"])
-        logger(
-            logging.DEBUG,
-            "Retrieved %i messages retrieved in %s seconds",
-            len(messages),
-            time.time() - start_time,
+    query_by_service = config_get_bool("hermes", "query_by_service", default=False)
+
+    # query_by_service is a toggleable behaviour switch between collecting bulk number of messages across all services when false, to collecting bulk messages from each service when true.
+    if query_by_service:
+        for service in services_list:
+            build_message_dict(
+                bulk=bulk,
+                thread=worker_number,
+                total_threads=total_workers,
+                message_dict=message_dict,
+                logger=logger,
+                service=service,
+            )
+    else:
+        build_message_dict(
+            bulk=bulk,
+            thread=worker_number,
+            total_threads=total_workers,
+            message_dict=message_dict,
+            logger=logger
         )
 
+    if message_dict:
+        to_delete = []
+
         if "influx" in message_dict and influx_endpoint:
             # For influxDB, bulk submission, either everything succeeds or fails
             t_time = time.time()
@@ -685,12 +745,12 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
             except Exception as error:
                 logger(logging.ERROR, "Error sending email : %s", str(error))
 
-        if "activemq" in message_dict and conns:
+        if "activemq" in message_dict:
             t_time = time.time()
             try:
                 messages_sent = deliver_to_activemq(
                     messages=message_dict["activemq"],
-                    conns=conns,
+                    conns=conns,  # type: ignore (argument could be None)
                     destination=destination,  # type: ignore (argument could be None)
                     username=username,  # type: ignore (argument could be None)
                     password=password,  # type: ignore (argument could be None)
@@ -717,6 +777,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
             "updated_at": message["created_at"],
             "payload": str(message["payload"]),
             "event_type": message["event_type"],
+            "services": message["services"]
         }
         for message in to_delete
     ]

rucio/daemons/judge/evaluator.py

@@ -91,9 +91,9 @@ def run_once(
     dids = get_updated_dids(total_workers=total_workers,
                             worker_number=worker_number,
                             limit=did_limit,
-                            blocked_dids=[(InternalScope(key[0], fromExternal=False), key[1]) for key in paused_dids])
+                            blocked_dids=[(InternalScope(key[0], from_external=False), key[1]) for key in paused_dids])
     logger(logging.DEBUG, 'index query time %f fetch size is %d (%d blocked)', time.time() - start, len(dids),
-           len([(InternalScope(key[0], fromExternal=False), key[1]) for key in paused_dids]))
+           len([(InternalScope(key[0], from_external=False), key[1]) for key in paused_dids]))
 
     # If the list is empty, sent the worker to sleep
     if not dids:

rucio/daemons/oauthmanager/oauthmanager.py

@@ -53,7 +53,7 @@ graceful_stop = threading.Event()
 DAEMON_NAME = 'oauth-manager'
 
 
-def OAuthManager(once: bool = False, max_rows: int = 100, sleep_time: int = 300) -> None:
+def oauth_manager(once: bool = False, max_rows: int = 100, sleep_time: int = 300) -> None:
     """
     Main loop to delete all expired tokens, refresh tokens eligible
     for refresh and delete all expired OAuth session parameters.
@@ -178,10 +178,10 @@ def run(once: bool = False, threads: int = 1, max_rows: int = 100, sleep_time: i
         raise DatabaseException('Database was not updated, daemon won\'t start')
 
     if once:
-        OAuthManager(once, max_rows, sleep_time)
+        oauth_manager(once, max_rows, sleep_time)
     else:
         logging.info('OAuth Manager starting %s threads', str(threads))
-        threads = [threading.Thread(target=OAuthManager,
+        threads = [threading.Thread(target=oauth_manager,
                                     kwargs={'once': once,
                                             'max_rows': max_rows,
                                             'sleep_time': sleep_time}) for i in range(0, threads)]

rucio/daemons/reaper/dark_reaper.py

@@ -44,6 +44,7 @@ if TYPE_CHECKING:
     from types import FrameType
     from typing import Optional
 
+    from rucio.common.types import LFNDict
     from rucio.daemons.common import HeartbeatHandler
 
 logging.getLogger("requests").setLevel(logging.CRITICAL)
@@ -120,10 +121,13 @@ def run_once(
                 if replica['scope']:
                     scope = replica['scope'].external
                 try:
+                    lfn: "LFNDict" = {
+                        'scope': scope,
+                        'name': replica['name'],
+                        'path': replica['path']
+                    }
                     pfn = str(list(rsemgr.lfns2pfns(rse_settings=rse_info,
-                                                    lfns=[{'scope': scope,
-                                                           'name': replica['name'],
-                                                           'path': replica['path']}],
+                                                    lfns=[lfn],
                                                     operation='delete',
                                                     scheme=scheme).values())[0])
                     logger(logging.INFO, 'Deletion ATTEMPT of %s:%s as %s on %s', scope, replica['name'], pfn, rse)

rucio/daemons/reaper/reaper.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''
+"""
 Reaper is a daemon to manage file deletion.
-'''
+"""
 
 import concurrent.futures.thread  # noqa (https://github.com/rucio/rucio/issues/6548)
 
@@ -33,7 +33,7 @@ from dogpile.cache.api import NoValue
 from sqlalchemy.exc import DatabaseError, IntegrityError
 
 import rucio.db.sqla.util
-from rucio.common.cache import make_region_memcached
+from rucio.common.cache import MemcacheRegion
 from rucio.common.config import config_get_bool, config_get_int
 from rucio.common.constants import RseAttr
 from rucio.common.exception import DatabaseException, ReplicaNotFound, ReplicaUnAvailable, ResourceTemporaryUnavailable, RSEAccessDenied, RSENotFound, RSEProtocolNotSupported, ServiceUnavailable, SourceNotFound, VONotFound
@@ -57,12 +57,12 @@ if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
     from types import FrameType
 
-    from rucio.common.types import LoggerFunction
+    from rucio.common.types import LFNDict, LoggerFunction
     from rucio.daemons.common import HeartbeatHandler
 
 GRACEFUL_STOP = threading.Event()
 METRICS = MetricManager(module=__name__)
-REGION = make_region_memcached(expiration_time=600)
+REGION = MemcacheRegion(expiration_time=600)
 DAEMON_NAME = 'reaper'
 
 EXCLUDED_RSE_GAUGE = METRICS.gauge('excluded_rses.{rse}', documentation='Temporarly excluded RSEs')
@@ -474,7 +474,7 @@ def run_once(
 
     rses_to_process = get_rses_to_process(rses, include_rses, exclude_rses, vos)
     if not rses_to_process:
-        logger(logging.ERROR, 'Reaper: No RSEs found. Will sleep for 30 seconds')
+        logger(logging.WARNING, 'Reaper: No RSEs found, sleeping')
         return must_sleep
     else:
         rses_to_process = [RseData(id_=rse['id'], name=rse['rse'], columns=rse) for rse in rses_to_process]
@@ -632,8 +632,13 @@ def _run_once(
                 del_start_time = time.time()
                 for replica in file_replicas:
                     try:
+                        lfn: "LFNDict" = {
+                            'scope': replica['scope'].external,
+                            'name': replica['name'],
+                            'path': replica['path']
+                        }
                         replica['pfn'] = str(list(rsemgr.lfns2pfns(rse_settings=rse.info,
-                                                                   lfns=[{'scope': replica['scope'].external, 'name': replica['name'], 'path': replica['path']}],
+                                                                   lfns=[lfn],
                                                                    operation='delete', scheme=scheme).values())[0])
                     except (ReplicaUnAvailable, ReplicaNotFound) as error:
                         logger(logging.WARNING, 'Failed get pfn UNAVAILABLE replica %s:%s on %s with error %s', replica['scope'], replica['name'], rse.name, str(error))
@@ -690,7 +695,6 @@ def run(
 
     :param threads:                The total number of workers.
     :param chunk_size:             The size of chunk for deletion.
-    :param threads_per_worker:     Total number of threads created by each worker.
     :param once:                   If True, only runs one iteration of the main loop.
     :param greedy:                 If True, delete right away replicas with tombstone.
     :param rses:                   List of RSEs the reaper should work against.
@@ -711,14 +715,6 @@ def run(
     if rucio.db.sqla.util.is_old_db():
         raise DatabaseException('Database was not updated, daemon won\'t start')
 
-    logging.log(logging.INFO, 'main: starting processes')
-    rses_to_process = get_rses_to_process(rses, include_rses, exclude_rses, vos)
-    if not rses_to_process:
-        logging.log(logging.ERROR, 'Reaper: No RSEs found. Exiting.')
-        return
-
-    logging.log(logging.INFO, 'Reaper: This instance will work on RSEs: %s', ', '.join([rse['rse'] for rse in rses_to_process]))
-
     logging.log(logging.INFO, 'starting reaper threads')
     threads_list = [threading.Thread(target=reaper, kwargs={'once': once,
                                                             'rses': rses,

rucio/daemons/rsedecommissioner/config.py

@@ -75,7 +75,7 @@ def set_status(
     :param rse_id: RSE ID.
     :param status: RSE decommissioning status.
     """
-    config = attr_to_config(get_rse_attribute(rse_id, RseAttr.DECOMMISSION))
+    config = attr_to_config(get_rse_attribute(rse_id, RseAttr.DECOMMISSION))  # type: ignore (get_rse_attribute could return None)
     config['status'] = status
     # add_rse_attribute can handle updating existing entries too
     add_rse_attribute(rse_id, RseAttr.DECOMMISSION, config_to_attr(config))

rucio/daemons/rsedecommissioner/profiles/generic.py

@@ -14,7 +14,6 @@
 
 """Generic decommissioning profiles."""
 import logging
-from collections.abc import Callable, Iterable
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
@@ -32,6 +31,8 @@ from rucio.db.sqla.constants import ReplicaState
 from .types import DecommissioningProfile, HandlerOutcome
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from rucio.common.types import LoggerFunction
 
 
@@ -137,7 +138,7 @@ def _generic_discover(
     rse: dict[str, Any],
     *,
     logger: "LoggerFunction" = logging.log
-) -> Iterable[dict[str, Any]]:
+) -> 'Iterable[dict[str, Any]]':
     """Discoverer function that calls the listing function from core.rule.
 
     :param rse: RSE table entry as a dictionary.
@@ -186,7 +187,7 @@ def _generic_finalize(
 
 def _process_replicas_with_no_locks(
     rse: dict[str, Any],
-    replicas: Iterable[dict[str, Any]],
+    replicas: 'Iterable[dict[str, Any]]',
     limit: int = 0,
     *,
     logger: "LoggerFunction" = logging.log,
@@ -382,7 +383,7 @@ def _call_for_attention(
     rule: dict[str, Any],
     rse: dict[str, Any],
     *,
-    logger: Callable[..., None] = logging.log
+    logger: "LoggerFunction" = logging.log
 ) -> HandlerOutcome:
     return HandlerOutcome.NEED_ATTENTION
 

rucio/daemons/rsedecommissioner/profiles/types.py

@@ -14,12 +14,13 @@
 
 """Types used for profile definitions."""
 import logging
-from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
     from rucio.common.types import LoggerFunction
 
 
@@ -42,10 +43,10 @@ class DecommissioningProfile:
     """
 
     rse: dict[str, Any]
-    initializer: Callable[..., None]
-    discoverer: Callable[..., Iterable[dict[str, Any]]]
-    handlers: list[tuple[Callable[..., bool], Callable[..., HandlerOutcome]]]
-    finalizer: Callable[..., bool]
+    initializer: "Callable[..., None]"
+    discoverer: "Callable[..., Iterable[dict[str, Any]]]"
+    handlers: list[tuple["Callable[..., bool]", "Callable[..., HandlerOutcome]"]]
+    finalizer: "Callable[..., bool]"
 
     def initialize(
         self,
@@ -59,7 +60,7 @@ class DecommissioningProfile:
         self,
         *,
         logger: "LoggerFunction" = logging.log
-    ) -> Iterable[dict[str, Any]]:
+    ) -> 'Iterable[dict[str, Any]]':
         """Call the discoverer."""
         return self.discoverer(self.rse, logger=logger)
 

rucio/daemons/rsedecommissioner/rse_decommissioner.py

@@ -98,7 +98,7 @@ def run_once(
         # Get the decommission attribute (encodes the decommissioning config)
         attr = get_rse_attribute(rse['id'], RseAttr.DECOMMISSION)
         try:
-            config = attr_to_config(attr)
+            config = attr_to_config(attr)  # type: ignore (attr could be None)
         except InvalidStatusName:
             logger(logging.ERROR, 'RSE %s has an invalid decommissioning status',
                    rse['rse'])

rucio/daemons/storage/consistency/actions.py

@@ -35,7 +35,7 @@ from sqlalchemy.orm.exc import FlushError
 
 from rucio.common import exception
 from rucio.common.logging import formatted_logger, setup_logging
-from rucio.common.types import InternalAccount, InternalScope
+from rucio.common.types import InternalAccount, InternalScope, LFNDict
 from rucio.common.utils import daemon_sleep
 from rucio.core.heartbeat import die, live, sanity_check
 from rucio.core.monitor import MetricManager
@@ -443,16 +443,18 @@ def process_dark_files(
                 logger(logging.INFO, 'Processing a dark file:\n RSE %s  Scope: %s  Name: %s'
                        % (rse, scope, name))
                 rse_id = get_rse_id(rse=rse)
-                Intscope = InternalScope(scope=scope, vo=issuer.vo)
-                lfns = [{'scope': scope, 'name': name}]
-
+                internal_scope = InternalScope(scope=scope, vo=issuer.vo)
+                lfn: "LFNDict" = {
+                    'scope': scope,
+                    'name': name,
+                }
                 attributes = get_rse_info(rse=rse)
-                pfns = lfns2pfns(rse_settings=attributes, lfns=lfns, operation='delete')
+                pfns = lfns2pfns(rse_settings=attributes, lfns=[lfn], operation='delete')
                 pfn_key = scope + ':' + name
                 url = pfns[pfn_key]
                 urls = [url]
                 paths = parse_pfns(attributes, urls, operation='delete')
-                replicas = [{'scope': Intscope, 'rse_id': rse_id, 'name': name,
+                replicas = [{'scope': internal_scope, 'rse_id': rse_id, 'name': name,
                              'path': paths[url]['path'] + paths[url]['name']}]
                 add_quarantined_replicas(rse_id, replicas, session=None)
                 deleted_files += 1