rucio 37.6.0__py3-none-any.whl → 37.7.1__py3-none-any.whl

rucio/daemons/hermes/hermes.py

@@ -25,6 +25,7 @@ import random
 import re
 import smtplib
 import socket
+import ssl
 import sys
 import threading
 import time
@@ -343,6 +344,14 @@ def deliver_emails(
     :returns:                  List of message_id to delete
     """
 
+    smtp_host = config_get("messaging-hermes", "smtp_host", default='')
+    smtp_port = config_get_int("messaging-hermes", "smtp_port", default=25)
+    smtp_username = config_get("messaging-hermes", "smtp_username", default='')
+    smtp_password = config_get("messaging-hermes", "smtp_password", default='')
+    smtp_certfile = config_get("messaging-hermes", "smtp_certfile", default='')
+    smtp_keyfile = config_get("messaging-hermes", "smtp_keyfile", default='')
+    smtp_usessl = config_get_bool("messaging-hermes", "smtp_usessl", default=False)
+    smtp_usetls = config_get_bool("messaging-hermes", "smtp_usetls", default=False)
     email_from = config_get("messaging-hermes", "email_from")
     send_email = config_get_bool(
         "messaging-hermes", "send_email", raise_exception=False, default=True
@@ -357,12 +366,33 @@ def deliver_emails(
 
             try:
                 if send_email:
-                    smtp = smtplib.SMTP()
-                    smtp.connect()
-                    smtp.sendmail(
-                        msg["From"], message["payload"]["to"], msg.as_string()
-                    )
-                    smtp.quit()
+                    # Fall back to unauthenticated connection if no host is provided
+                    if not smtp_host:
+                        smtp = smtplib.SMTP()
+                        smtp.connect()
+                        smtp.sendmail(
+                            msg["From"], message["payload"]["to"], msg.as_string()
+                        )
+                        smtp.quit()
+                    else:
+                        ssl_context = None
+                        if smtp_certfile and smtp_keyfile:
+                            ssl_context = ssl.create_default_context()
+                            ssl_context.load_cert_chain(certfile=smtp_certfile, keyfile=smtp_keyfile)
+
+                        smtp_context = smtplib.SMTP(host=smtp_host, port=smtp_port)
+                        if not smtp_usetls and smtp_usessl:
+                            smtp_context = smtplib.SMTP_SSL(host=smtp_host, port=smtp_port, context=ssl_context)
+
+                        with smtp_context as smtp_server:
+                            if smtp_usetls:
+                                smtp_server.ehlo()  # not strictly necessary
+                                smtp_server.starttls(context=ssl_context)
+                            if smtp_username and smtp_password:
+                                smtp_server.login(smtp_username, smtp_password)
+                            smtp_server.sendmail(
+                                msg["From"], message["payload"]["to"], msg.as_string()
+                            )
                 to_delete.append(message["id"])
             except Exception as error:
                 logger(logging.ERROR, "Cannot send email : %s", str(error))

rucio/daemons/reaper/dark_reaper.py

@@ -29,6 +29,7 @@ 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.constants import DEFAULT_VO
 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
@@ -145,7 +146,7 @@ def run_once(
                                'url': pfn,
                                'duration': duration,
                                'protocol': prot.attributes['scheme']}
-                    if replica['scope'].vo != 'def':
+                    if replica['scope'].vo != DEFAULT_VO:
                         payload['vo'] = replica['scope'].vo
                     add_message('deletion-done', payload)
                     deleted_replicas.append(replica)
@@ -167,7 +168,7 @@ def run_once(
                                'url': pfn,
                                'reason': str(error),
                                'protocol': prot.attributes['scheme']}
-                    if replica['scope'].vo != 'def':
+                    if replica['scope'].vo != DEFAULT_VO:
                         payload['vo'] = replica['scope'].vo
                     add_message('deletion-failed', payload)
 
@@ -215,7 +216,7 @@ def run(
     :param exclude_rses: RSE expression to exclude RSEs from the Reaper.
     :param include_rses: RSE expression to include RSEs.
     :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.
+                If None, we either use all VOs if run from DEFAULT_VO, or the current VO otherwise.
     """
     rses = rses or []
     setup_logging(process_name=DAEMON_NAME)
@@ -229,7 +230,7 @@ def run(
     if not multi_vo:
         if vos:
             logging.warning('Ignoring argument vos, this is only applicable in a multi-VO setup.')
-        vos = ['def']
+        vos = [DEFAULT_VO]
     else:
         if vos:
             invalid = set(vos) - set([v['vo'] for v in list_vos()])

rucio/daemons/reaper/reaper.py

@@ -35,7 +35,7 @@ from sqlalchemy.exc import DatabaseError, IntegrityError
 import rucio.db.sqla.util
 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.constants import RseAttr, DEFAULT_VO
 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
@@ -81,7 +81,7 @@ def get_rses_to_process(
     :param exclude_rses:       RSE expression to exclude RSEs from the Reaper.
     :param include_rses:       RSE expression to include RSEs.
     :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"
+                               If None, we either use all VOs if run from DEFAULT_VO
 
     :returns: A list of RSEs to process
     """
@@ -89,7 +89,7 @@ def get_rses_to_process(
     if not multi_vo:
         if vos:
             logging.log(logging.WARNING, 'Ignoring argument vos, this is only applicable in a multi-VO setup.')
-        vos = ['def']
+        vos = [DEFAULT_VO]
     else:
         if vos:
             invalid = set(vos) - set([v['vo'] for v in list_vos()])
@@ -156,7 +156,7 @@ def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info,
                              'protocol': prot.attributes['scheme'],
                              'datatype': replica['datatype']}
             try:
-                if replica['scope'].vo != 'def':
+                if replica['scope'].vo != DEFAULT_VO:
                     deletion_dict['vo'] = replica['scope'].vo
                 logger(logging.DEBUG, 'Deletion ATTEMPT of %s:%s as %s on %s', replica['scope'], replica['name'], replica['pfn'], rse_name)
                 # For STAGING RSEs, no physical deletion
@@ -232,7 +232,7 @@ def delete_from_storage(heartbeat_handler, hb_payload, replicas, prot, rse_info,
                        'url': replica['pfn'],
                        'reason': str(error),
                        'protocol': prot.attributes['scheme']}
-            if replica['scope'].vo != 'def':
+            if replica['scope'].vo != DEFAULT_VO:
                 payload['vo'] = replica['scope'].vo
             add_message('deletion-failed', payload)
         logger(logging.INFO, 'Cannot connect to %s. RSE will be temporarily excluded.', rse_name)
@@ -400,7 +400,7 @@ def reaper(
     :param include_rses:           RSE expression to include RSEs.
     :param exclude_rses:           RSE expression to exclude RSEs from the Reaper.
     :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.
+                                   If None, we either use all VOs if run from DEFAULT_VO, or the current VO otherwise.
     :param chunk_size:             The size of chunk for deletion.
     :param once:                   If True, only runs one iteration of the main loop.
     :param greedy:                 If True, delete right away replicas with tombstone.
@@ -703,7 +703,7 @@ def run(
     :param exclude_rses:           RSE expression to exclude RSEs from the Reaper.
     :param include_rses:           RSE expression to include RSEs.
     :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",
+                                   If None, we either use all VOs if run from DEFAULT_VO,
                                    or the current VO otherwise.
     :param delay_seconds:          The delay to query replicas in BEING_DELETED state.
     :param sleep_time:             Time between two cycles.

rucio/daemons/replicarecoverer/suspicious_replica_recoverer.py

@@ -31,7 +31,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 import rucio.db.sqla.util
 from rucio.common.config import config_get, config_get_bool
-from rucio.common.constants import SuspiciousAvailability
+from rucio.common.constants import DEFAULT_VO, SuspiciousAvailability
 from rucio.common.exception import DatabaseException, DuplicateRule, VONotFound
 from rucio.common.logging import setup_logging
 from rucio.common.types import InternalAccount, LoggerFunction
@@ -145,7 +145,7 @@ def declare_suspicious_replicas_bad(
     :param nattempts: The minimum number of appearances in the bad_replica DB table
                       in order to appear in the resulting list of replicas for recovery.
     :param vos: VOs on which to look for RSEs. Only used in multi-VO mode.
-                If empty, we either use all VOs if run from "def",
+                If empty, we either use all VOs if run from DEFAULT_VO,
     :param limit_suspicious_files_on_rse: Maximum number of suspicious replicas on an RSE before that RSE
                                           is considered problematic and the suspicious replicas on that RSE
                                           are labeled as 'TEMPORARY_UNAVAILABLE'.
@@ -182,7 +182,7 @@ def run_once(heartbeat_handler: Any, younger_than: int, nattempts: int, vos: "Op
     if not multi_vo:
         if vos:
             logger(logging.WARNING, 'Ignoring argument vos, this is only applicable in a multi-VO setup.')
-        vos = ['def']
+        vos = [DEFAULT_VO]
     else:
         if vos:
             invalid = set(vos) - set([v['vo'] for v in list_vos()])

rucio/daemons/tracer/kronos.py

@@ -30,6 +30,7 @@ from typing import TYPE_CHECKING, Optional
 
 import rucio.db.sqla.util
 from rucio.common.config import config_get, config_get_bool, config_get_int, config_get_list
+from rucio.common.constants import DEFAULT_VO
 from rucio.common.exception import DatabaseException, RSENotFound
 from rucio.common.logging import setup_logging
 from rucio.common.stomp_utils import StompConnectionManager
@@ -143,7 +144,7 @@ class AMQConsumer:
         rses = []
         for report in self.__reports:
             if 'vo' not in report:
-                report['vo'] = 'def'
+                report['vo'] = DEFAULT_VO
 
             try:
                 # Identify suspicious files
@@ -299,7 +300,7 @@ class AMQConsumer:
                                 'usrdn': 'someuser',
                                 'clientState': 'DONE',
                                 'eventVersion': replica['eventVersion']}
-                    if replica['scope'].vo != 'def':
+                    if replica['scope'].vo != DEFAULT_VO:
                         resubmit['vo'] = replica['scope'].vo
                     self.__conn.send(body=jdumps(resubmit), destination=self.__queue, headers={'appversion': 'rucio', 'resubmitted': '1'})
                     METRICS.counter('sent_resubmitted').inc()

rucio/daemons/transmogrifier/transmogrifier.py

@@ -124,7 +124,7 @@ def __split_rule_select_rses(
     weight: int,
     rse_expression: str,
     copies: int,
-    blocklisted_rse_id: list,
+    blocklisted_rse_ids: list,
     logger: LoggerFunction,
 ) -> tuple[list, bool, bool]:
     """
@@ -138,7 +138,7 @@ def __split_rule_select_rses(
     :param weight: The weight of the rule.
     :param rse_expression: The RSE expression of the rule.
     :param copies: The number of copies.
-    :param blocklisted_rse_id: The list of blocklisted_rse_id.
+    :param blocklisted_rse_ids: The list of blocklisted rse_ids.
     :param logger: The logger.
     :return: A tuple with list selected_rses, and 2 booleans create_rule, wont_reevaluate.
     """
@@ -172,7 +172,7 @@ def __split_rule_select_rses(
                 copies=copies,
                 size=0,
                 preferred_rses=preferred_rses,
-                blocklist=blocklisted_rse_id,
+                blocklist=blocklisted_rse_ids,
             )
             wont_reevaluate = True
             break
@@ -184,26 +184,22 @@ def __split_rule_select_rses(
         ) as error:
             logger(
                 logging.WARNING,
-                'Problem getting RSEs for subscription "%s" for account %s : %s. %s'
-                % (
-                    subscription_name,
-                    account,
-                    str(error),
-                    'Try including blocklisted sites' if attempt == 0 else 'Skipping rule creation.'
-                ),
+                'Problem getting RSEs for subscription "%s" for account %s : %s. %s',
+                subscription_name,
+                account,
+                str(error),
+                'Try including blocklisted sites' if attempt == 0 else 'Skipping rule creation.'
             )
             # Now including the blocklisted sites
-            blocklisted_rse_id = []
+            blocklisted_rse_ids = []
             METRICS.counter(name="addnewrule.errortype.{exception}").labels(exception=str(error.__class__.__name__)).inc()
             wont_reevaluate = True
         except Exception as error:
             logger(
                 logging.ERROR,
-                "Problem resolving RSE expression %s : %s"
-                % (
-                    rse_expression,
-                    str(error),
-                )
+                "Problem resolving RSE expression %s : %s",
+                rse_expression,
+                str(error),
             )
     if len(preferred_rses) - len(preferred_unmatched) >= copies:
         create_rule = False
@@ -242,6 +238,7 @@ def get_subscriptions(logger: LoggerFunction = logging.log) -> list[dict]:
                     break
                 if rule.get("copies") == "*":
                     rule["copies"] = len(list_rses_from_expression)
+                    rule["wildcard"] = True
                     overwrite_rules = True
             if skip_sub:
                 continue
@@ -272,7 +269,7 @@ def get_subscriptions(logger: LoggerFunction = logging.log) -> list[dict]:
             subscriptions.extend(sub_dict[priority])
         logger(logging.INFO, "%i active subscriptions", len(subscriptions))
     except SubscriptionNotFound as error:
-        logger(logging.WARNING, "No subscriptions defined: %s" % (str(error)))
+        logger(logging.WARNING, "No subscriptions defined: %s", (str(error)))
         return []
     except TypeError as error:
         logger(
@@ -307,7 +304,7 @@ def __is_matching_subscription(
     try:
         filter_string = loads(subscription["filter"])
     except ValueError as error:
-        logging.error("%s : Subscription will be skipped" % error)
+        logging.error("%s : Subscription will be skipped", error)
         return False
     # Loop over the keys of filter_string for subscription
     for key in filter_string:
@@ -399,7 +396,7 @@ def select_algorithm(
     selected_rses = {}
     for rule_id in rule_ids:
         rule = get_rule(rule_id)
-        logging.debug("In select_algorithm, %s", str(rule))
+        logger(logging.DEBUG, "In select_algorithm, %s", str(rule))
         rse = rule["rse_expression"]
         vo = rule["account"].vo
         if rse_exists(rse, vo=vo):
@@ -439,7 +436,7 @@ def select_algorithm(
                     weight=rule.get("weight"),
                     rse_expression=rse_expression,
                     copies=rule.get('copies'),
-                    blocklisted_rse_id=params['blocklisted_rse_id'],
+                    blocklisted_rse_ids=params['blocklisted_rse_ids'],
                     logger=logger,
                 )
                 dict_selected_rses = {}
@@ -487,7 +484,8 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
 
     worker_number, total_workers, logger = heartbeat_handler.live()
     stopwatch = Stopwatch()
-    blocklisted_rse_id = [rse["id"] for rse in list_rses({"availability_write": False})]
+    block_listed = {rse['rse']: rse["id"] for rse in list_rses({"availability_write": False})}
+    blocklisted_rse_ids = list(block_listed.values())
     identifiers = []
     #  List all the active subscriptions
     subscriptions = get_subscriptions(logger=logger)
@@ -535,6 +533,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                     #  Get all the rule and subscription parameters
                     rule_dict = __get_rule_dict(rule_dict, subscription)
                     weight = rule_dict.get("weight", None)
+                    ignore_availability = rule_dict.get("ignore_availability", False)
                     source_replica_expression = rule_dict.get(
                         "source_replica_expression", None
                     )
@@ -551,7 +550,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                         params['rse_expression'] = rule_dict.get("rse_expression")
                         params['subscription_id'] = subscription["id"]
                         params['subscription_name'] = subscription["name"]
-                        params['blocklisted_rse_id'] = blocklisted_rse_id
+                        params['blocklisted_rse_ids'] = blocklisted_rse_ids
                         if rule_dict.get("associated_site_idx", None):
                             params["associated_site_idx"] = rule_dict.get(
                                 "associated_site_idx", None
@@ -583,7 +582,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                             weight=weight,
                             rse_expression=rule_dict.get("rse_expression"),
                             copies=copies,
-                            blocklisted_rse_id=blocklisted_rse_id,
+                            blocklisted_rse_ids=blocklisted_rse_ids,
                             logger=logger,
                         )
                         copies = 1
@@ -595,20 +594,26 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                     nb_rule = 0
                     #  Try to create the rule
                     logger(logging.DEBUG, 'selected_rses : %s' % selected_rses)
-                    try:
-                        for rse in selected_rses:
-                            if isinstance(selected_rses, dict):
-                                #  selected_rses is a dictionary only when split_rule is True or for chained subscriptions
-                                source_replica_expression = selected_rses[rse].get(
-                                    "source_replica_expression",
-                                    None,
-                                )
-                                weight = selected_rses[rse].get("weight", None)
-                            logger(
-                                logging.INFO,
-                                "Will insert one rule for %s:%s on %s"
-                                % (did["scope"], did["name"], rse),
+                    for rse in selected_rses:
+                        if isinstance(selected_rses, dict):
+                            #  selected_rses is a dictionary only when split_rule is True or for chained subscriptions
+                            source_replica_expression = selected_rses[rse].get(
+                                "source_replica_expression",
+                                None,
                             )
+                            weight = selected_rses[rse].get("weight", None)
+                        logger(
+                            logging.INFO,
+                            "Will insert one rule for %s:%s on %s",
+                            did["scope"], did["name"], rse,
+                        )
+                        if rse in block_listed and rule_dict.get("wildcard"):
+                            if ignore_availability:
+                                logger(logging.WARNING, "RSE %s is unavailable, but wildcard number of copies is used with ignore_availability option. Creating a rule", rse)
+                            else:
+                                logger(logging.INFO, "RSE %s is unavailable and wildcard number of copies is used. Skipping rule creation", rse)
+                                continue
+                        try:
                             rule_ids = add_rule(
                                 dids=[
                                     {
@@ -627,9 +632,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                                 source_replica_expression=source_replica_expression,
                                 activity=rule_dict.get("activity"),
                                 purge_replicas=rule_dict.get("purge_replicas", False),
-                                ignore_availability=rule_dict.get(
-                                    "ignore_availability", None
-                                ),
+                                ignore_availability=ignore_availability,
                                 comment=rule_dict.get("comment"),
                                 delay_injection=rule_dict.get("delay_injection"),
                             )
@@ -640,41 +643,40 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
                             if split_rule:
                                 success = True
 
-                        METRICS.counter("addnewrule.done").inc(nb_rule)
-                        METRICS.counter("addnewrule.activity.{activity}").labels(activity="".join(rule_dict.get("activity").split())).inc(nb_rule)
-                        success = True
-                    except (
-                        InvalidReplicationRule,
-                        InvalidRuleWeight,
-                        InvalidRSEExpression,
-                        StagingAreaRuleRequiresLifetime,
-                        DuplicateRule,
-                    ) as error:
-                        # Errors that won't be retried
-                        success = True
-                        logger(logging.ERROR, str(error))
-                        METRICS.counter("addnewrule.errortype.{exception}").labels(exception=str(error.__class__.__name__)).inc()
-                    except Exception:
-                        # Errors that will be retried
-                        METRICS.counter("addnewrule.errortype.{exception}").labels(exception="unknown").inc()
-                        logger(logging.ERROR, "Unexpected error", exc_info=True)
+                        except (
+                            InvalidReplicationRule,
+                            InvalidRuleWeight,
+                            InvalidRSEExpression,
+                            StagingAreaRuleRequiresLifetime,
+                            DuplicateRule,
+                        ) as error:
+                            # Errors that won't be retried
+                            success = True
+                            logger(logging.ERROR, str(error))
+                            METRICS.counter("addnewrule.errortype.{exception}").labels(exception=str(error.__class__.__name__)).inc()
+                        except Exception:
+                            # Errors that will be retried
+                            METRICS.counter("addnewrule.errortype.{exception}").labels(exception="unknown").inc()
+                            logger(logging.ERROR, "Unexpected error", exc_info=True)
+
+                    METRICS.counter("addnewrule.done").inc(nb_rule)
+                    METRICS.counter("addnewrule.activity.{activity}").labels(activity="".join(rule_dict.get("activity").split())).inc(nb_rule)
+                    success = True
 
                     did_success = did_success and success
                     if not success:
                         logger(
                             logging.ERROR,
-                            "Rule for %s:%s on %s cannot be inserted"
-                            % (
-                                did["scope"],
-                                did["name"],
-                                rule_dict.get("rse_expression"),
-                            ),
+                            "Rule for %s:%s on %s cannot be inserted",
+                            did["scope"],
+                            did["name"],
+                            rule_dict.get("rse_expression"),
                         )
                     else:
                         logger(
                             logging.INFO,
-                            "%s rule(s) inserted in %f seconds"
-                            % (str(nb_rule), time.time() - stime),
+                            "%s rule(s) inserted in %f seconds",
+                            str(nb_rule), time.time() - stime,
                         )
 
         if did_success:
@@ -697,7 +699,7 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
     flag_stopwatch = Stopwatch()
     for identifier in chunks(identifiers, 100):
         set_new_dids(identifier, None)
-    logger(logging.DEBUG, "Time to set the new flag : %f" % flag_stopwatch.elapsed)
+    logger(logging.DEBUG, "Time to set the new flag : %f", flag_stopwatch.elapsed)
 
     stopwatch.stop()
 
@@ -709,9 +711,9 @@ def run_once(heartbeat_handler: "HeartbeatHandler", bulk: int, **_kwargs) -> boo
         )
     logger(
         logging.INFO,
-        "It took %f seconds to process %i DIDs" % (stopwatch.elapsed, len(identifiers)),
+        "It took %f seconds to process %i DIDs", stopwatch.elapsed, len(identifiers),
     )
-    logger(logging.DEBUG, "DIDs processed : %s" % (str(identifiers)))
+    logger(logging.DEBUG, "DIDs processed : %s", str(identifiers))
     METRICS.counter(name="transmogrifier.job.done").inc(1)
     METRICS.timer("job.duration").observe(stopwatch.elapsed)
     must_sleep = True

rucio/daemons/undertaker/undertaker.py

@@ -29,6 +29,7 @@ from typing import TYPE_CHECKING
 from sqlalchemy.exc import DatabaseError
 
 import rucio.db.sqla.util
+from rucio.common.constants import DEFAULT_VO
 from rucio.common.exception import DatabaseException, RuleNotFound, UnsupportedOperation
 from rucio.common.logging import setup_logging
 from rucio.common.types import InternalAccount
@@ -90,7 +91,7 @@ def run_once(paused_dids: dict[tuple, datetime], chunk_size: int, heartbeat_hand
             _, _, logger = heartbeat_handler.live()
             try:
                 logger(logging.INFO, 'Receive %s dids to delete', len(chunk))
-                delete_dids(dids=chunk, account=InternalAccount('root', vo='def'), expire_rules=True)
+                delete_dids(dids=chunk, account=InternalAccount('root', vo=DEFAULT_VO), expire_rules=True)
                 logger(logging.INFO, 'Delete %s dids', len(chunk))
                 METRICS.counter(name='undertaker.delete_dids').inc(len(chunk))
             except RuleNotFound as error:

rucio/db/sqla/models.py

@@ -29,7 +29,7 @@ from sqlalchemy.types import LargeBinary
 # and it must be renamed to avoid conflicts with the policy package schema modules
 from rucio.common import schema as common_schema
 from rucio.common import utils
-from rucio.common.constants import TransferLimitDirection
+from rucio.common.constants import DEFAULT_VO, TransferLimitDirection
 from rucio.common.types import InternalAccount, InternalScope  # noqa: TCH001 (types are needed by SQLAlchemy)
 from rucio.db.sqla.constants import (
     AccountStatus,
@@ -776,7 +776,7 @@ class RSE(BASE, SoftModelBase):
     __tablename__ = 'rses'
     id: Mapped[str] = mapped_column(GUID(), default=utils.generate_uuid)
     rse: Mapped[str] = mapped_column(String(255))
-    vo: Mapped[str] = mapped_column(String(3), nullable=False, server_default='def')
+    vo: Mapped[str] = mapped_column(String(3), nullable=False, server_default=DEFAULT_VO)
     rse_type: Mapped[RSEType] = mapped_column(Enum(RSEType, name='RSES_TYPE_CHK',
                                                    create_constraint=True,
                                                    values_callable=lambda obj: [e.value for e in obj]),

rucio/db/sqla/util.py

@@ -33,6 +33,7 @@ from sqlalchemy.sql.expression import select, text
 from rucio import alembicrevision
 from rucio.common.cache import MemcacheRegion
 from rucio.common.config import config_get, config_get_list
+from rucio.common.constants import DEFAULT_VO
 from rucio.common.schema import get_schema_value
 from rucio.common.types import InternalAccount, LoggerFunction
 from rucio.common.utils import generate_uuid
@@ -136,7 +137,7 @@ def create_base_vo() -> None:
 
     session_scoped = get_session()
 
-    vo = models.VO(vo='def', description='Default base VO', email='N/A')
+    vo = models.VO(vo=DEFAULT_VO, description='Default base VO', email='N/A')
     with session_scoped() as s:
         with s.begin():
             s.add_all([vo])
@@ -172,7 +173,7 @@ def create_root_account() -> None:
     else:
         access = 'root'
 
-    account = models.Account(account=InternalAccount(access, 'def'), account_type=AccountType.SERVICE, status=AccountStatus.ACTIVE)
+    account = models.Account(account=InternalAccount(access, DEFAULT_VO), account_type=AccountType.SERVICE, status=AccountStatus.ACTIVE)
 
     salt = urandom(255)
     salted_password = salt + up_pwd.encode()