DIRAC 9.0.0a42__py3-none-any.whl → 9.0.7__py3-none-any.whl

DIRAC/Core/Utilities/TimeUtilities.py

@@ -1,260 +1,17 @@
-"""
-DIRAC TimeUtilities module
-Support for basic Date and Time operations
-based on system datetime module.
-
-It provides common interface to UTC timestamps,
-converter to string types and back.
-
-Useful timedelta constant are also provided to
-define time intervals.
-
-Notice: datetime.timedelta objects allow multiplication and division by interger
-but not by float. Thus:
-
-  - DIRAC.TimeUtilities.second * 1.5             is not allowed
-  - DIRAC.TimeUtilities.second * 3 / 2           is allowed
+"""Backward compatibility wrapper - moved to DIRACCommon
 
-An timeInterval class provides a method to check
-if a give datetime is in the defined interval.
+This module has been moved to DIRACCommon.Core.Utilities.TimeUtilities to avoid
+circular dependencies and allow DiracX to use these utilities without
+triggering DIRAC's global state initialization.
 
+All exports are maintained for backward compatibility.
 """
-import datetime
-import sys
-import time
-
-from DIRAC import gLogger
-
-# Some useful constants for time operations
-microsecond = datetime.timedelta(microseconds=1)
-second = datetime.timedelta(seconds=1)
-minute = datetime.timedelta(minutes=1)
-hour = datetime.timedelta(hours=1)
-day = datetime.timedelta(days=1)
-week = datetime.timedelta(days=7)
-
-
-def timeThis(method):
-    """Function to be used as a decorator for timing other functions/methods"""
-
-    def timed(*args, **kw):
-        """What actually times"""
-        ts = time.time()
-        result = method(*args, **kw)
-        if sys.stdout.isatty():
-            return result
-        te = time.time()
-
-        pre = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC ")
-
-        try:
-            pre += args[0].log.getName() + "/" + args[0].log.getSubName() + "   TIME: " + args[0].transString
-        except AttributeError:
-            try:
-                pre += args[0].log.getName() + "    TIME: " + args[0].transString
-            except AttributeError:
-                try:
-                    pre += args[0].log.getName() + "/" + args[0].log.getSubName() + "   TIME: "
-                except AttributeError:
-                    pre += "TIME: "
-        except IndexError:
-            pre += "TIME: "
-
-        argsLen = ""
-        if args:
-            try:
-                if isinstance(args[1], (list, dict)):
-                    argsLen = f"arguments len: {len(args[1])}"
-            except IndexError:
-                if kw:
-                    try:
-                        if isinstance(list(list(kw.items())[0])[1], (list, dict)):
-                            argsLen = f"arguments len: {len(list(list(kw.items())[0])[1])}"
-                    except IndexError:
-                        argsLen = ""
-
-        gLogger.info(f"{pre} Exec time ===> function {method.__name__!r} {argsLen} -> {te - ts:2.2f} sec")
-        return result
-
-    return timed
-
-
-def toEpoch(dateTimeObject=None):
-    """
-    Get seconds since epoch. Accepts datetime or date objects
-    """
-    return toEpochMilliSeconds(dateTimeObject) // 1000
+from functools import partial
 
+# Re-export everything from DIRACCommon for backward compatibility
+from DIRACCommon.Core.Utilities.TimeUtilities import *  # noqa: F401, F403
 
-def toEpochMilliSeconds(dateTimeObject=None):
-    """
-    Get milliseconds since epoch
-    """
-    if dateTimeObject is None:
-        dateTimeObject = datetime.datetime.utcnow()
-    if dateTimeObject.resolution == datetime.timedelta(days=1):
-        # Add time information corresponding to midnight UTC if it's a datetime.date
-        dateTimeObject = datetime.datetime.combine(
-            dateTimeObject, datetime.time.min.replace(tzinfo=datetime.timezone.utc)
-        )
-    posixTime = dateTimeObject.replace(tzinfo=datetime.timezone.utc).timestamp()
-    return int(posixTime * 1000)
-
-
-def fromEpoch(epoch):
-    """
-    Get datetime object from epoch
-    """
-    # Check if the timestamp is in milliseconds
-    if epoch > 10**17:  # nanoseconds
-        epoch /= 1000**3
-    elif epoch > 10**14:  # microseconds
-        epoch /= 1000**2
-    elif epoch > 10**11:  # milliseconds
-        epoch /= 1000
-    return datetime.datetime.utcfromtimestamp(epoch)
-
-
-def toString(myDate=None):
-    """
-    Convert to String
-    if argument type is neither _dateTimeType, _dateType, nor _timeType
-    the current dateTime converted to String is returned instead
-
-    Notice: datetime.timedelta are converted to strings using the format:
-      [day] days [hour]:[min]:[sec]:[microsec]
-      where hour, min, sec, microsec are always positive integers,
-      and day carries the sign.
-    To keep internal consistency we are using:
-      [hour]:[min]:[sec]:[microsec]
-      where min, sec, microsec are always positive integers and hour carries the sign.
-    """
-    if isinstance(myDate, datetime.date):
-        return str(myDate)
-
-    elif isinstance(myDate, datetime.time):
-        return "%02d:%02d:%02d.%06d" % (
-            myDate.days * 24 + myDate.seconds / 3600,
-            myDate.seconds % 3600 / 60,
-            myDate.seconds % 60,
-            myDate.microseconds,
-        )
-    else:
-        return toString(datetime.datetime.utcnow())
-
-
-def fromString(myDate=None):
-    """
-    Convert date/time/datetime String back to appropriated objects
-
-    The format of the string it is assume to be that returned by toString method.
-    See notice on toString method
-    On Error, return None
-
-    :param myDate: the date string to be converted
-    :type myDate: str or datetime.datetime
-    """
-    if isinstance(myDate, datetime.datetime):
-        return myDate
-    if isinstance(myDate, str):
-        if myDate.find(" ") > 0:
-            dateTimeTuple = myDate.split(" ")
-            dateTuple = dateTimeTuple[0].split("-")
-            try:
-                return datetime.datetime(year=dateTuple[0], month=dateTuple[1], day=dateTuple[2]) + fromString(
-                    dateTimeTuple[1]
-                )
-                # return datetime.datetime.utcnow().combine( fromString( dateTimeTuple[0] ),
-                #                                   fromString( dateTimeTuple[1] ) )
-            except Exception:
-                try:
-                    return datetime.datetime(
-                        year=int(dateTuple[0]), month=int(dateTuple[1]), day=int(dateTuple[2])
-                    ) + fromString(dateTimeTuple[1])
-                except ValueError:
-                    return None
-                # return datetime.datetime.utcnow().combine( fromString( dateTimeTuple[0] ),
-                #                                   fromString( dateTimeTuple[1] ) )
-        elif myDate.find(":") > 0:
-            timeTuple = myDate.replace(".", ":").split(":")
-            try:
-                if len(timeTuple) == 4:
-                    return datetime.timedelta(
-                        hours=int(timeTuple[0]),
-                        minutes=int(timeTuple[1]),
-                        seconds=int(timeTuple[2]),
-                        microseconds=int(timeTuple[3]),
-                    )
-                elif len(timeTuple) == 3:
-                    try:
-                        return datetime.timedelta(
-                            hours=int(timeTuple[0]),
-                            minutes=int(timeTuple[1]),
-                            seconds=int(timeTuple[2]),
-                            microseconds=0,
-                        )
-                    except ValueError:
-                        return None
-                else:
-                    return None
-            except Exception:
-                return None
-        elif myDate.find("-") > 0:
-            dateTuple = myDate.split("-")
-            try:
-                return datetime.date(int(dateTuple[0]), int(dateTuple[1]), int(dateTuple[2]))
-            except Exception:
-                return None
-
-    return None
-
-
-class timeInterval:
-    """
-    Simple class to define a timeInterval object able to check if a given
-    dateTime is inside
-    """
-
-    def __init__(self, initialDateTime, intervalTimeDelta):
-        """
-        Initialization method, it requires the initial dateTime and the
-        timedelta that define the limits.
-        The upper limit is not included thus it is [begin,end)
-        If not properly initialized an error flag is set, and subsequent calls
-        to any method will return None
-        """
-        if not isinstance(initialDateTime, datetime.datetime) or not isinstance(intervalTimeDelta, datetime.timedelta):
-            self.__error = True
-            return None
-        self.__error = False
-        if intervalTimeDelta.days < 0:
-            self.__startDateTime = initialDateTime + intervalTimeDelta
-            self.__endDateTime = initialDateTime
-        else:
-            self.__startDateTime = initialDateTime
-            self.__endDateTime = initialDateTime + intervalTimeDelta
-
-    def includes(self, myDateTime):
-        """ """
-        if self.__error:
-            return None
-        if not isinstance(myDateTime, datetime.datetime):
-            return None
-        if myDateTime < self.__startDateTime:
-            return False
-        if myDateTime >= self.__endDateTime:
-            return False
-        return True
-
-
-def queryTime(f):
-    """Decorator to measure the function call time"""
+from DIRAC import gLogger
 
-    def measureQueryTime(*args, **kwargs):
-        start = time.time()
-        result = f(*args, **kwargs)
-        if result["OK"] and "QueryTime" not in result:
-            result["QueryTime"] = time.time() - start
-        return result
 
-    return measureQueryTime
+timeThis = partial(timeThis, logger_info=gLogger.info)

DIRAC/Core/Utilities/test/Test_JDL.py

@@ -19,9 +19,6 @@ def jdl_monkey_business(monkeypatch):
     monkeypatch.setattr("DIRAC.Core.Base.API.getSites", lambda: S_OK(["LCG.IN2P3.fr"]))
     monkeypatch.setattr("DIRAC.WorkloadManagementSystem.Utilities.JobModel.getSites", lambda: S_OK(["LCG.IN2P3.fr"]))
     monkeypatch.setattr("DIRAC.Interfaces.API.Job.getDIRACPlatforms", lambda: S_OK("x86_64-slc6-gcc49-opt"))
-    monkeypatch.setattr(
-        "DIRAC.WorkloadManagementSystem.Utilities.JobModel.getDIRACPlatforms", lambda: S_OK("x86_64-slc6-gcc49-opt")
-    )
     yield
 
 

DIRAC/Core/Utilities/test/Test_Profiler.py

@@ -29,50 +29,50 @@ def test_base():
     time.sleep(1)
     p = Profiler(mainProcess.pid)
     res = p.pid()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.status()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.runningTime()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
 
     res = p.memoryUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.memoryUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.vSizeUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.vSizeUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.vSizeUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.vSizeUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.numThreads()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.numThreads(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.cpuPercentage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] >= 0
     resWC = p.cpuPercentage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] >= 0
     assert resWC["Value"] >= res["Value"]
 
@@ -88,13 +88,13 @@ def test_cpuUsage():
     time.sleep(2)
     p = Profiler(mainProcess.pid)
     res = p.pid()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.status()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
 
     # user
     res = p.cpuUsageUser()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageUser(withChildren=True)
     assert resC["OK"] is True
@@ -102,7 +102,7 @@ def test_cpuUsage():
     assert resC["Value"] >= res["Value"]
 
     res = p.cpuUsageUser()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageUser(withChildren=True)
     assert resC["OK"] is True
@@ -121,15 +121,15 @@ def test_cpuUsage():
 
     # system
     res = p.cpuUsageSystem()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] >= 0
     resWC = p.cpuUsageSystem(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] >= 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.cpuUsageSystem()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageSystem(withChildren=True)
     assert resC["OK"] is True

DIRAC/Core/scripts/dirac_agent.py

@@ -25,7 +25,7 @@ def main():
     localCfg.setConfigurationForAgent(agentName)
     localCfg.addDefaultEntry("/DIRAC/Security/UseServerCertificate", "yes")
     localCfg.addDefaultEntry("LogColor", True)
-    resultDict = localCfg.loadUserData()
+    resultDict = localCfg.loadUserData(requireSuccessfulSync=True)
     if not resultDict["OK"]:
         gLogger.error("There were errors when loading configuration", resultDict["Message"])
         sys.exit(1)

DIRAC/Core/scripts/dirac_apptainer_exec.py

@@ -1,47 +1,48 @@
-""" Starts a DIRAC command inside an apptainer container.
-"""
+#!/usr/bin/env python
+"""Starts a DIRAC command inside an apptainer container."""
 
 import os
-import shutil
 import sys
+from pathlib import Path
 
 import DIRAC
 from DIRAC import S_ERROR, gConfig, gLogger
 from DIRAC.Core.Base.Script import Script
+from DIRAC.Core.Security.Locations import getCAsLocation, getProxyLocation, getVOMSLocation
+from DIRAC.Core.Utilities.Os import safe_listdir
 from DIRAC.Core.Utilities.Subprocess import systemCall
 
-CONTAINER_WRAPPER = """#!/bin/bash
 
-echo "Starting inner container wrapper scripts (no install) at `date`."
-export DIRAC=%(dirac_env_var)s
-export DIRACOS=%(diracos_env_var)s
-# In any case we need to find a bashrc, and a cfg
-source %(rc_script)s
-%(command)s
-echo "Finishing inner container wrapper scripts at `date`."
-"""
+def generate_container_wrapper(dirac_env_var, diracos_env_var, etc_dir, rc_script, command, include_proxy=True):
+    lines = [
+        "#!/bin/bash",
+        f"export DIRAC={dirac_env_var}",
+        f"export DIRACOS={diracos_env_var}",
+    ]
 
-CONTAINER_DEFROOT = ""  # Should add something like "/cvmfs/dirac.egi.eu/container/apptainer/alma9/x86_64"
+    if include_proxy:
+        lines.append("export X509_USER_PROXY=/etc/proxy")
 
+    lines.extend(
+        [
+            "export X509_CERT_DIR=/etc/grid-security/certificates",
+            "export X509_VOMS_DIR=/etc/grid-security/vomsdir",
+            "export X509_VOMSES=/etc/grid-security/vomses",
+            f"export DIRACSYSCONFIG={etc_dir}/dirac.cfg",
+            f"source {rc_script}",
+            command,
+        ]
+    )
 
-def getEnv():
-    """Gets the environment for use within the container.
-    We blank almost everything to prevent contamination from the host system.
-    """
+    return "\n".join(lines)
 
-    payloadEnv = {k: v for k, v in os.environ.items()}
-    payloadEnv["TMP"] = "/tmp"
-    payloadEnv["TMPDIR"] = "/tmp"
-    payloadEnv["X509_USER_PROXY"] = os.path.join("tmp", "proxy")
-    payloadEnv["DIRACSYSCONFIG"] = os.path.join("tmp", "dirac.cfg")
 
-    return payloadEnv
+CONTAINER_DEFROOT = ""  # Should add something like "/cvmfs/dirac.egi.eu/container/apptainer/alma9/x86_64"
 
 
 @Script()
 def main():
-    Script.registerArgument(" command: Command to execute inside the container")
-    command = Script.getPositionalArgs(group=True)
+    command = sys.argv[1]
 
     user_image = None
     Script.registerSwitch("i:", "image=", "   apptainer image to use")
@@ -50,41 +51,66 @@ def main():
         if switch[0].lower() == "i" or switch[0].lower() == "image":
             user_image = switch[1]
 
-    wrapSubs = {
-        "dirac_env_var": os.environ.get("DIRAC", os.getcwd()),
-        "diracos_env_var": os.environ.get("DIRACOS", os.getcwd()),
-    }
-    wrapSubs["rc_script"] = os.path.join(os.path.realpath(sys.base_prefix), "diracosrc")
-    wrapSubs["command"] = command
-    shutil.copyfile("dirac.cfg", os.path.join("tmp", "dirac.cfg"))
-
-    wrapLoc = os.path.join("tmp", "dirac_container.sh")
-    rawfd = os.open(wrapLoc, os.O_WRONLY | os.O_CREAT, 0o700)
-    fd = os.fdopen(rawfd, "w")
-    fd.write(CONTAINER_WRAPPER % wrapSubs)
-    fd.close()
-
-    innerCmd = os.path.join("tmp", "dirac_container.sh")
+    cwd = os.path.realpath(os.getcwd())
+    dirac_env_var = os.environ.get("DIRAC", cwd)
+    diracos_env_var = os.environ.get("DIRACOS", cwd)
+    etc_dir = os.path.join(DIRAC.rootPath, "etc")
+    rc_script = os.path.join(os.path.realpath(sys.base_prefix), "diracosrc")
+
+    include_proxy = True
+    proxy_location = getProxyLocation()
+    if not proxy_location:
+        include_proxy = False
+
+    with open("dirac_container.sh", "w", encoding="utf-8") as fd:
+        script = generate_container_wrapper(
+            dirac_env_var, diracos_env_var, etc_dir, rc_script, command, include_proxy=include_proxy
+        )
+        fd.write(script)
+    os.chmod("dirac_container.sh", 0o755)
+
+    # Now let's construct the apptainer command
     cmd = ["apptainer", "exec"]
     cmd.extend(["--contain"])  # use minimal /dev and empty other directories (e.g. /tmp and $HOME)
     cmd.extend(["--ipc"])  # run container in a new IPC namespace
-    cmd.extend(["--workdir", "/tmp"])  # working directory to be used for /tmp, /var/tmp and $HOME
-    cmd.extend(["--home", "/tmp"])  # Avoid using small tmpfs for default $HOME and use scratch /tmp instead
-    cmd.extend(["--bind", "{0}:{0}:ro".format(os.path.join(os.path.realpath(sys.base_prefix)))])
+    cmd.extend(["--pid"])  # run container in a new PID namespace
+    cmd.extend(["--bind", cwd])  # bind current directory for dirac_container.sh
+    if proxy_location:
+        cmd.extend(["--bind", f"{proxy_location}:/etc/proxy"])  # bind proxy file
+    cmd.extend(["--bind", f"{getCAsLocation()}:/etc/grid-security/certificates"])  # X509_CERT_DIR
+    voms_location = Path(getVOMSLocation())
+    cmd.extend(["--bind", f"{voms_location}:/etc/grid-security/vomsdir"])  # X509_VOMS_DIR
+    vomses_location = voms_location.parent / "vomses"
+    cmd.extend(["--bind", f"{vomses_location}:/etc/grid-security/vomses"])  # X509_VOMSES
+    cmd.extend(["--bind", "{0}:{0}:ro".format(etc_dir)])  # etc dir for dirac.cfg
+    cmd.extend(["--bind", "{0}:{0}:ro".format(os.path.join(os.path.realpath(sys.base_prefix)))])  # code dir
+    # here bind optional paths
+    for bind_path in gConfig.getValue("/Resources/Computing/Singularity/BindPaths", []):
+        if safe_listdir(bind_path):
+            cmd.extend(["--bind", f"{bind_path}:{bind_path}"])
+        else:
+            gLogger.warn(f"Bind path {bind_path} does not exist, skipping")
+    cmd.extend(["--cwd", cwd])  # set working directory
 
     rootImage = user_image or gConfig.getValue("/Resources/Computing/Singularity/ContainerRoot") or CONTAINER_DEFROOT
 
     if os.path.isdir(rootImage) or os.path.isfile(rootImage):
-        cmd.extend([rootImage, innerCmd])
+        cmd.extend([rootImage, f"{cwd}/dirac_container.sh"])
     else:
         # if we are here is because there's no image, or it is not accessible (e.g. not on CVMFS)
         gLogger.error("Apptainer image to exec not found: ", rootImage)
         return S_ERROR("Failed to find Apptainer image to exec")
 
-    gLogger.debug(f"Execute Apptainer command: {cmd}")
-    result = systemCall(0, cmd, env=getEnv())
+    gLogger.debug(f"Execute Apptainer command: {' '.join(cmd)}")
+    result = systemCall(0, cmd)
     if not result["OK"]:
+        gLogger.error(result["Message"])
         DIRAC.exit(1)
+    if result["Value"][0] != 0:
+        gLogger.error("Apptainer command failed with exit code", result["Value"][0])
+        gLogger.error("Command output:", result["Value"])
+        DIRAC.exit(2)
+    gLogger.notice(result["Value"][1])
 
 
 if __name__ == "__main__":

DIRAC/Core/scripts/dirac_configure.py

@@ -99,9 +99,7 @@ class Params:
         self.includeAllServers = True
 
     def setSetup(self, optionValue):
-        self.setup = optionValue
-        DIRAC.gConfig.setOptionValue("/DIRAC/Setup", self.setup)
-        DIRAC.gConfig.setOptionValue(cfgInstallPath("Setup"), self.setup)
+        DIRAC.gLogger.warn("Ignoring Setup option as it is not used for DIRAC v9.0+")
         return DIRAC.S_OK()
 
     def setSiteName(self, optionValue):

DIRAC/Core/scripts/dirac_install_db.py

@@ -2,6 +2,8 @@
 """
 Create a new DB in the MySQL server
 """
+from DIRAC import exit as DIRACExit
+from DIRAC import gConfig, gLogger
 from DIRAC.Core.Base.Script import Script
 
 
@@ -12,24 +14,40 @@ def main():
     _, args = Script.parseCommandLine()
 
     # Script imports
-    from DIRAC import gConfig
+    from DIRAC.ConfigurationSystem.Client.Helpers.CSGlobals import useServerCertificate
+    from DIRAC.Core.Security.ProxyInfo import getProxyInfo
     from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller
     from DIRAC.FrameworkSystem.Utilities import MonitoringUtilities
 
+    user = "DIRAC"
+
     gComponentInstaller.exitOnError = True
     gComponentInstaller.getMySQLPasswords()
     for db in args:
         result = gComponentInstaller.installDatabase(db)
         if not result["OK"]:
-            print(f"ERROR: failed to correctly install {db}", result["Message"])
-            continue
+            gLogger.error(f"Failed to correctly install {db}:", result["Message"])
+            DIRACExit(1)
         extension, system = result["Value"]
-        gComponentInstaller.addDatabaseOptionsToCS(gConfig, system, db, overwrite=True)
+        result = gComponentInstaller.addDatabaseOptionsToCS(gConfig, system, db, overwrite=True)
+        if not result["OK"]:
+            gLogger.error("Failed to add database options to CS:", result["Message"])
+            DIRACExit(1)
 
         if db != "InstalledComponentsDB":
-            result = MonitoringUtilities.monitorInstallation("DB", system, db)
+            # get the user that installed the DB
+            if not useServerCertificate():
+                result = getProxyInfo()
+                if not result["OK"]:
+                    return result
+                proxyInfo = result["Value"]
+                if "username" in proxyInfo:
+                    user = proxyInfo["username"]
+
+            result = MonitoringUtilities.monitorInstallation("DB", system, db, user=user)
             if not result["OK"]:
-                print(f"ERROR: failed to register installation in database: {result['Message']}")
+                gLogger.error("Failed to register installation in database:", result["Message"])
+                DIRACExit(1)
 
 
 if __name__ == "__main__":