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

rucio/daemons/auditor/__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");
@@ -18,27 +17,37 @@ import glob
 import logging
 import os
 import queue as Queue
-from datetime import datetime
-from datetime import timedelta
-
 import select
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Optional
 
 from rucio.common import config
-from rucio.common.dumper import LogPipeHandler
-from rucio.common.dumper import mkdir
-from rucio.common.dumper import temp_file
+from rucio.common.dumper import LogPipeHandler, mkdir, temp_file
 from rucio.common.dumper.consistency import Consistency
 from rucio.common.types import InternalAccount, InternalScope
 from rucio.common.utils import chunks
 from rucio.core.quarantined_replica import add_quarantined_replicas
 from rucio.core.replica import declare_bad_file_replicas, list_replicas
-from rucio.core.rse import get_rse_usage, get_rse_id
+from rucio.core.rse import get_rse_id, get_rse_usage
 from rucio.daemons.auditor import srmdumps
 from rucio.daemons.auditor.hdfs import ReplicaFromHDFS
 from rucio.db.sqla.constants import BadFilesStatus
 
-
-def consistency(rse, delta, configuration, cache_dir, results_dir):
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from configparser import RawConfigParser
+    from multiprocessing import Queue as QueueType
+    from multiprocessing.connection import Connection
+    from multiprocessing.synchronize import Event
+
+
+def consistency(
+        rse: str,
+        delta: timedelta,
+        configuration: "RawConfigParser",
+        cache_dir: str,
+        results_dir: str
+) -> Optional[str]:
     logger = logging.getLogger('auditor-worker')
     rsedump, rsedate = srmdumps.download_rse_dump(rse, configuration, destdir=cache_dir)
     results_path = os.path.join(results_dir, '{0}_{1}'.format(rse, rsedate.strftime('%Y%m%d')))  # pylint: disable=no-member
@@ -66,11 +75,12 @@ def consistency(rse, delta, configuration, cache_dir, results_dir):
     return results_path
 
 
-def guess_replica_info(path):
+def guess_replica_info(
+        path: str
+) -> tuple[Optional[str], str]:
     """Try to extract the scope and name from a path.
 
-    ``path`` should be an ``str`` with the relative path to the file on
-    the RSE.
+    ``path``: relative path to the file on the RSE.
 
     Returns a ``tuple`` of which the first element is the scope of the
     replica and the second element is its name.
@@ -84,7 +94,10 @@ def guess_replica_info(path):
         return items[0], items[-1]
 
 
-def bz2_compress_file(source, chunk_size=65000):
+def bz2_compress_file(
+        source: str,
+        chunk_size: int = 65000
+) -> str:
     """Compress a file with bzip2.
 
     The destination is the path passed through ``source`` extended with
@@ -93,13 +106,11 @@ def bz2_compress_file(source, chunk_size=65000):
     Errors are deliberately not handled gracefully.  Any exceptions
     should be propagated to the caller.
 
-    ``source`` should be an ``str`` with the absolute path to the file
-    to compress.
+    ``source``: absolute path to the file to compress.
 
-    ``chunk_size`` should be an ``int`` with the size (in bytes) of the
-    chunks by which to read the file.
+    ``chunk_size``: size (in bytes) of the chunks by which to read the file.
 
-    Returns an ``str`` with the destination path.
+    Returns the destination path.
     """
     destination = '{}.bz2'.format(source)
     with open(source) as plain, bz2.BZ2File(destination, 'w') as compressed:
@@ -112,14 +123,18 @@ def bz2_compress_file(source, chunk_size=65000):
     return destination
 
 
-def process_output(output, sanity_check=True, compress=True):
+def process_output(
+        output: str,
+        sanity_check: bool = True,
+        compress: bool = True
+) -> None:
     """Perform post-consistency-check actions.
 
     DARK files are put in the quarantined-replica table so that they
     may be deleted by the Dark Reaper.  LOST files are reported as
     suspicious so that they may be further checked by the cloud squads.
 
-    ``output`` should be an ``str`` with the absolute path to the file
+    ``output``: absolute path to the file
     produced by ``consistency()``.  It must maintain its naming
     convention.
 
@@ -155,7 +170,7 @@ def process_output(output, sanity_check=True, compress=True):
     rse = os.path.basename(output[:output.rfind('_')])
     rse_id = get_rse_id(rse=rse)
     usage = get_rse_usage(rse_id=rse_id, source='rucio')[0]
-    threshold = config.config_get_float('auditor', 'threshold', False, 0.2)
+    threshold = config.config_get_float('auditor', 'threshold', False, 0.1)
 
     # Perform a basic sanity check by comparing the number of entries
     # with the total number of files on the RSE.  If the percentage is
@@ -190,7 +205,16 @@ def process_output(output, sanity_check=True, compress=True):
         logger.debug('Compressed "%s"', destination)
 
 
-def check(queue, retry, terminate, logpipe, cache_dir, results_dir, keep_dumps, delta_in_days):
+def check(
+        queue: "QueueType",
+        retry: "QueueType",
+        terminate: "Event",
+        logpipe: "Connection",
+        cache_dir: str,
+        results_dir: str,
+        keep_dumps: bool,
+        delta_in_days: int
+) -> None:
     logger = logging.getLogger('auditor-worker')
     lib_logger = logging.getLogger('dumper')
 
@@ -213,7 +237,7 @@ def check(queue, retry, terminate, logpipe, cache_dir, results_dir, keep_dumps,
 
     while not terminate.is_set():
         try:
-            rse, attemps = queue.get(timeout=30)
+            rse, attempts = queue.get(timeout=30)
         except Queue.Empty:
             continue
         start = datetime.now()
@@ -225,7 +249,7 @@ def check(queue, retry, terminate, logpipe, cache_dir, results_dir, keep_dumps,
                 process_output(output)
         except:
             elapsed = (datetime.now() - start).total_seconds() / 60
-            logger.error('Check of "%s" failed in %d minutes, %d remaining attemps', rse, elapsed, attemps, exc_info=True)
+            logger.error('Check of "%s" failed in %d minutes, %d remaining attempts', rse, elapsed, attempts, exc_info=True)
             success = False
         else:
             elapsed = (datetime.now() - start).total_seconds() / 60
@@ -239,11 +263,15 @@ def check(queue, retry, terminate, logpipe, cache_dir, results_dir, keep_dumps,
             for fil in remove:
                 os.remove(fil)
 
-        if not success and attemps > 0:
-            retry.put((rse, attemps - 1))
+        if not success and attempts > 0:
+            retry.put((rse, attempts - 1))
 
 
-def activity_logger(logpipes, logfilename, terminate):
+def activity_logger(
+        logpipes: "Iterable[Connection]",
+        logfilename: str,
+        terminate: "Event"
+) -> None:
     handler = logging.handlers.RotatingFileHandler(
         logfilename,
         maxBytes=20971520,

rucio/daemons/auditor/hdfs.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");
@@ -20,13 +19,19 @@ import re
 import shutil
 import subprocess
 import tempfile
+from typing import TYPE_CHECKING
 
-from rucio.common.dumper import DUMPS_CACHE_DIR
-from rucio.common.dumper import temp_file
+from rucio.common.dumper import DUMPS_CACHE_DIR, temp_file
 from rucio.common.dumper.data_models import Replica
 
+if TYPE_CHECKING:
+    from datetime import datetime
 
-def _hdfs_get(src_url, dst_path):
+
+def _hdfs_get(
+        src_url: str,
+        dst_path: str
+) -> None:
     cmd = ['hadoop', 'fs', '-get', src_url, dst_path]
     get = subprocess.Popen(
         cmd,
@@ -34,7 +39,7 @@ def _hdfs_get(src_url, dst_path):
     )
     _, stderr = get.communicate()
     if get.returncode != 0:
-        raise IOError('_hdfs_get(): "{0}": {1}. Return code {2}'.format(
+        raise OSError('_hdfs_get(): "{0}": {1}. Return code {2}'.format(
             ' '.join(cmd),
             stderr,
             get.returncode,
@@ -45,7 +50,13 @@ class ReplicaFromHDFS(Replica):
     BASE_URL = '/user/rucio01/reports/{0}/replicas_per_rse/{1}/*'
 
     @classmethod
-    def download(cls, rse, date, cache_dir=DUMPS_CACHE_DIR, buffer_size=65536):
+    def download(
+        cls,
+        rse: str,
+        date: "datetime",
+        cache_dir: str = DUMPS_CACHE_DIR,
+        buffer_size: int = 65536
+    ) -> str:
         logger = logging.getLogger('auditor.hdfs')
 
         if not os.path.isdir(cache_dir):

rucio/daemons/auditor/srmdumps.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,32 +21,53 @@ import logging
 import operator
 import os
 import re
+from typing import IO, TYPE_CHECKING, Any, Optional
 
 import gfal2
 import requests
 
 from rucio.common.config import get_config_dirs
-from rucio.common.dumper import DUMPS_CACHE_DIR
-from rucio.common.dumper import http_download_to_file, gfal_download_to_file, ddmendpoint_url, temp_file
+from rucio.common.constants import RseAttr
+from rucio.common.dumper import DUMPS_CACHE_DIR, HTTPDownloadFailed, ddmendpoint_url, gfal_download_to_file, http_download_to_file, temp_file
+from rucio.core.credential import get_signed_url
+from rucio.core.rse import get_rse_id, list_rse_attributes
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 CHUNK_SIZE = 10485760
 
-__DUMPERCONFIGDIRS = (os.path.join(confdir, 'auditor') for confdir in get_config_dirs())
-__DUMPERCONFIGDIRS = list(filter(os.path.exists, __DUMPERCONFIGDIRS))
+__DUMPERCONFIGDIRS = list(
+    filter(
+        os.path.exists,
+        (
+            os.path.join(confdir, 'auditor') for confdir in get_config_dirs()
+        )
+    )
+)
+
+OBJECTSTORE_NUM_TRIES = 30
 
 
-class Parser(ConfigParser.RawConfigParser, object):
+class Parser(ConfigParser.RawConfigParser):
     '''
     RawConfigParser subclass that doesn't modify the the name of the options
-    and removes any quotes arround the string values.
+    and removes any quotes around the string values.
     '''
     remove_quotes_re = re.compile(r"^'(.+)'$")
     remove_double_quotes_re = re.compile(r'^"(.+)"$')
 
-    def optionxform(self, optionstr):
+    def optionxform(
+            self,
+            optionstr: str
+    ) -> str:
         return optionstr
 
-    def get(self, section, option):
+    def get(
+            self,
+            section: str,
+            option: str
+    ) -> Any:
         value = super(Parser, self).get(section, option)
         if isinstance(value, str):
             value = self.remove_quotes_re.sub(r'\1', value)
@@ -58,18 +78,23 @@ class Parser(ConfigParser.RawConfigParser, object):
         return [(name, self.get(section, name)) for name in self.options(section)]
 
 
-def mkdir(dir_):
+def mkdir(dir_: str) -> None:
     '''
     This functions creates the `dir` directory if it doesn't exist. If `dir`
     already exists this function does nothing.
     '''
     try:
         os.mkdir(dir_)
-    except OSError as e:
-        assert e.errno == 17
+    except OSError as error:
+        if error.errno != 17:
+            raise error
 
 
-def get_newest(base_url, url_pattern, links):
+def get_newest(
+        base_url: str,
+        url_pattern: str,
+        links: "Iterable[str]"
+) -> tuple[str, datetime.datetime]:
     '''
     Returns a tuple with the newest url in the `links` list matching the
     pattern `url_pattern` and a datetime object representing the creation
@@ -104,7 +129,7 @@ def get_newest(base_url, url_pattern, links):
     return max(times, key=operator.itemgetter(1))
 
 
-def gfal_links(base_url):
+def gfal_links(base_url: str) -> list[str]:
     '''
     Returns a list of the urls contained in `base_url`.
     '''
@@ -112,19 +137,22 @@ def gfal_links(base_url):
     return ['/'.join((base_url, f)) for f in ctxt.listdir(str(base_url))]
 
 
-class _LinkCollector(HTMLParser.HTMLParser, object):
+class _LinkCollector(HTMLParser.HTMLParser):
     def __init__(self):
         super(_LinkCollector, self).__init__()
         self.links = []
 
-    def handle_starttag(self, tag, attrs):
+    def handle_starttag(
+            self, tag: str,
+            attrs: "Iterable[tuple[str, str]]"
+    ) -> None:
         if tag == 'a':
             self.links.append(
                 next(value for key, value in attrs if key == 'href')
             )
 
 
-def http_links(base_url):
+def http_links(base_url: str) -> list[str]:
     '''
     Returns a list of the urls contained in `base_url`.
     '''
@@ -169,7 +197,7 @@ protocol_funcs = {
 }
 
 
-def protocol(url):
+def protocol(url: str) -> str:
     '''
     Given the URL `url` returns a string with the protocol part.
     '''
@@ -180,25 +208,26 @@ def protocol(url):
     return proto
 
 
-def get_links(base_url):
+def get_links(base_url: str) -> list[str]:
     '''
     Given the URL `base_url` returns the URLs linked or contained in it.
     '''
     return protocol_funcs[protocol(base_url)]['links'](base_url)
 
 
-def download(url, filename):
+def download(url: str, filename: IO) -> None:
     '''
     Given the URL `url` downloads its contents on `filename`.
     '''
     return protocol_funcs[protocol(url)]['download'](url, filename)
 
 
-def parse_configuration(conf_dirs=__DUMPERCONFIGDIRS):
+def parse_configuration(conf_dirs: Optional[list[str]] = None) -> Parser:
     '''
     Parses the configuration for the endpoints contained in `conf_dir`.
     Returns a ConfParser.RawConfParser subclass instance.
     '''
+    conf_dirs = conf_dirs or __DUMPERCONFIGDIRS
     logger = logging.getLogger('auditor.srmdumps')
     if len(conf_dirs) == 0:
         logger.error('No configuration directory given to load SRM dumps paths')
@@ -213,18 +242,23 @@ def parse_configuration(conf_dirs=__DUMPERCONFIGDIRS):
     return configuration
 
 
-def download_rse_dump(rse, configuration, date='latest', destdir=DUMPS_CACHE_DIR):
+def download_rse_dump(
+        rse: str,
+        configuration: ConfigParser.RawConfigParser,
+        date: Optional[datetime.datetime] = None,
+        destdir: str = DUMPS_CACHE_DIR
+) -> tuple[str, datetime.datetime]:
     '''
     Downloads the dump for the given ddmendpoint. If this endpoint does not
-    follow the standarized method to publish the dumps it should have an
+    follow the standardized method to publish the dumps it should have an
     entry in the `configuration` object describing how to download the dump.
 
     `rse` is the DDMEndpoint name.
 
     `configuration` is a RawConfigParser subclass.
 
-    `date` is a datetime instance with the date of the desired dump or 'latest'
-    to download the lastest available dump.
+    `date` is a datetime instance with the date of the desired dump or None
+    to download the latest available dump.
 
     `destdir` is the directory where the dump will be saved (the final component
     in the path is created if it doesn't exist).
@@ -234,34 +268,71 @@ def download_rse_dump(rse, configuration, date='latest', destdir=DUMPS_CACHE_DIR
     '''
     logger = logging.getLogger('auditor.srmdumps')
     base_url, url_pattern = generate_url(rse, configuration)
-    if date == 'latest':
-        logger.debug('Looking for site dumps in: "%s"', base_url)
-        links = get_links(base_url)
-        url, date = get_newest(base_url, url_pattern, links)
-    else:
-        url = '{0}/{1}'.format(base_url, date.strftime(url_pattern))
 
     if not os.path.isdir(destdir):
         os.mkdir(destdir)
 
-    filename = '{0}_{1}_{2}_{3}'.format(
-        'ddmendpoint',
-        rse,
-        date.strftime('%d-%m-%Y'),
-        hashlib.sha1(url.encode()).hexdigest()
-    )
-    filename = re.sub(r'\W', '-', filename)
-    path = os.path.join(destdir, filename)
-
-    if not os.path.exists(path):
-        logger.debug('Trying to download: "%s"', url)
-        with temp_file(destdir, final_name=filename) as (f, _):
-            download(url, f)
+    # check for objectstores, which need to be handled differently
+    rse_id = get_rse_id(rse)
+    rse_attr = list_rse_attributes(rse_id)
+    if RseAttr.IS_OBJECT_STORE in rse_attr and rse_attr[RseAttr.IS_OBJECT_STORE] is not False:
+        tries = 1
+        if date is None:
+            # on objectstores, can't list dump files, so try the last N dates
+            date = datetime.datetime.now()
+            tries = OBJECTSTORE_NUM_TRIES
+        path = ''
+        while tries > 0:
+            url = '{0}/{1}'.format(base_url, date.strftime(url_pattern))
+
+            filename = '{0}_{1}_{2}_{3}'.format(
+                'ddmendpoint',
+                rse,
+                date.strftime('%d-%m-%Y'),
+                hashlib.sha1(url.encode()).hexdigest()
+            )
+            filename = re.sub(r'\W', '-', filename)
+            path = os.path.join(destdir, filename)
+            if not os.path.exists(path):
+                logger.debug('Trying to download: "%s"', url)
+                if RseAttr.SIGN_URL in rse_attr:
+                    url = get_signed_url(rse_id, rse_attr[RseAttr.SIGN_URL], 'read', url)
+                try:
+                    with temp_file(destdir, final_name=filename) as (f, _):
+                        download(url, f)
+                    tries = 0
+                except (HTTPDownloadFailed, gfal2.GError):
+                    tries -= 1
+                    date = date - datetime.timedelta(1)
+    else:
+        if date is None:
+            logger.debug('Looking for site dumps in: "%s"', base_url)
+            links = get_links(base_url)
+            url, date = get_newest(base_url, url_pattern, links)
+        else:
+            url = '{0}/{1}'.format(base_url, date.strftime(url_pattern))
+
+        filename = '{0}_{1}_{2}_{3}'.format(
+            'ddmendpoint',
+            rse,
+            date.strftime('%d-%m-%Y'),
+            hashlib.sha1(url.encode()).hexdigest()
+        )
+        filename = re.sub(r'\W', '-', filename)
+        path = os.path.join(destdir, filename)
+
+        if not os.path.exists(path):
+            logger.debug('Trying to download: "%s"', url)
+            with temp_file(destdir, final_name=filename) as (f, _):
+                download(url, f)
 
     return (path, date)
 
 
-def generate_url(rse, config):
+def generate_url(
+        rse: str,
+        config: ConfigParser.RawConfigParser
+) -> tuple[str, str]:
     '''
     :param rse: Name of the endpoint.
     :param config: RawConfigParser instance which may have configuration

rucio/daemons/automatix/__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/automatix/automatix.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");
@@ -16,40 +15,42 @@
 import functools
 import logging
 import random
+import secrets
 import tempfile
 import threading
 from configparser import NoOptionError, NoSectionError
 from datetime import datetime
 from json import load
 from os import remove, rmdir
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 import rucio.db.sqla.util
 from rucio.client import Client
 from rucio.client.uploadclient import UploadClient
 from rucio.common import exception
-from rucio.common.config import config_get, config_get_int, config_get_bool
+from rucio.common.config import config_get, config_get_bool, config_get_int
 from rucio.common.logging import setup_logging
 from rucio.common.stopwatch import Stopwatch
-from rucio.common.types import InternalScope
+from rucio.common.types import InternalScope, LoggerFunction
 from rucio.common.utils import execute, generate_uuid
 from rucio.core.monitor import MetricManager
 from rucio.core.scope import list_scopes
 from rucio.core.vo import map_vo
-from rucio.daemons.common import run_daemon
+from rucio.daemons.common import HeartbeatHandler, run_daemon
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
     from types import FrameType
-    from typing import Optional
 
-    from rucio.daemons.common import HeartbeatHandler
 
 METRICS = MetricManager(module=__name__)
 graceful_stop = threading.Event()
 DAEMON_NAME = "automatix"
 
 
-def get_data_distribution(inputfile: str):
+def get_data_distribution(
+        inputfile: str
+) -> tuple[dict[str, int], dict[str, Any]]:
     with open(inputfile) as data_file:
         data = load(data_file)
     probabilities = {}
@@ -62,8 +63,11 @@ def get_data_distribution(inputfile: str):
     return probabilities, data
 
 
-def choose_element(probabilities: dict, data: str) -> float:
-    rnd = random.uniform(0, 1)
+def choose_element(
+        probabilities: "Mapping[str, int]",
+        data: "Mapping[str, Any]"
+) -> dict[str, Any]:
+    rnd = random.uniform(0, 1)  # noqa: S311
     prob = 0
     for key in probabilities:
         prob = probabilities[key]
@@ -72,7 +76,11 @@ def choose_element(probabilities: dict, data: str) -> float:
     return data[key]
 
 
-def generate_file(fname: str, size: int, logger=logging.log) -> int:
+def generate_file(
+        fname: str,
+        size: int,
+        logger: LoggerFunction = logging.log
+) -> int:
     cmd = "/bin/dd if=/dev/urandom of=%s bs=%s count=1" % (fname, size)
     exitcode, out, err = execute(cmd)
     logger(logging.DEBUG, out)
@@ -80,7 +88,11 @@ def generate_file(fname: str, size: int, logger=logging.log) -> int:
     return exitcode
 
 
-def generate_didname(metadata: dict, dsn: str, did_type: str) -> str:
+def generate_didname(
+        metadata: "Mapping[str, str]",
+        dsn: Optional[str],
+        did_type: str
+) -> str:
     try:
         did_prefix = config_get("automatix", "did_prefix")
     except (NoOptionError, NoSectionError, RuntimeError):
@@ -102,11 +114,11 @@ def generate_didname(metadata: dict, dsn: str, did_type: str) -> str:
         elif field == "uuid":
             field_str = generate_uuid()
         elif field == "randint":
-            field_str = str(random.randint(0, 100000))
+            field_str = str(secrets.choice(range(0, 100001)))
         else:
             field_str = metadata.get(field, None)
             if not field_str:
-                field_str = str(random.randint(0, 100000))
+                field_str = str(secrets.choice(range(0, 100001)))
         file_name = "%s%s%s" % (file_name, separator, field_str)
     len_separator = len(separator)
     return file_name[len_separator:]
@@ -133,7 +145,7 @@ def automatix(inputfile: str, sleep_time: int, once: bool = False) -> None:
     )
 
 
-def run_once(heartbeat_handler: "HeartbeatHandler", inputfile: str, **_kwargs) -> bool:
+def run_once(heartbeat_handler: HeartbeatHandler, inputfile: str, **_kwargs) -> bool:
 
     _, _, logger = heartbeat_handler.live()
     try:
@@ -166,7 +178,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", inputfile: str, **_kwargs) -
     account = config_get("automatix", "account", raise_exception=False, default="root")
     scope = config_get("automatix", "scope", raise_exception=False, default="test")
     client = Client(account=account)
-    vo = map_vo(client.vo)
+    vo = map_vo(client.vo)  # type: ignore
     filters = {"scope": InternalScope("*", vo=vo)}
     scopes = list_scopes(filter_=filters)
     if InternalScope(scope, vo=vo) not in scopes:
@@ -230,7 +242,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", inputfile: str, **_kwargs) -
         upload_client = UploadClient(client)
         ret = upload_client.upload(files)
         if ret == 0:
-            logger(logging.INFO, "%s sucessfully registered" % dsn)
+            logger(logging.INFO, "%s successfully registered" % dsn)
             METRICS.counter(name="addnewdataset.done").inc()
             METRICS.counter(name="addnewfile.done").inc(nbfiles)
             METRICS.timer(name='datasetinjection').observe(stopwatch.elapsed)
@@ -274,7 +286,7 @@ def run(
         [thread.join(timeout=3.14) for thread in threads]
 
 
-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/badreplicas/__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");