DIRAC 9.0.10__tar.gz → 9.0.12__tar.gz

{dirac-9.0.10/src/DIRAC.egg-info → dirac-9.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DIRAC
-Version: 9.0.10
+Version: 9.0.12
 Summary: DIRAC is an interware, meaning a software framework for distributed computing.
 Home-page: https://github.com/DIRACGrid/DIRAC/
 License: GPL-3.0-only
@@ -19,7 +19,7 @@ Requires-Dist: cachetools
 Requires-Dist: certifi
 Requires-Dist: cwltool
 Requires-Dist: diraccfg
-Requires-Dist: DIRACCommon==v9.0.10
+Requires-Dist: DIRACCommon==v9.0.12
 Requires-Dist: diracx-client>=v0.0.1
 Requires-Dist: diracx-core>=v0.0.1
 Requires-Dist: diracx-cli>=v0.0.1

{dirac-9.0.10 → dirac-9.0.12}/release.notes

@@ -1,3 +1,28 @@
+[v9.0.12]
+
+*Resources
+
+FIX: (#8393) make client_id and secret optional to avoid KeyError exceptions.
+
+*ConfigurationSystem
+
+NEW: (#8392) handle adding user AffiliationEnds section in the CS when modifying the user from CSAPI
+
+*MonitoringSystem
+
+FIX: (#8391) Addapt webApp to new getTransformations API
+
+[v9.0.11]
+
+*WorkloadManagement
+
+FIX: (#8389) Use ObjectLoader for DB instantiation in WMS components
+FIX: (#8389) Reuse DB objects when killing/deleting jobs
+
+*Resources
+
+CHANGE: (#8362) SSHCE export inputs/import outputs as a JSON file instead of using the stdout/stderr
+
 [v9.0.10]
 
 *DataManagementSystem

{dirac-9.0.10 → dirac-9.0.12}/setup.cfg

@@ -26,7 +26,7 @@ install_requires =
 	certifi
 	cwltool
 	diraccfg
-	DIRACCommon==v9.0.10
+	DIRACCommon==v9.0.12
 	diracx-client >=v0.0.1
 	diracx-core >=v0.0.1
 	diracx-cli >=v0.0.1

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/AccountingSystem/Client/Types/Network.py

@@ -1,6 +1,6 @@
-""" Accounting class to stores network metrics gathered by perfSONARs.
+"""Accounting class to stores network metrics gathered by perfSONARs.
 
-    Filled by "Accounting/Network" agent
+Filled by "Accounting/Network" agent
 """
 
 from DIRAC.AccountingSystem.Client.Types.BaseAccountingType import BaseAccountingType
@@ -16,12 +16,12 @@ class Network(BaseAccountingType):
 
         # IPv6 address has up to 45 chars
         self.definitionKeyFields = [
-            ("SourceIP", "VARCHAR(50)"),
-            ("DestinationIP", "VARCHAR(50)"),
-            ("SourceHostName", "VARCHAR(50)"),
-            ("DestinationHostName", "VARCHAR(50)"),
-            ("Source", "VARCHAR(50)"),
-            ("Destination", "VARCHAR(50)"),
+            ("SourceIP", "VARCHAR(64)"),
+            ("DestinationIP", "VARCHAR(64)"),
+            ("SourceHostName", "VARCHAR(255)"),
+            ("DestinationHostName", "VARCHAR(255)"),
+            ("Source", "VARCHAR(255)"),
+            ("Destination", "VARCHAR(255)"),
         ]
 
         self.definitionAccountingFields = [

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/AccountingSystem/Client/Types/PilotSubmission.py

@@ -1,6 +1,6 @@
-""" Accounting Type for Pilot Submission
+"""Accounting Type for Pilot Submission
 
-    Filled by the "WorkloadManagement/SiteDirector" agent(s)
+Filled by the "WorkloadManagement/SiteDirector" agent(s)
 """
 
 from DIRAC.AccountingSystem.Client.Types.BaseAccountingType import BaseAccountingType
@@ -13,7 +13,7 @@ class PilotSubmission(BaseAccountingType):
         super().__init__()
 
         self.definitionKeyFields = [
-            ("HostName", "VARCHAR(100)"),
+            ("HostName", "VARCHAR(255)"),
             ("SiteDirector", "VARCHAR(100)"),
             ("Site", "VARCHAR(100)"),
             ("CE", "VARCHAR(100)"),

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/ConfigurationSystem/Client/CSAPI.py

@@ -456,13 +456,23 @@ class CSAPI:
             gLogger.error("User is not registered: ", repr(username))
             return S_OK(False)
         for prop in properties:
-            if prop == "Groups":
+            if prop in ["Groups", "AffiliationEnds"]:
                 continue
             prevVal = self.__csMod.getValue(f"{self.__baseSecurity}/Users/{username}/{prop}")
             if not prevVal or prevVal != properties[prop]:
                 gLogger.info(f"Setting {prop} property for user {username} to {properties[prop]}")
                 self.__csMod.setOptionValue(f"{self.__baseSecurity}/Users/{username}/{prop}", properties[prop])
                 modifiedUser = True
+        if properties.get("AffiliationEnds", None):
+            user_affiliationends_section = f"{self.__baseSecurity}/Users/{username}/AffiliationEnds"
+            # add the section for AffiliationEnds
+            res = gConfig.getSections(user_affiliationends_section)
+            if not res["OK"]:
+                self.__csMod.createSection(user_affiliationends_section)
+            # now set value VO = end date
+            for vo, end_date in properties["AffiliationEnds"].items():
+                self.__csMod.setOptionValue(f"{user_affiliationends_section}/{vo}", end_date)
+                modifiedUser = True
         if "Groups" in properties:
             result = self.listGroups()
             if not result["OK"]:

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/FrameworkSystem/DB/InstalledComponentsDB.py

@@ -1,6 +1,7 @@
 """
 Classes and functions for easier management of the InstalledComponents database
 """
+
 import re
 import datetime
 
@@ -90,7 +91,7 @@ class Host(componentsBase):
     __table_args__ = {"mysql_engine": "InnoDB", "mysql_charset": "utf8mb4"}
 
     hostID = Column("HostID", Integer, primary_key=True)
-    hostName = Column("HostName", String(32), nullable=False)
+    hostName = Column("HostName", String(255), nullable=False)
     cpu = Column("CPU", String(64), nullable=False)
     installationList = relationship("InstalledComponent", backref="installationHost")
 
@@ -219,7 +220,7 @@ class HostLogging(componentsBase):
     __tablename__ = "HostLogging"
     __table_args__ = {"mysql_engine": "InnoDB", "mysql_charset": "utf8mb4"}
 
-    hostName = Column("HostName", String(32), nullable=False, primary_key=True)
+    hostName = Column("HostName", String(255), nullable=False, primary_key=True)
     # status
     DIRAC = Column("DIRACVersion", String(64))
     Extension = Column("Extension", String(512))

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/FrameworkSystem/Utilities/MonitoringUtilities.py

@@ -1,6 +1,7 @@
 """
 Utilities for ComponentMonitoring features
 """
+
 import datetime
 import socket
 

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/FrameworkSystem/scripts/dirac_uninstall_component.py

@@ -2,6 +2,7 @@
 """
 Uninstallation of a DIRAC component
 """
+
 import socket
 
 from DIRAC import exit as DIRACexit

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/MonitoringSystem/Service/WebAppHandler.py

@@ -2,6 +2,7 @@
 The WebAppHandler module provides a class to handle web requests from the DIRAC WebApp.
 It is not indented to be used in diracx
 """
+
 from DIRAC import S_ERROR, S_OK
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
@@ -527,13 +528,21 @@ class WebAppHandler(RequestHandler):
         ops = Operations()
         # Prepare the standard structure now within the resultDict dictionary
         resultDict = {}
-        trList = res["Records"]
+        # Reconstruct just the values list
+        trList = [
+            [str(item) if not isinstance(item, int) else item for item in trans_dict.values()]
+            for trans_dict in res["Value"]
+        ]
+
         # Create the total records entry
         nTrans = len(trList)
         resultDict["TotalRecords"] = nTrans
         # Create the ParameterNames entry
-        # As this list is a reference to the list in the DB, we cannot extend it, therefore copy it
-        resultDict["ParameterNames"] = list(res["ParameterNames"])
+        try:
+            resultDict["ParameterNames"] = list(res["Value"][0].keys())
+        except IndexError:
+            # As this list is a reference to the list in the DB, we cannot extend it, therefore copy it
+            resultDict["ParameterNames"] = list(cls.transformationDB.TRANSPARAMS)
         # Add the job states to the ParameterNames entry
         taskStateNames = TASKS_STATE_NAMES + ops.getValue("Transformations/AdditionalTaskStates", [])
         resultDict["ParameterNames"] += ["Jobs_" + x for x in taskStateNames]

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/Computing/BatchSystems/Condor.py

@@ -203,9 +203,6 @@ class Condor(object):
             resultDict["Jobs"] = []
             for i in range(submittedJobs):
                 resultDict["Jobs"].append(".".join([cluster, str(i)]))
-            # Executable is transferred afterward
-            # Inform the caller that Condor cannot delete it before the end of the execution
-            resultDict["ExecutableToKeep"] = executable
         else:
             resultDict["Status"] = status
             resultDict["Message"] = error

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/Computing/BatchSystems/executeBatch.py

@@ -35,8 +35,10 @@ if __name__ == "__main__":
       from urllib.parse import unquote as urlunquote
 
 
-  arguments = sys.argv[1]
-  inputDict = json.loads(urlunquote(arguments))
+  # Read options from JSON file
+  optionsFilePath = sys.argv[1]
+  with open(optionsFilePath, 'r') as f:
+    inputDict = json.load(f)
 
   method = inputDict.pop('Method')
   batchSystem = inputDict.pop('BatchSystem')
@@ -45,9 +47,15 @@ if __name__ == "__main__":
   try:
     result = getattr(batch, method)(**inputDict)
   except Exception:
-    result = traceback.format_exc()
-
-  resultJson = urlquote(json.dumps(result))
-  print("============= Start output ===============")
-  print(resultJson)
+    # Wrap the traceback in a proper error structure
+    result = {
+      'Status': -1,
+      'Message': 'Exception during batch method execution',
+      'Traceback': traceback.format_exc()
+    }
+
+  # Write result to JSON file
+  resultFilePath = optionsFilePath.replace('.json', '_result.json')
+  with open(resultFilePath, 'w') as f:
+    json.dump(result, f)
 """

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/Computing/LocalComputingElement.py

@@ -182,8 +182,6 @@ class LocalComputingElement(ComputingElement):
             batchSystemName = self.batchSystem.__class__.__name__.lower()
             jobIDs = ["ssh" + batchSystemName + "://" + self.ceName + "/" + _id for _id in resultSubmit["Jobs"]]
             result = S_OK(jobIDs)
-            if "ExecutableToKeep" in resultSubmit:
-                result["ExecutableToKeep"] = resultSubmit["ExecutableToKeep"]
         else:
             result = S_ERROR(resultSubmit["Message"])
 

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/Computing/SSHComputingElement.py

@@ -67,9 +67,10 @@ import json
 import os
 import shutil
 import stat
+import tempfile
 import uuid
 from shlex import quote as shlex_quote
-from urllib.parse import quote, unquote, urlparse
+from urllib.parse import urlparse
 
 import pexpect
 
@@ -484,47 +485,69 @@ class SSHComputingElement(ComputingElement):
         options["User"] = self.user
         options["Queue"] = self.queue
 
-        options = json.dumps(options)
-        options = quote(options)
+        localOptionsFile = None
+        remoteOptionsFile = None
+        localResultFile = None
+        remoteResultFile = None
+        try:
+            # Write options to a local temporary file
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+                json.dump(options, f)
+                localOptionsFile = f.name
+
+            # Upload the options file to the remote host
+            remoteOptionsFile = f"{self.sharedArea}/batch_options_{uuid.uuid4().hex}.json"
+            result = ssh.scpCall(30, localOptionsFile, remoteOptionsFile)
+            if not result["OK"]:
+                return result
 
-        cmd = (
-            "bash --login -c 'python3 %s/execute_batch %s || python %s/execute_batch %s || python2 %s/execute_batch %s'"
-            % (self.sharedArea, options, self.sharedArea, options, self.sharedArea, options)
-        )
+            # Execute the batch command with the options file path
+            cmd = (
+                f"bash --login -c 'python3 {self.sharedArea}/execute_batch {remoteOptionsFile} || "
+                f"python {self.sharedArea}/execute_batch {remoteOptionsFile} || "
+                f"python2 {self.sharedArea}/execute_batch {remoteOptionsFile}'"
+            )
 
-        self.log.verbose(f"CE submission command: {cmd}")
+            self.log.verbose(f"CE submission command: {cmd}")
 
-        result = ssh.sshCall(120, cmd)
-        if not result["OK"]:
-            self.log.error(f"{self.ceType} CE job submission failed", result["Message"])
-            return result
+            result = ssh.sshCall(120, cmd)
+            if not result["OK"]:
+                self.log.error(f"{self.ceType} CE job submission failed", result["Message"])
+                return result
 
-        sshStatus = result["Value"][0]
-        sshStdout = result["Value"][1]
-        sshStderr = result["Value"][2]
-
-        # Examine results of the job submission
-        if sshStatus == 0:
-            output = sshStdout.strip().replace("\r", "").strip()
-            if not output:
-                return S_ERROR("No output from remote command")
-
-            try:
-                index = output.index("============= Start output ===============")
-                output = output[index + 42 :]
-            except ValueError:
-                return S_ERROR(f"Invalid output from remote command: {output}")
-
-            try:
-                output = unquote(output)
-                result = json.loads(output)
-                if isinstance(result, str) and result.startswith("Exception:"):
-                    return S_ERROR(result)
-                return S_OK(result)
-            except Exception:
-                return S_ERROR("Invalid return structure from job submission")
-        else:
-            return S_ERROR("\n".join([sshStdout, sshStderr]))
+            sshStatus = result["Value"][0]
+            if sshStatus != 0:
+                sshStdout = result["Value"][1]
+                sshStderr = result["Value"][2]
+                return S_ERROR(f"CE job submission command failed with status {sshStatus}: {sshStdout} {sshStderr}")
+
+            # The result should be written to a JSON file by execute_batch
+            # Compute the expected result file path
+            remoteResultFile = remoteOptionsFile.replace(".json", "_result.json")
+
+            # Try to download the result file
+            with tempfile.NamedTemporaryFile(mode="r", suffix=".json", delete=False) as f:
+                localResultFile = f.name
+
+            result = ssh.scpCall(30, localResultFile, remoteResultFile, upload=False)
+            if not result["OK"]:
+                return result
+
+            # Read the result from the downloaded file
+            with open(localResultFile) as f:
+                result = json.load(f)
+            return S_OK(result)
+        finally:
+            # Clean up local temporary file
+            if localOptionsFile and os.path.exists(localOptionsFile):
+                os.remove(localOptionsFile)
+            if localResultFile and os.path.exists(localResultFile):
+                os.remove(localResultFile)
+            # Clean up remote temporary files
+            if remoteOptionsFile:
+                ssh.sshCall(30, f"rm -f {remoteOptionsFile}")
+            if remoteResultFile:
+                ssh.sshCall(30, f"rm -f {remoteResultFile}")
 
     def submitJob(self, executableFile, proxy, numberOfJobs=1):
         #    self.log.verbose( "Executable file path: %s" % executableFile )

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/IdProvider/IdProviderFactory.py

@@ -75,8 +75,10 @@ class IdProviderFactory:
 
             if client_name_prefix:
                 client_name_prefix = client_name_prefix + "_"
-            pDict["client_id"] = pDict[f"{client_name_prefix}client_id"]
-            pDict["client_secret"] = pDict[f"{client_name_prefix}client_secret"]
+            if f"{client_name_prefix}client_id" in pDict:
+                pDict["client_id"] = pDict[f"{client_name_prefix}client_id"]
+            if f"{client_name_prefix}client_secret" in pDict:
+                pDict["client_secret"] = pDict[f"{client_name_prefix}client_secret"]
 
         pDict.update(kwargs)
         pDict["ProviderName"] = name

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/Resources/IdProvider/tests/Test_IdProviderFactory.py

@@ -63,6 +63,12 @@ Resources
       client_secret = IdP_client_secret
       scope = openid+profile+offline_access+eduperson_entitlement
     }
+    SomeIdP3.partial
+    {
+      ProviderType = OAuth2
+      issuer = https://and-another-idp.url/
+      scope = openid+profile+offline_access+eduperson_entitlement
+    }
   }
 }
 """
@@ -77,6 +83,7 @@ idps = IdProviderFactory()
         ("SomeIdP1.2", {"OK": True}, "https://idp.url/", "IdP_client_id2", "IdP_client_secret"),
         ("SomeIdP2", {"OK": True}, "https://another-idp.url/", "IdP_client_id1", "IdP_client_secret"),
         ("SomeIdP3", {"OK": True}, "https://and-another-idp.url/", "IdP_client_id3", "IdP_client_secret"),
+        ("SomeIdP3.partial", {"OK": True}, "https://and-another-idp.url/", None, None),
         # Try to get an unknown DIRAC client
         ("DIRACUnknown", {"OK": False, "Message": "DIRACUnknown does not exist"}, None, None, None),
     ],

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py

@@ -20,6 +20,7 @@ from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Base.AgentModule import AgentModule
 from DIRAC.Core.Utilities.DErrno import cmpError
 from DIRAC.Core.Utilities.List import breakListIntoChunks
+from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
 from DIRAC.Core.Utilities.Proxy import executeWithUserProxy
 from DIRAC.Core.Utilities.ReturnValues import returnSingleResult
 from DIRAC.RequestManagementSystem.Client.File import File
@@ -32,7 +33,6 @@ from DIRAC.Resources.Catalog.FileCatalogClient import FileCatalogClient
 from DIRAC.Resources.Storage.StorageElement import StorageElement
 from DIRAC.TransformationSystem.Client import TransformationStatus
 from DIRAC.TransformationSystem.Client.TransformationClient import TransformationClient
-from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
 from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
     RIGHT_DELETE,
     RIGHT_KILL,
@@ -65,8 +65,11 @@ class TransformationCleaningAgent(AgentModule):
         self.reqClient = None
         # # file catalog client
         self.metadataClient = None
-        # # JobDB
+        # # databases
         self.jobDB = None
+        self.pilotAgentsDB = None
+        self.taskQueueDB = None
+        self.storageManagementDB = None
 
         # # transformations types
         self.transformationTypes = None
@@ -125,8 +128,26 @@ class TransformationCleaningAgent(AgentModule):
         self.reqClient = ReqClient()
         # # file catalog client
         self.metadataClient = FileCatalogClient()
-        # # job DB
-        self.jobDB = JobDB()
+        # # databases
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.JobDB", "JobDB")
+        if not result["OK"]:
+            return result
+        self.jobDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.PilotAgentsDB", "PilotAgentsDB")
+        if not result["OK"]:
+            return result
+        self.pilotAgentsDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.TaskQueueDB", "TaskQueueDB")
+        if not result["OK"]:
+            return result
+        self.taskQueueDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("StorageManagementSystem.DB.StorageManagementDB", "StorageManagementDB")
+        if not result["OK"]:
+            return result
+        self.storageManagementDB = result["Value"]()
 
         return S_OK()
 
@@ -615,11 +636,17 @@ class TransformationCleaningAgent(AgentModule):
         :param self: self reference
         :param list trasnJobIDs: job IDs
         """
+        db_kwargs = dict(
+            jobdb=self.jobDB,
+            taskqueuedb=self.taskQueueDB,
+            pilotagentsdb=self.pilotAgentsDB,
+            storagemanagementdb=self.storageManagementDB,
+        )
         # Prevent 0 job IDs
         jobIDs = [int(j) for j in transJobIDs if int(j)]
         allRemove = True
         for jobList in breakListIntoChunks(jobIDs, 1000):
-            res = kill_delete_jobs(RIGHT_KILL, jobList, force=True)
+            res = kill_delete_jobs(RIGHT_KILL, jobList, force=True, **db_kwargs)
             if res["OK"]:
                 self.log.info(f"Successfully killed {len(jobList)} jobs from WMS")
             elif ("InvalidJobIDs" in res) and ("NonauthorizedJobIDs" not in res) and ("FailedJobIDs" not in res):
@@ -631,7 +658,7 @@ class TransformationCleaningAgent(AgentModule):
                 self.log.error("Failed to kill jobs", f"(n={len(res['FailedJobIDs'])})")
                 allRemove = False
 
-            res = kill_delete_jobs(RIGHT_DELETE, jobList, force=True)
+            res = kill_delete_jobs(RIGHT_DELETE, jobList, force=True, **db_kwargs)
             if res["OK"]:
                 self.log.info("Successfully deleted jobs from WMS", f"(n={len(jobList)})")
             elif ("InvalidJobIDs" in res) and ("NonauthorizedJobIDs" not in res) and ("FailedJobIDs" not in res):

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/WorkloadManagementSystem/Agent/StalledJobAgent.py

@@ -17,11 +17,9 @@ from DIRAC.ConfigurationSystem.Client.Helpers import cfgPath
 from DIRAC.Core.Base.AgentModule import AgentModule
 from DIRAC.Core.Utilities import DErrno
 from DIRAC.Core.Utilities.ClassAd.ClassAdLight import ClassAd
+from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
 from DIRAC.Core.Utilities.TimeUtilities import fromString, second, toEpoch
 from DIRAC.WorkloadManagementSystem.Client import JobMinorStatus, JobStatus
-from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
-from DIRAC.WorkloadManagementSystem.DB.JobLoggingDB import JobLoggingDB
-from DIRAC.WorkloadManagementSystem.DB.PilotAgentsDB import PilotAgentsDB
 from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_KILL
 from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import getJobParameters
@@ -40,6 +38,9 @@ class StalledJobAgent(AgentModule):
 
         self.jobDB = None
         self.logDB = None
+        self.taskQueueDB = None
+        self.pilotAgentsDB = None
+        self.storageManagementDB = None
         self.matchedTime = 7200
         self.rescheduledTime = 600
         self.submittingTime = 300
@@ -51,8 +52,30 @@ class StalledJobAgent(AgentModule):
     #############################################################################
     def initialize(self):
         """Sets default parameters."""
-        self.jobDB = JobDB()
-        self.logDB = JobLoggingDB()
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.JobDB", "JobDB")
+        if not result["OK"]:
+            return result
+        self.jobDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.JobLoggingDB", "JobLoggingDB")
+        if not result["OK"]:
+            return result
+        self.logDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.TaskQueueDB", "TaskQueueDB")
+        if not result["OK"]:
+            return result
+        self.taskQueueDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.PilotAgentsDB", "PilotAgentsDB")
+        if not result["OK"]:
+            return result
+        self.pilotAgentsDB = result["Value"]()
+
+        result = ObjectLoader().loadObject("StorageManagementSystem.DB.StorageManagementDB", "StorageManagementDB")
+        if not result["OK"]:
+            return result
+        self.storageManagementDB = result["Value"]()
 
         # getting parameters
 
@@ -235,7 +258,16 @@ class StalledJobAgent(AgentModule):
         # Set the jobs Failed, send them a kill signal in case they are not really dead
         # and send accounting info
         if setFailed:
-            res = kill_delete_jobs(RIGHT_KILL, [jobID], nonauthJobList=[], force=True)
+            res = kill_delete_jobs(
+                RIGHT_KILL,
+                [jobID],
+                nonauthJobList=[],
+                force=True,
+                jobdb=self.jobDB,
+                taskqueuedb=self.taskQueueDB,
+                pilotagentsdb=self.pilotAgentsDB,
+                storagemanagementdb=self.storageManagementDB,
+            )
             if not res["OK"]:
                 self.log.error("Failed to kill job", jobID)
 
@@ -262,7 +294,7 @@ class StalledJobAgent(AgentModule):
             # There is no pilot reference, hence its status is unknown
             return S_OK("NoPilot")
 
-        result = PilotAgentsDB().getPilotInfo(pilotReference)
+        result = self.pilotAgentsDB.getPilotInfo(pilotReference)
         if not result["OK"]:
             if DErrno.cmpError(result, DErrno.EWMSNOPILOT):
                 self.log.warn("No pilot found", f"for job {jobID}: {result['Message']}")

{dirac-9.0.10 → dirac-9.0.12}/src/DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_StalledJobAgent.py

@@ -23,10 +23,31 @@ def sja(mocker):
         side_effect=lambda x, y=None: y,
         create=True,
     )
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobDB")
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobLoggingDB")
+
+    # Mock ObjectLoader to return mock DB instances
+    mockJobDB = MagicMock()
+    mockJobDB.log = gLogger
+    mockJobLoggingDB = MagicMock()
+    mockTaskQueueDB = MagicMock()
+    mockPilotAgentsDB = MagicMock()
+    mockStorageManagementDB = MagicMock()
+
+    def mock_load_object(module_path, class_name):
+        mocks = {
+            "JobDB": mockJobDB,
+            "JobLoggingDB": mockJobLoggingDB,
+            "TaskQueueDB": mockTaskQueueDB,
+            "PilotAgentsDB": mockPilotAgentsDB,
+            "StorageManagementDB": mockStorageManagementDB,
+        }
+        return {"OK": True, "Value": lambda: mocks[class_name]}
+
+    mocker.patch(
+        "DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.ObjectLoader.loadObject",
+        side_effect=mock_load_object,
+    )
+
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.rescheduleJobs", return_value=MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.PilotAgentsDB", return_value=MagicMock())
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.getJobParameters", return_value=MagicMock())
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.kill_delete_jobs", return_value=MagicMock())
 
@@ -34,7 +55,6 @@ def sja(mocker):
     stalledJobAgent._AgentModule__configDefaults = mockAM
     stalledJobAgent.log = gLogger
     stalledJobAgent.initialize()
-    stalledJobAgent.jobDB.log = gLogger
     stalledJobAgent.log.setLevel("DEBUG")
     stalledJobAgent.stalledTime = 120