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

rucio/daemons/hermes/hermes.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");
@@ -31,10 +30,11 @@ import threading
 import time
 from configparser import NoOptionError, NoSectionError
 from email.mime.text import MIMEText
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import requests
 import stomp
+from requests.auth import HTTPBasicAuth
 
 import rucio.db.sqla.util
 from rucio.common.config import (
@@ -50,10 +50,12 @@ from rucio.core.monitor import MetricManager
 from rucio.daemons.common import run_daemon
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Iterable, Sequence
     from types import FrameType
-    from typing import Optional
 
+    from stomp.utils import Frame
+
+    from rucio.common.types import LoggerFunction
     from rucio.daemons.common import HeartbeatHandler
 
 logging.getLogger("requests").setLevel(logging.CRITICAL)
@@ -69,7 +71,7 @@ RECONNECT_COUNTER = METRICS.counter(
 )
 
 
-def default(datetype):
+def default(datetype: Union[datetime.date, datetime.datetime]) -> str:
     if isinstance(datetype, (datetime.date, datetime.datetime)):
         return datetype.isoformat()
 
@@ -79,20 +81,28 @@ class HermesListener(stomp.ConnectionListener):
     Hermes Listener
     """
 
-    def __init__(self, broker):
+    def __init__(self, broker: str):
         """
         __init__
         """
         self.__broker = broker
 
-    def on_error(self, frame):
+    def on_error(self, frame: "Frame") -> None:
         """
         Error handler
         """
         logging.error("[broker] [%s]: %s", self.__broker, frame.body)
 
 
-def setup_activemq(logger: "Callable"):
+def setup_activemq(
+        logger: "LoggerFunction"
+) -> tuple[
+    Optional[list[stomp.Connection12]],
+    Optional[str],
+    Optional[str],
+    Optional[str],
+    Optional[bool]
+]:
     """
     Deliver messages to ActiveMQ
 
@@ -149,6 +159,8 @@ def setup_activemq(logger: "Callable"):
 
     port = config_get_int("messaging-hermes", "port")
     vhost = config_get("messaging-hermes", "broker_virtual_host", raise_exception=False)
+    username = None
+    password = None
     if not use_ssl:
         username = config_get("messaging-hermes", "username")
         password = config_get("messaging-hermes", "password")
@@ -191,8 +203,14 @@ def setup_activemq(logger: "Callable"):
 
 
 def deliver_to_activemq(
-    messages, conns, destination, username, password, use_ssl, logger
-):
+    messages: "Iterable[dict[str, Any]]",
+    conns: "Sequence[stomp.Connection12]",
+    destination: str,
+    username: str,
+    password: str,
+    use_ssl: bool,
+    logger: "LoggerFunction"
+) -> list[str]:
     """
     Deliver messages to ActiveMQ
 
@@ -315,7 +333,10 @@ def deliver_to_activemq(
     return to_delete
 
 
-def deliver_emails(messages: list[dict], logger: "Callable") -> list:
+def deliver_emails(
+        messages: "Iterable[dict[str, Any]]",
+        logger: "LoggerFunction"
+) -> list[str]:
     """
     Sends emails
 
@@ -354,7 +375,11 @@ def deliver_emails(messages: list[dict], logger: "Callable") -> list:
     return to_delete
 
 
-def submit_to_elastic(messages: list[dict], endpoint: str, logger: "Callable") -> int:
+def submit_to_elastic(
+        messages: "Iterable[dict[str, Any]]",
+        endpoint: str,
+        logger: "LoggerFunction"
+) -> int:
     """
     Aggregate a list of message to ElasticSearch
 
@@ -365,23 +390,34 @@ def submit_to_elastic(messages: list[dict], endpoint: str, logger: "Callable") -
     :returns:                  HTTP status code. 200 and 204 OK. Rest is failure.
     """
     text = ""
+    elastic_username = config_get("hermes", "elastic_username",
+                                  raise_exception=False, default=None)
+    elastic_password = config_get("hermes", "elastic_password",
+                                  raise_exception=False, default=None)
+    auth = None
+    if elastic_username and elastic_password:
+        auth = HTTPBasicAuth(elastic_username, elastic_password)
+
     for message in messages:
         text += '{ "index":{ } }\n%s\n' % json.dumps(message, default=default)
     res = requests.post(
-        endpoint, data=text, headers={"Content-Type": "application/json"}
+        endpoint, data=text, headers={"Content-Type": "application/json"}, auth=auth
     )
     return res.status_code
 
 
 def aggregate_to_influx(
-    messages: list[dict], bin_size: int, endpoint: str, logger: "Callable"
+    messages: "Iterable[dict[str, Any]]",
+    bin_size: int,
+    endpoint: str,
+    logger: "LoggerFunction"
 ) -> int:
     """
     Aggregate a list of message using a certain bin_size
     and submit them to a InfluxDB endpoint
 
     :param messages:           The list of messages.
-    :param bin_size:           The size of the bins for the aggreagation (e.g. 10m, 1h, etc.).
+    :param bin_size:           The size of the bins for the aggregation (e.g. 10m, 1h, etc.).
     :param endpoint:           The InfluxDB endpoint were to send the messages.
     :param logger:             The logger object.
 
@@ -625,7 +661,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                     logger(
                         logging.ERROR,
                         "Failure to submit %s messages to elastic. Returned status: %s",
-                        len(message_dict["influx"]),
+                        len(message_dict["elastic"]),
                         state,
                     )
             except Exception as error:
@@ -655,10 +691,10 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                 messages_sent = deliver_to_activemq(
                     messages=message_dict["activemq"],
                     conns=conns,
-                    destination=destination,
-                    username=username,
-                    password=password,
-                    use_ssl=use_ssl,
+                    destination=destination,  # type: ignore (argument could be None)
+                    username=username,  # type: ignore (argument could be None)
+                    password=password,  # type: ignore (argument could be None)
+                    use_ssl=use_ssl,  # type: ignore (argument could be None)
                     logger=logger,
                 )
                 logger(
@@ -689,7 +725,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
     return must_sleep
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """

rucio/daemons/judge/__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/judge/cleaner.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");
@@ -24,29 +23,32 @@ from copy import deepcopy
 from datetime import datetime, timedelta
 from random import randint
 from re import match
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy.exc import DatabaseError
 
 import rucio.db.sqla.util
 from rucio.common import exception
-from rucio.common.exception import DatabaseException, UnsupportedOperation, RuleNotFound
+from rucio.common.exception import DatabaseException, RuleNotFound, UnsupportedOperation
 from rucio.common.logging import setup_logging
 from rucio.core.monitor import MetricManager
 from rucio.core.rule import delete_rule, get_expired_rules
-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, ORACLE_RESOURCE_BUSY_REGEX
 from rucio.db.sqla.util import get_db_time
 
 if TYPE_CHECKING:
     from types import FrameType
-    from typing import Optional
 
 METRICS = MetricManager(module=__name__)
 graceful_stop = threading.Event()
 DAEMON_NAME = 'judge-cleaner'
 
 
-def rule_cleaner(once=False, sleep_time=60):
+def rule_cleaner(
+        once: bool = False,
+        sleep_time: int = 60
+) -> None:
     """
     Main loop to check for expired replication rules
     """
@@ -64,7 +66,11 @@ def rule_cleaner(once=False, sleep_time=60):
     )
 
 
-def run_once(paused_rules, heartbeat_handler, **_kwargs):
+def run_once(
+        paused_rules: dict[str, datetime],
+        heartbeat_handler: HeartbeatHandler,
+        **_kwargs
+) -> None:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
     start = time.time()
@@ -97,14 +103,14 @@ def run_once(paused_rules, heartbeat_handler, **_kwargs):
             delete_rule(rule_id=rule_id, nowait=True)
             logger(logging.DEBUG, 'deletion of %s took %f' % (rule_id, time.time() - start))
         except (DatabaseException, DatabaseError, UnsupportedOperation) as e:
-            if match('.*ORA-00054.*', str(e.args[0])):
-                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(600, 2400))
+            if match(ORACLE_RESOURCE_BUSY_REGEX, str(e.args[0])):
+                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(600, 2400))  # noqa: S311
                 METRICS.counter('exceptions.{exception}').labels(exception='LocksDetected').inc()
                 logger(logging.WARNING, 'Locks detected for %s' % rule_id)
             elif match('.*QueuePool.*', str(e.args[0])):
                 logger(logging.WARNING, 'DatabaseException', exc_info=True)
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
-            elif match('.*ORA-03135.*', str(e.args[0])):
+            elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(e.args[0])):
                 logger(logging.WARNING, 'DatabaseException', exc_info=True)
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
             else:
@@ -114,14 +120,18 @@ def run_once(paused_rules, heartbeat_handler, **_kwargs):
             pass
 
 
-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(once=False, threads=1, sleep_time=60):
+def run(
+        once: bool = False,
+        threads: int = 1,
+        sleep_time: int = 60
+) -> None:
     """
     Starts up the Judge-Clean threads.
     """
@@ -141,9 +151,9 @@ def run(once=False, threads=1, sleep_time=60):
         rule_cleaner(once)
     else:
         logging.info('Cleaner starting %s threads' % str(threads))
-        threads = [threading.Thread(target=rule_cleaner, kwargs={'once': once,
-                                                                 'sleep_time': sleep_time}) for i in range(0, threads)]
-        [t.start() for t in threads]
+        thread_list = [threading.Thread(target=rule_cleaner, kwargs={'once': once,
+                                                                     'sleep_time': sleep_time}) for i in range(0, threads)]
+        [t.start() for t in thread_list]
         # 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/judge/evaluator.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 @@ import traceback
 from datetime import datetime, timedelta
 from random import randint
 from re import match
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy.exc import DatabaseError
 from sqlalchemy.orm.exc import FlushError
@@ -35,19 +34,23 @@ from rucio.common.exception import DatabaseException, DataIdentifierNotFound, Re
 from rucio.common.logging import setup_logging
 from rucio.common.types import InternalScope
 from rucio.core.monitor import MetricManager
-from rucio.core.rule import re_evaluate_did, get_updated_dids, delete_updated_did
-from rucio.daemons.common import run_daemon
+from rucio.core.rule import delete_updated_did, get_updated_dids, re_evaluate_did
+from rucio.daemons.common import HeartbeatHandler, run_daemon
+from rucio.db.sqla.constants import ORACLE_CONNECTION_LOST_CONTACT_REGEX, ORACLE_RESOURCE_BUSY_REGEX, ORACLE_UNIQUE_CONSTRAINT_VIOLATED_REGEX
 
 if TYPE_CHECKING:
     from types import FrameType
-    from typing import Optional
 
 METRICS = MetricManager(module=__name__)
 graceful_stop = threading.Event()
 DAEMON_NAME = 'judge-evaluator'
 
 
-def re_evaluator(once=False, sleep_time=30, did_limit=100):
+def re_evaluator(
+        once: bool = False,
+        sleep_time: int = 30,
+        did_limit: int = 100
+) -> None:
     """
     Main loop to check the re-evaluation of dids.
     """
@@ -67,7 +70,12 @@ def re_evaluator(once=False, sleep_time=30, did_limit=100):
     )
 
 
-def run_once(paused_dids, did_limit, heartbeat_handler, **_kwargs):
+def run_once(
+        paused_dids: dict[tuple[str, str], datetime],
+        did_limit: int,
+        heartbeat_handler: HeartbeatHandler,
+        **_kwargs
+) -> None:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
     # heartbeat
@@ -121,14 +129,14 @@ def run_once(paused_dids, did_limit, heartbeat_handler, **_kwargs):
         except DataIdentifierNotFound:
             delete_updated_did(id_=did.id)
         except (DatabaseException, DatabaseError) as e:
-            if match('.*ORA-000(01|54).*', str(e.args[0])):
-                paused_dids[(did.scope.internal, did.name)] = datetime.utcnow() + timedelta(seconds=randint(60, 600))
+            if match(ORACLE_UNIQUE_CONSTRAINT_VIOLATED_REGEX, str(e.args[0])) or match(ORACLE_RESOURCE_BUSY_REGEX, str(e.args[0])):
+                paused_dids[(did.scope.internal, did.name)] = datetime.utcnow() + timedelta(seconds=randint(60, 600))  # noqa: S311
                 logger(logging.WARNING, 'Locks detected for %s:%s', did.scope, did.name)
                 METRICS.counter('exceptions.{exception}').labels(exception='LocksDetected').inc()
             elif match('.*QueuePool.*', str(e.args[0])):
                 logger(logging.WARNING, traceback.format_exc())
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
-            elif match('.*ORA-03135.*', str(e.args[0])):
+            elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(e.args[0])):
                 logger(logging.WARNING, traceback.format_exc())
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
             else:
@@ -142,7 +150,7 @@ def run_once(paused_dids, did_limit, heartbeat_handler, **_kwargs):
             logger(logging.WARNING, 'Flush error for %s:%s', did.scope, did.name)
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -150,7 +158,12 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
     graceful_stop.set()
 
 
-def run(once=False, threads=1, sleep_time=30, did_limit=100):
+def run(
+        once: bool = False,
+        threads: int = 1,
+        sleep_time: int = 30,
+        did_limit: int = 100
+) -> None:
     """
     Starts up the Judge-Eval threads.
     """
@@ -163,10 +176,10 @@ def run(once=False, threads=1, sleep_time=30, did_limit=100):
         re_evaluator(once=once, did_limit=did_limit)
     else:
         logging.info('Evaluator starting %s threads' % str(threads))
-        threads = [threading.Thread(target=re_evaluator, kwargs={'once': once,
-                                                                 'sleep_time': sleep_time,
-                                                                 'did_limit': did_limit}) for i in range(0, threads)]
-        [t.start() for t in threads]
+        thread_list = [threading.Thread(target=re_evaluator, kwargs={'once': once,
+                                                                     'sleep_time': sleep_time,
+                                                                     'did_limit': did_limit}) for i in range(0, threads)]
+        [t.start() for t in thread_list]
         # 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/judge/injector.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");
@@ -24,28 +23,30 @@ from copy import deepcopy
 from datetime import datetime, timedelta
 from random import randint
 from re import match
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy.exc import DatabaseError
 
 import rucio.db.sqla.util
-from rucio.common.exception import (DatabaseException, RuleNotFound, RSEWriteBlocked,
-                                    ReplicationRuleCreationTemporaryFailed, InsufficientAccountLimit)
+from rucio.common.exception import DatabaseException, InsufficientAccountLimit, ReplicationRuleCreationTemporaryFailed, RSEWriteBlocked, RuleNotFound
 from rucio.common.logging import setup_logging
 from rucio.core.monitor import MetricManager
-from rucio.core.rule import inject_rule, get_injected_rules, update_rule
-from rucio.daemons.common import run_daemon
+from rucio.core.rule import get_injected_rules, inject_rule, update_rule
+from rucio.daemons.common import HeartbeatHandler, run_daemon
+from rucio.db.sqla.constants import ORACLE_CONNECTION_LOST_CONTACT_REGEX, ORACLE_RESOURCE_BUSY_REGEX
 
 if TYPE_CHECKING:
     from types import FrameType
-    from typing import Optional
 
 METRICS = MetricManager(module=__name__)
 graceful_stop = threading.Event()
 DAEMON_NAME = 'judge-injector'
 
 
-def rule_injector(once=False, sleep_time=60):
+def rule_injector(
+        once: bool = False,
+        sleep_time: int = 60
+) -> None:
     """
     Main loop to check for asynchronous creation of replication rules
     """
@@ -63,7 +64,11 @@ def rule_injector(once=False, sleep_time=60):
     )
 
 
-def run_once(paused_rules, heartbeat_handler, **_kwargs):
+def run_once(
+        paused_rules: dict[str, datetime],
+        heartbeat_handler: HeartbeatHandler,
+        **_kwargs
+) -> None:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
     start = time.time()
@@ -84,9 +89,8 @@ def run_once(paused_rules, heartbeat_handler, **_kwargs):
         logger(logging.DEBUG, 'did not get any work (paused_rules=%s)' % str(len(paused_rules)))
         return
 
-    for rule in rules:
+    for rule_id in rules:
         _, _, logger = heartbeat_handler.live()
-        rule_id = rule[0]
         logger(logging.INFO, 'Injecting rule %s' % rule_id)
         if graceful_stop.is_set():
             break
@@ -95,25 +99,25 @@ def run_once(paused_rules, heartbeat_handler, **_kwargs):
             inject_rule(rule_id=rule_id, logger=logger)
             logger(logging.DEBUG, 'injection of %s took %f' % (rule_id, time.time() - start))
         except (DatabaseException, DatabaseError) as e:
-            if match('.*ORA-00054.*', str(e.args[0])):
-                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))
+            if match(ORACLE_RESOURCE_BUSY_REGEX, str(e.args[0])):
+                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))  # noqa: S311
                 METRICS.counter('exceptions.{exception}').labels(exception='LocksDetected').inc()
                 logger(logging.WARNING, 'Locks detected for %s' % rule_id)
             elif match('.*QueuePool.*', str(e.args[0])):
                 logger(logging.WARNING, 'DatabaseException', exc_info=True)
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
-            elif match('.*ORA-03135.*', str(e.args[0])):
+            elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(e.args[0])):
                 logger(logging.WARNING, 'DatabaseException', exc_info=True)
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
             else:
                 logger(logging.ERROR, 'DatabaseException', exc_info=True)
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
         except (RSEWriteBlocked) as e:
-            paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))
+            paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))  # noqa: S311
             logger(logging.WARNING, 'RSEWriteBlocked for rule %s' % rule_id)
             METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
         except ReplicationRuleCreationTemporaryFailed as e:
-            paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))
+            paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(60, 600))  # noqa: S311
             logger(logging.WARNING, 'ReplicationRuleCreationTemporaryFailed for rule %s' % rule_id)
             METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
         except RuleNotFound:
@@ -125,7 +129,7 @@ def run_once(paused_rules, heartbeat_handler, **_kwargs):
             update_rule(rule_id=rule_id, options={'state': 'SUSPENDED'})
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -133,7 +137,11 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
     graceful_stop.set()
 
 
-def run(once=False, threads=1, sleep_time=60):
+def run(
+        once: bool = False,
+        threads: int = 1,
+        sleep_time: int = 60
+) -> None:
     """
     Starts up the Judge-Injector threads.
     """
@@ -146,9 +154,9 @@ def run(once=False, threads=1, sleep_time=60):
         rule_injector(once)
     else:
         logging.info('Injector starting %s threads' % str(threads))
-        threads = [threading.Thread(target=rule_injector, kwargs={'once': once,
-                                                                  'sleep_time': sleep_time}) for i in range(0, threads)]
-        [t.start() for t in threads]
+        thread_list = [threading.Thread(target=rule_injector, kwargs={'once': once,
+                                                                      'sleep_time': sleep_time}) for i in range(0, threads)]
+        [t.start() for t in thread_list]
         # 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/judge/repairer.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 copy import deepcopy
 from datetime import datetime, timedelta
 from random import randint
 from re import match
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from sqlalchemy.exc import DatabaseError
 
@@ -34,19 +33,22 @@ from rucio.common import exception
 from rucio.common.exception import DatabaseException
 from rucio.common.logging import setup_logging
 from rucio.core.monitor import MetricManager
-from rucio.core.rule import repair_rule, get_stuck_rules
-from rucio.daemons.common import run_daemon
+from rucio.core.rule import get_stuck_rules, repair_rule
+from rucio.daemons.common import HeartbeatHandler, run_daemon
+from rucio.db.sqla.constants import ORACLE_CONNECTION_LOST_CONTACT_REGEX, ORACLE_RESOURCE_BUSY_REGEX
 
 if TYPE_CHECKING:
     from types import FrameType
-    from typing import Optional
 
 METRICS = MetricManager(module=__name__)
 graceful_stop = threading.Event()
 DAEMON_NAME = 'judge-repairer'
 
 
-def rule_repairer(once=False, sleep_time=60):
+def rule_repairer(
+        once: bool = False,
+        sleep_time: int = 60
+) -> None:
     """
     Main loop to check for STUCK replication rules
     """
@@ -65,7 +67,12 @@ def rule_repairer(once=False, sleep_time=60):
     )
 
 
-def run_once(paused_rules, delta, heartbeat_handler, **_kwargs):
+def run_once(
+        paused_rules: dict[str, datetime],
+        delta: int,
+        heartbeat_handler: HeartbeatHandler,
+        **_kwargs
+) -> None:
     worker_number, total_workers, logger = heartbeat_handler.live()
 
     start = time.time()
@@ -91,7 +98,6 @@ def run_once(paused_rules, delta, heartbeat_handler, **_kwargs):
 
     for rule_id in rules:
         _, _, logger = heartbeat_handler.live()
-        rule_id = rule_id[0]
         logger(logging.INFO, 'Repairing rule %s' % (rule_id))
         if graceful_stop.is_set():
             break
@@ -100,14 +106,14 @@ def run_once(paused_rules, delta, heartbeat_handler, **_kwargs):
             repair_rule(rule_id=rule_id)
             logger(logging.DEBUG, 'repairing of %s took %f' % (rule_id, time.time() - start))
         except (DatabaseException, DatabaseError) as e:
-            if match('.*ORA-00054.*', str(e.args[0])):
-                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(600, 2400))
+            if match(ORACLE_RESOURCE_BUSY_REGEX, str(e.args[0])):
+                paused_rules[rule_id] = datetime.utcnow() + timedelta(seconds=randint(600, 2400))  # noqa: S311
                 logger(logging.WARNING, 'Locks detected for %s' % (rule_id))
                 METRICS.counter('exceptions.{exception}').labels(exception='LocksDetected').inc()
             elif match('.*QueuePool.*', str(e.args[0])):
                 logger(logging.WARNING, traceback.format_exc())
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
-            elif match('.*ORA-03135.*', str(e.args[0])):
+            elif match(ORACLE_CONNECTION_LOST_CONTACT_REGEX, str(e.args[0])):
                 logger(logging.WARNING, traceback.format_exc())
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
             else:
@@ -115,7 +121,7 @@ def run_once(paused_rules, delta, heartbeat_handler, **_kwargs):
                 METRICS.counter('exceptions.{exception}').labels(exception=e.__class__.__name__).inc()
 
 
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
+def stop(signum: Optional[int] = None, frame: Optional["FrameType"] = None) -> None:
     """
     Graceful exit.
     """
@@ -123,7 +129,11 @@ def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) ->
     graceful_stop.set()
 
 
-def run(once=False, threads=1, sleep_time=60):
+def run(
+        once: bool = False,
+        threads: int = 1,
+        sleep_time: int = 60
+) -> None:
     """
     Starts up the Judge-Repairer threads.
     """
@@ -136,9 +146,9 @@ def run(once=False, threads=1, sleep_time=60):
         rule_repairer(once)
     else:
         logging.info('Repairer starting %s threads' % str(threads))
-        threads = [threading.Thread(target=rule_repairer, kwargs={'once': once,
-                                                                  'sleep_time': sleep_time}) for i in range(0, threads)]
-        [t.start() for t in threads]
+        thread_list = [threading.Thread(target=rule_repairer, kwargs={'once': once,
+                                                                      'sleep_time': sleep_time}) for i in range(0, threads)]
+        [t.start() for t in thread_list]
         # 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/oauthmanager/__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");