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

rucio/daemons/oauthmanager/oauthmanager.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,7 +13,7 @@
 # limitations under the License.
 
 """
-OAuth Manager is a daemon which is reponsible for:
+OAuth Manager is a daemon which is responsible for:
 - deletion of expired access tokens (in case there is a valid refresh token,
   expired access tokens will be kept until refresh_token expires as well.)
 - deletion of expired OAuth session parameters
@@ -42,8 +41,8 @@ from rucio.common.stopwatch import Stopwatch
 from rucio.core.authentication import delete_expired_tokens
 from rucio.core.monitor import MetricManager
 from rucio.core.oidc import delete_expired_oauthrequests, refresh_jwt_tokens
-from rucio.daemons.common import HeartbeatHandler
-from rucio.daemons.common import run_daemon
+from rucio.daemons.common import HeartbeatHandler, run_daemon
+from rucio.db.sqla.constants import ORACLE_CONNECTION_LOST_CONTACT_REGEX
 
 if TYPE_CHECKING:
     from types import FrameType
@@ -107,7 +106,7 @@ def run_once(heartbeat_handler: HeartbeatHandler, max_rows: int, sleep_time: int
         if match('.*QueuePool.*', str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
-        elif match('.*ORA-03135.*', str(err.args[0])):
+        elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
         else:
@@ -115,7 +114,7 @@ def run_once(heartbeat_handler: HeartbeatHandler, max_rows: int, sleep_time: int
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
 
     try:
-        # waiting 1 sec as DBs does not store milisecond and tokens
+        # waiting 1 sec as DBs does not store millisecond and tokens
         # eligible for deletion after refresh might not get deleted otherwise
         graceful_stop.wait(1)
 
@@ -134,7 +133,7 @@ def run_once(heartbeat_handler: HeartbeatHandler, max_rows: int, sleep_time: int
         if match('.*QueuePool.*', str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
-        elif match('.*ORA-03135.*', str(err.args[0])):
+        elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
         else:
@@ -157,7 +156,7 @@ def run_once(heartbeat_handler: HeartbeatHandler, max_rows: int, sleep_time: int
         if match('.*QueuePool.*', str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
-        elif match('.*ORA-03135.*', str(err.args[0])):
+        elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(err.args[0])):
             logger(logging.WARNING, traceback.format_exc())
             METRICS.counter('exceptions.{exception}').labels(exception=err.__class__.__name__).inc()
         else:

rucio/daemons/reaper/__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/reaper/dark_reaper.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");
@@ -30,15 +29,11 @@ import rucio.core.rse as rse_core
 import rucio.db.sqla.util
 from rucio.common import exception
 from rucio.common.config import config_get_bool
-from rucio.common.exception import (SourceNotFound, ServiceUnavailable,
-                                    RSEAccessDenied, ResourceTemporaryUnavailable,
-                                    RSENotFound, VONotFound)
+from rucio.common.exception import ResourceTemporaryUnavailable, RSEAccessDenied, RSENotFound, ServiceUnavailable, SourceNotFound, VONotFound
 from rucio.common.logging import setup_logging
 from rucio.core.message import add_message
 from rucio.core.monitor import MetricManager
-from rucio.core.quarantined_replica import (list_quarantined_replicas,
-                                            delete_quarantined_replicas,
-                                            list_rses_with_quarantined_replicas)
+from rucio.core.quarantined_replica import delete_quarantined_replicas, list_quarantined_replicas, list_rses_with_quarantined_replicas
 from rucio.core.rse_expression_parser import parse_expression
 from rucio.core.vo import list_vos
 from rucio.daemons.common import run_daemon
@@ -193,8 +188,18 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
     GRACEFUL_STOP.set()
 
 
-def run(total_workers=1, chunk_size=100, once=False, rses=[], scheme=None,
-        exclude_rses=None, include_rses=None, vos=None, delay_seconds=0, sleep_time=300):
+def run(
+    total_workers: int = 1,
+    chunk_size: int = 100,
+    once: bool = False,
+    rses: "Optional[list[str]]" = None,
+    scheme: "Optional[str]" = None,
+    exclude_rses: "Optional[str]" = None,
+    include_rses: "Optional[str]" = None,
+    vos: "Optional[list[str]]" = None,
+    delay_seconds: int = 0,
+    sleep_time: int = 300
+) -> None:
     """
     Starts up the reaper threads.
 
@@ -208,6 +213,7 @@ def run(total_workers=1, chunk_size=100, once=False, rses=[], scheme=None,
     :param vos: VOs on which to look for RSEs. Only used in multi-VO mode.
                 If None, we either use all VOs if run from "def", or the current VO otherwise.
     """
+    rses = rses or []
     setup_logging(process_name=DAEMON_NAME)
 
     if rucio.db.sqla.util.is_old_db():

rucio/daemons/reaper/reaper.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,6 +16,8 @@
 Reaper is a daemon to manage file deletion.
 '''
 
+import concurrent.futures.thread  # noqa (https://github.com/rucio/rucio/issues/6548)
+
 import functools
 import logging
 import random
@@ -25,30 +26,27 @@ import time
 import traceback
 from configparser import NoOptionError, NoSectionError
 from datetime import datetime, timedelta
-from typing import TYPE_CHECKING
+from math import log2
+from typing import TYPE_CHECKING, Any, Optional
 
 from dogpile.cache.api import NoValue
-from math import log2
 from sqlalchemy.exc import DatabaseError, IntegrityError
 
 import rucio.db.sqla.util
 from rucio.common.cache import make_region_memcached
-from rucio.common.config import config_get, config_get_bool, config_get_int
-from rucio.common.exception import (DatabaseException, RSENotFound,
-                                    ReplicaUnAvailable, ReplicaNotFound, ServiceUnavailable,
-                                    RSEAccessDenied, ResourceTemporaryUnavailable, SourceNotFound,
-                                    VONotFound, RSEProtocolNotSupported)
+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
 from rucio.common.logging import setup_logging
 from rucio.common.stopwatch import Stopwatch
-from rucio.common.types import InternalAccount
 from rucio.common.utils import chunks
 from rucio.core.credential import get_signed_url
 from rucio.core.heartbeat import list_payload_counts
 from rucio.core.message import add_message
 from rucio.core.monitor import MetricManager
-from rucio.core.oidc import get_token_for_account_operation
-from rucio.core.replica import list_and_mark_unlocked_replicas, delete_replicas
-from rucio.core.rse import list_rses, RseData
+from rucio.core.oidc import request_token
+from rucio.core.replica import delete_replicas, list_and_mark_unlocked_replicas
+from rucio.core.rse import RseData, determine_audience_for_rse, determine_scope_for_rse, list_rses
 from rucio.core.rse_expression_parser import parse_expression
 from rucio.core.rule import get_evaluation_backlog
 from rucio.core.vo import list_vos
@@ -56,10 +54,10 @@ from rucio.daemons.common import run_daemon
 from rucio.rse import rsemanager as rsemgr
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Iterable, Sequence
     from types import FrameType
-    from typing import Any, Optional
 
+    from rucio.common.types import LoggerFunction
     from rucio.daemons.common import HeartbeatHandler
 
 GRACEFUL_STOP = threading.Event()
@@ -70,7 +68,12 @@ DAEMON_NAME = 'reaper'
 EXCLUDED_RSE_GAUGE = METRICS.gauge('excluded_rses.{rse}', documentation='Temporarly excluded RSEs')
 
 
-def get_rses_to_process(rses, include_rses, exclude_rses, vos):
+def get_rses_to_process(
+        rses: Optional["Iterable[str]"],
+        include_rses: Optional[str],
+        exclude_rses: Optional[str],
+        vos: Optional["Sequence[str]"]
+) -> Optional[list[dict[str, Any]]]:
     """
     Return the list of RSEs to process based on rses, include_rses and exclude_rses
 
@@ -105,7 +108,7 @@ def get_rses_to_process(rses, include_rses, exclude_rses, vos):
     if not isinstance(result, NoValue):
         return result
 
-    all_rses = []
+    all_rses: list[dict[str, Any]] = []
     for vo in vos:
         all_rses.extend(list_rses(filters={'vo': vo}))
 
@@ -115,21 +118,21 @@ def get_rses_to_process(rses, include_rses, exclude_rses, vos):
             msg = 'RSE{} {} cannot be found'.format('s' if len(invalid) > 1 else '',
                                                     ', '.join([repr(rse) for rse in invalid]))
             raise RSENotFound(msg)
-        rses = [rse for rse in all_rses if rse['rse'] in rses]
+        rses_to_process = [rse for rse in all_rses if rse['rse'] in rses]
     else:
-        rses = all_rses
+        rses_to_process = all_rses
 
     if include_rses:
         included_rses = parse_expression(include_rses)
-        rses = [rse for rse in rses if rse in included_rses]
+        rses_to_process = [rse for rse in rses_to_process if rse in included_rses]
 
     if exclude_rses:
         excluded_rses = parse_expression(exclude_rses)
-        rses = [rse for rse in rses if rse not in excluded_rses]
+        rses_to_process = [rse for rse in rses_to_process if rse not in excluded_rses]
 
-    REGION.set(cache_key, rses)
-    logging.log(logging.INFO, 'Reaper: This instance will work on RSEs: %s', ', '.join([rse['rse'] for rse in rses]))
-    return rses
+    REGION.set(cache_key, rses_to_process)
+    logging.log(logging.INFO, 'Reaper: This instance will work on RSEs: %s', ', '.join([rse['rse'] for rse in rses_to_process]))
+    return rses_to_process
 
 
 def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info, is_staging, auto_exclude_threshold, logger=logging.log):
@@ -200,7 +203,7 @@ def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info,
                 add_message('deletion-failed', deletion_dict)
                 noaccess_attempts += 1
                 if noaccess_attempts >= auto_exclude_threshold:
-                    logger(logging.INFO, 'Too many (%d) NOACCESS attempts for %s. RSE will be temporarly excluded.', noaccess_attempts, rse_name)
+                    logger(logging.INFO, 'Too many (%d) NOACCESS attempts for %s. RSE will be temporarily excluded.', noaccess_attempts, rse_name)
                     REGION.set('temporary_exclude_%s' % rse_id, True)
                     METRICS.gauge('excluded_rses.{rse}').labels(rse=rse_name).set(1)
 
@@ -232,7 +235,7 @@ def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info,
             if replica['scope'].vo != 'def':
                 payload['vo'] = replica['scope'].vo
             add_message('deletion-failed', payload)
-        logger(logging.INFO, 'Cannot connect to %s. RSE will be temporarly excluded.', rse_name)
+        logger(logging.INFO, 'Cannot connect to %s. RSE will be temporarily excluded.', rse_name)
         REGION.set('temporary_exclude_%s' % rse_id, True)
         EXCLUDED_RSE_GAUGE.labels(rse=rse_name).set(1)
     finally:
@@ -240,7 +243,7 @@ def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info,
     return deleted_files
 
 
-def _rse_deletion_hostname(rse: RseData, scheme: "Optional[str]") -> "Optional[str]":
+def _rse_deletion_hostname(rse: RseData, scheme: Optional[str]) -> Optional[str]:
     """
     Retrieves the hostname of the default deletion protocol
     """
@@ -277,7 +280,7 @@ def get_max_deletion_threads_by_hostname(hostname: str) -> int:
     return result
 
 
-def __try_reserve_worker_slot(heartbeat_handler: "HeartbeatHandler", rse: RseData, hostname: str, logger: "Callable[..., Any]") -> "Optional[str]":
+def __try_reserve_worker_slot(heartbeat_handler: "HeartbeatHandler", rse: RseData, hostname: str, logger: "LoggerFunction") -> Optional[str]:
     """
     The maximum number of concurrent workers is limited per hostname and per RSE due to storage performance reasons.
     This function tries to reserve a slot to run the deletion worker for the given RSE and hostname.
@@ -290,7 +293,7 @@ def __try_reserve_worker_slot(heartbeat_handler: "HeartbeatHandler", rse: RseDat
     """
 
     rse_hostname_key = '%s,%s' % (rse.id, hostname)
-    payload_cnt = list_payload_counts(heartbeat_handler.executable, older_than=heartbeat_handler.older_than)
+    payload_cnt = list_payload_counts(heartbeat_handler.executable, older_than=heartbeat_handler.older_than)  # type: ignore (argument missing: session)
     tot_threads_for_hostname = 0
     tot_threads_for_rse = 0
     for key in payload_cnt:
@@ -309,7 +312,7 @@ def __try_reserve_worker_slot(heartbeat_handler: "HeartbeatHandler", rse: RseDat
     return rse_hostname_key
 
 
-def __check_rse_usage_cached(rse: RseData, greedy: bool = False, logger: "Callable[..., Any]" = logging.log) -> tuple[int, bool]:
+def __check_rse_usage_cached(rse: RseData, greedy: bool = False, logger: "LoggerFunction" = logging.log) -> tuple[int, bool]:
     """
     Wrapper around __check_rse_usage which manages the cache entry.
     """
@@ -321,7 +324,7 @@ def __check_rse_usage_cached(rse: RseData, greedy: bool = False, logger: "Callab
     return result
 
 
-def __check_rse_usage(rse: RseData, greedy: bool = False, logger: "Callable[..., Any]" = logging.log) -> tuple[int, bool]:
+def __check_rse_usage(rse: RseData, greedy: bool = False, logger: "LoggerFunction" = logging.log) -> tuple[int, bool]:
     """
     Internal method to check RSE usage and limits.
 
@@ -347,12 +350,12 @@ def __check_rse_usage(rse: RseData, greedy: bool = False, logger: "Callable[...,
 
     # Check from which sources to get used and total spaces (default storage)
     # If specified sources do not exist, only delete obsolete
-    source_for_total_space = rse.attributes.get('source_for_total_space', 'storage')
+    source_for_total_space = rse.attributes.get(RseAttr.SOURCE_FOR_TOTAL_SPACE, 'storage')
     if source_for_total_space not in available_sources['total']:
         logger(logging.WARNING, 'RSE: %s, \'%s\' requested for source_for_total_space but cannot be found. Will only delete obsolete',
                rse.name, source_for_total_space)
         return 0, True
-    source_for_used_space = rse.attributes.get('source_for_used_space', 'storage')
+    source_for_used_space = rse.attributes.get(RseAttr.SOURCE_FOR_USED_SPACE, 'storage')
     if source_for_used_space not in available_sources['used']:
         logger(logging.WARNING, 'RSE: %s, \'%s\' requested for source_for_used_space but cannot be found. Will only delete obsolete',
                rse.name, source_for_used_space)
@@ -376,8 +379,20 @@ def __check_rse_usage(rse: RseData, greedy: bool = False, logger: "Callable[...,
     return 0, True
 
 
-def reaper(rses, include_rses, exclude_rses, vos=None, chunk_size=100, once=False, greedy=False,
-           scheme=None, delay_seconds=0, sleep_time=60, auto_exclude_threshold=100, auto_exclude_timeout=600):
+def reaper(
+        rses: "Sequence[str]",
+        include_rses: Optional[str],
+        exclude_rses: Optional[str],
+        vos: Optional["Sequence[str]"] = None,
+        chunk_size: int = 100,
+        once: bool = False,
+        greedy: bool = False,
+        scheme: Optional[str] = None,
+        delay_seconds: int = 0,
+        sleep_time: int = 60,
+        auto_exclude_threshold: int = 100,
+        auto_exclude_timeout: int = 600
+) -> None:
     """
     Main loop to select and delete files.
 
@@ -395,11 +410,6 @@ def reaper(rses, include_rses, exclude_rses, vos=None, chunk_size=100, once=Fals
     :param auto_exclude_threshold: Number of service unavailable exceptions after which the RSE gets temporarily excluded.
     :param auto_exclude_timeout:   Timeout for temporarily excluded RSEs.
     """
-
-    oidc_account = config_get('reaper', 'oidc_account', False, 'root')
-    oidc_scope = config_get('reaper', 'oidc_scope', False, 'delete')
-    oidc_audience = config_get('reaper', 'oidc_audience', False, 'rse')
-
     run_daemon(
         once=once,
         graceful_stop=GRACEFUL_STOP,
@@ -418,16 +428,24 @@ def reaper(rses, include_rses, exclude_rses, vos=None, chunk_size=100, once=Fals
             delay_seconds=delay_seconds,
             auto_exclude_threshold=auto_exclude_threshold,
             auto_exclude_timeout=auto_exclude_timeout,
-            oidc_account=oidc_account,
-            oidc_scope=oidc_scope,
-            oidc_audience=oidc_audience,
         )
     )
 
 
-def run_once(rses, include_rses, exclude_rses, vos, chunk_size, greedy, scheme,
-             delay_seconds, auto_exclude_threshold, auto_exclude_timeout,
-             heartbeat_handler, oidc_account, oidc_scope, oidc_audience, **_kwargs):
+def run_once(
+        rses: "Sequence[str]",
+        include_rses: Optional[str],
+        exclude_rses: Optional[str],
+        vos: Optional["Sequence[str]"],
+        chunk_size: int,
+        greedy: bool,
+        scheme: Optional[str],
+        delay_seconds: int,
+        auto_exclude_threshold: int,
+        auto_exclude_timeout: int,
+        heartbeat_handler: "HeartbeatHandler",
+        **_kwargs
+) -> bool:
 
     must_sleep = True
 
@@ -455,10 +473,11 @@ def run_once(rses, include_rses, exclude_rses, vos, chunk_size, greedy, scheme,
             return must_sleep
 
     rses_to_process = get_rses_to_process(rses, include_rses, exclude_rses, vos)
-    rses_to_process = [RseData(id_=rse['id'], name=rse['rse'], columns=rse) for rse in rses_to_process]
     if not rses_to_process:
         logger(logging.ERROR, 'Reaper: No RSEs found. Will sleep for 30 seconds')
         return must_sleep
+    else:
+        rses_to_process = [RseData(id_=rse['id'], name=rse['rse'], columns=rse) for rse in rses_to_process]
 
     # On big deletion campaigns, we desire to re-iterate fast on RSEs which have a lot of data to delete.
     # The called function will return the RSEs which have more work remaining.
@@ -476,9 +495,6 @@ def run_once(rses, include_rses, exclude_rses, vos, chunk_size, greedy, scheme,
             auto_exclude_threshold=auto_exclude_threshold,
             auto_exclude_timeout=auto_exclude_timeout,
             heartbeat_handler=heartbeat_handler,
-            oidc_account=oidc_account,
-            oidc_scope=oidc_scope,
-            oidc_audience=oidc_audience,
         )
         if rses_to_process and iteration < max_fast_reiterations:
             logger(logging.INFO, "Will perform fast-reiteration %d/%d with rses: %s", iteration + 1, max_fast_reiterations, [str(rse) for rse in rses_to_process])
@@ -492,9 +508,17 @@ def run_once(rses, include_rses, exclude_rses, vos, chunk_size, greedy, scheme,
     return must_sleep
 
 
-def _run_once(rses_to_process, chunk_size, greedy, scheme,
-              delay_seconds, auto_exclude_threshold, auto_exclude_timeout,
-              heartbeat_handler, oidc_account, oidc_scope, oidc_audience, **_kwargs):
+def _run_once(
+        rses_to_process: "Iterable[RseData]",
+        chunk_size: int,
+        greedy: bool,
+        scheme: Optional[str],
+        delay_seconds: int,
+        auto_exclude_threshold: int,
+        auto_exclude_timeout: int,
+        heartbeat_handler: "HeartbeatHandler",
+        **_kwargs
+) -> list[RseData]:
 
     dict_rses = {}
     _, total_workers, logger = heartbeat_handler.live()
@@ -505,7 +529,7 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
             logger(logging.DEBUG, 'RSE %s is blocklisted for delete', rse.name)
             continue
         rse.ensure_loaded(load_attributes=True)
-        enable_greedy = rse.attributes.get('greedyDeletion', False) or greedy
+        enable_greedy = rse.attributes.get(RseAttr.GREEDYDELETION, False) or greedy
         needed_free_space, only_delete_obsolete = __check_rse_usage_cached(rse, greedy=enable_greedy, logger=logger)
         if needed_free_space:
             dict_rses[rse] = [needed_free_space, only_delete_obsolete, enable_greedy]
@@ -537,7 +561,7 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
 
         result = REGION.get('temporary_exclude_%s' % rse.id, expiration_time=auto_exclude_timeout)
         if not isinstance(result, NoValue):
-            logger(logging.WARNING, 'Too many failed attempts for %s in last cycle. RSE is temporarly excluded.', rse.name)
+            logger(logging.WARNING, 'Too many failed attempts for %s in last cycle. RSE is temporarily excluded.', rse.name)
             EXCLUDED_RSE_GAUGE.labels(rse=rse.name).set(1)
             continue
         EXCLUDED_RSE_GAUGE.labels(rse=rse.name).set(0)
@@ -572,7 +596,7 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
                                                            rse_id=rse.id,
                                                            delay_seconds=delay_seconds,
                                                            only_delete_obsolete=only_delete_obsolete,
-                                                           session=None)
+                                                           session=None)  # type: ignore (argument missing: session)
             logger(logging.DEBUG, 'list_and_mark_unlocked_replicas on %s for %s bytes in %s seconds: %s replicas', rse.name, needed_free_space, time.time() - del_start_time, len(replicas))
             if (len(replicas) == 0 and enable_greedy) or (len(replicas) < chunk_size and not enable_greedy):
                 logger(logging.DEBUG, 'Not enough replicas to delete on %s (%s requested vs %s returned). Will skip any new attempts on this RSE until next cycle', rse.name, chunk_size, len(replicas))
@@ -590,14 +614,18 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
         # Physical  deletion will take place there
         try:
             rse.ensure_loaded(load_info=True, load_attributes=True)
-            auth_token = None
-            if oidc_account and rse.attributes.get('oidc_support', False):
-                account = InternalAccount(oidc_account, vo=rse.columns['vo'])
-                token_dict = get_token_for_account_operation(account, req_audience=oidc_audience, req_scope=oidc_scope, admin=True)
-                if token_dict is not None and 'token' in token_dict:
-                    auth_token = token_dict['token']
-                    logger(logging.DEBUG, 'OIDC authentication used for deletion.')
-            prot = rsemgr.create_protocol(rse.info, 'delete', scheme=scheme, auth_token=auth_token, logger=logger)
+            prot = rsemgr.create_protocol(rse.info, 'delete', scheme=scheme, logger=logger)
+            if rse.attributes.get(RseAttr.OIDC_SUPPORT) is True and prot.attributes['scheme'] == 'davs':
+                audience = determine_audience_for_rse(rse.id)
+                # FIXME: At the time of writing, StoRM requires `storage.read`
+                # in order to perform a stat operation.
+                scope = determine_scope_for_rse(rse.id, scopes=['storage.modify', 'storage.read'])
+                auth_token = request_token(audience, scope)
+                if auth_token:
+                    logger(logging.INFO, 'Using a token to delete on RSE %s', rse.name)
+                    prot = rsemgr.create_protocol(rse.info, 'delete', scheme=scheme, auth_token=auth_token, logger=logger)
+                else:
+                    logger(logging.WARNING, 'Failed to procure a token to delete on RSE %s', rse.name)
             for file_replicas in chunks(replicas, chunk_size):
                 # Refresh heartbeat
                 _, total_workers, logger = heartbeat_handler.live(payload=hb_payload)
@@ -620,8 +648,8 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
 
                 # Then finally delete the replicas
                 del_start = time.time()
-                delete_replicas(rse_id=rse.id, files=deleted_files)
-                logger(logging.DEBUG, 'delete_replicas successed on %s : %s replicas in %s seconds', rse.name, len(deleted_files), time.time() - del_start)
+                delete_replicas(rse_id=rse.id, files=deleted_files)  # type: ignore (argument missing: session)
+                logger(logging.DEBUG, 'delete_replicas succeeded on %s : %s replicas in %s seconds', rse.name, len(deleted_files), time.time() - del_start)
                 METRICS.counter('deletion.done').inc(len(deleted_files))
         except RSEProtocolNotSupported:
             logger(logging.WARNING, 'Protocol %s not supported on %s', scheme, rse.name)
@@ -635,14 +663,28 @@ def _run_once(rses_to_process, chunk_size, greedy, scheme,
     return rses_with_more_work
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
     GRACEFUL_STOP.set()
 
 
-def run(threads=1, chunk_size=100, once=False, greedy=False, rses=None, scheme=None, exclude_rses=None, include_rses=None, vos=None, delay_seconds=0, sleep_time=60, auto_exclude_threshold=100, auto_exclude_timeout=600):
+def run(
+        threads: int = 1,
+        chunk_size: int = 100,
+        once: bool = False,
+        greedy: bool = False,
+        rses: Optional["Sequence[str]"] = None,
+        scheme: Optional[str] = None,
+        exclude_rses: Optional[str] = None,
+        include_rses: Optional[str] = None,
+        vos: Optional["Sequence[str]"] = None,
+        delay_seconds: int = 0,
+        sleep_time: int = 60,
+        auto_exclude_threshold: int = 100,
+        auto_exclude_timeout: int = 600
+) -> None:
     """
     Starts up the reaper threads.
 

rucio/daemons/replicarecoverer/__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");