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

DIRAC/WorkloadManagementSystem/Agent/PushJobAgent.py

@@ -12,16 +12,14 @@
 import hashlib
 import json
 import os
-from pathlib import Path
 import random
 import shutil
 import sys
-from collections import defaultdict
 import time
+from collections import defaultdict
+from pathlib import Path
 
-from diraccfg import CFG
-
-from DIRAC import gConfig, S_OK, S_ERROR
+from DIRAC import S_ERROR, S_OK, gConfig
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getQueues
 from DIRAC.Core.Utilities import DErrno
@@ -30,6 +28,7 @@ from DIRAC.Core.Utilities.Proxy import executeWithUserProxy
 from DIRAC.Core.Utilities.Version import getVersion
 from DIRAC.FrameworkSystem.Client.ProxyManagerClient import gProxyManager
 from DIRAC.Resources.Computing import ComputingElement
+from DIRAC.WorkloadManagementSystem.Agent.JobAgent import JobAgent
 from DIRAC.WorkloadManagementSystem.Client import JobMinorStatus, JobStatus, PilotStatus
 from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
 from DIRAC.WorkloadManagementSystem.Client.JobReport import JobReport
@@ -41,11 +40,10 @@ from DIRAC.WorkloadManagementSystem.JobWrapper.JobWrapperUtilities import (
     resolveInputData,
     transferInputSandbox,
 )
-from DIRAC.WorkloadManagementSystem.Utilities.QueueUtilities import getQueuesResolved
-from DIRAC.WorkloadManagementSystem.Agent.JobAgent import JobAgent
-from DIRAC.WorkloadManagementSystem.Utilities.Utils import createJobWrapper
 from DIRAC.WorkloadManagementSystem.private.ConfigHelper import findGenericPilotCredentials
+from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import getJobParameters
 from DIRAC.WorkloadManagementSystem.Utilities.QueueUtilities import getQueuesResolved
+from DIRAC.WorkloadManagementSystem.Utilities.Utils import createJobWrapper
 
 MAX_JOBS_MANAGED = 100
 
@@ -230,6 +228,12 @@ class PushJobAgent(JobAgent):
             return result
         pilotProxy = result["Value"]
 
+        # Dump the proxy to a file to get DiracX token (it's later used by DiracX)
+        result = gProxyManager.dumpProxyToFile(pilotProxy)
+        if not result["OK"]:
+            return result
+        os.environ["X509_USER_PROXY"] = result["Value"]
+
         for queueName, queueDictionary in queueDictItems:
             # Make sure there is no problem with the queue before trying to submit
             if not self._allowedToSubmit(queueName):
@@ -281,7 +285,6 @@ class PushJobAgent(JobAgent):
                 jobGroup = matcherInfo["Group"]
                 owner = matcherInfo["Owner"]
                 ceDict = matcherInfo["CEDict"]
-                matchTime = matcherInfo["matchTime"]
 
                 optimizerParams = {}
                 for key in matcherInfo:
@@ -309,9 +312,6 @@ class PushJobAgent(JobAgent):
                 self.log.verbose("Job request successful: \n", jobRequest["Value"])
                 self.log.info("Received", f"JobID={jobID}, JobType={jobType}, Owner={owner}, JobGroup={jobGroup}")
 
-                self.jobs[jobID]["JobReport"].setJobParameter(
-                    par_name="MatcherServiceTime", par_value=str(matchTime), sendFlag=False
-                )
                 self.jobs[jobID]["JobReport"].setJobStatus(
                     status=JobStatus.MATCHED, minorStatus="Job Received by Agent", sendFlag=False
                 )
@@ -734,7 +734,7 @@ class PushJobAgent(JobAgent):
             return S_OK()
 
         # Get their parameters
-        if not (result := self.jobMonitoring.getJobParameters(jobs, ["GridCE", "TaskID", "Stamp"]))["OK"]:
+        if not (result := getJobParameters(jobs, ["GridCE", "TaskID", "Stamp"]))["OK"]:
             self.log.error("Failed to get the list of taskIDs", result["Message"])
             return result
 

DIRAC/WorkloadManagementSystem/Agent/SiteDirector.py

@@ -1,4 +1,4 @@
-"""  The Site Director is an agent performing pilot job submission to particular sites/Computing Elements.
+"""The Site Director is an agent performing pilot job submission to particular sites/Computing Elements.
 
 .. literalinclude:: ../ConfigTemplate.cfg
   :start-after: ##BEGIN SiteDirector
@@ -7,6 +7,7 @@
   :caption: SiteDirector options
 
 """
+
 import datetime
 import os
 from collections import defaultdict
@@ -14,7 +15,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any
 
 import DIRAC
-from DIRAC import S_ERROR, S_OK, gConfig
+from DIRAC import S_ERROR, S_OK
 from DIRAC.AccountingSystem.Client.DataStoreClient import gDataStoreClient
 from DIRAC.AccountingSystem.Client.Types.Pilot import Pilot as PilotAccounting
 from DIRAC.AccountingSystem.Client.Types.PilotSubmission import (
@@ -147,10 +148,10 @@ class SiteDirector(AgentModule):
             self.sendSubmissionAccounting = True
 
         # Get the site description dictionary
-        siteNames = self.am_getOption("Site", [])
-        ceTypes = self.am_getOption("CETypes", [])
-        ces = self.am_getOption("CEs", [])
-        tags = self.am_getOption("Tags", [])
+        siteNames = self.am_getOption("Site")
+        ceTypes = self.am_getOption("CETypes")
+        ces = self.am_getOption("CEs")
+        tags = self.am_getOption("Tags")
 
         # Display options used
         self.log.always("VO:", self.vo)
@@ -229,12 +230,8 @@ class SiteDirector(AgentModule):
             site = self.queueDict[queueName]["Site"]
             ce = self.queueDict[queueName]["CEName"]
 
-            # Check the status of the Site
-            if site in siteMaskList:
-                continue
-
-            # Check the status of the CE (only for RSS=Active)
-            if ce not in ceMaskList:
+            # Check the status of the Site and CE
+            if site in siteMaskList and ce in ceMaskList:
                 continue
 
             self.log.warn("Queue not considered because not usable:", queueName)
@@ -580,7 +577,7 @@ class SiteDirector(AgentModule):
             pilotOptions = []
 
         pilotOptions = " ".join(pilotOptions)
-        self.log.verbose(f"pilotOptions: {pilotOptions}")
+        self.log.verbose(f"{pilotOptions=}")
 
         # if a global workingDirectory is defined for the CEType (like HTCondor)
         # use it (otherwise the __cleanup done by HTCondor will be in the wrong folder !)

DIRAC/WorkloadManagementSystem/Agent/StalledJobAgent.py

@@ -14,18 +14,18 @@ import datetime
 from DIRAC import S_ERROR, S_OK, gConfig
 from DIRAC.AccountingSystem.Client.Types.Job import Job
 from DIRAC.ConfigurationSystem.Client.Helpers import cfgPath
-from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getDNForUsername
 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.TimeUtilities import fromString, second, toEpoch
 from DIRAC.WorkloadManagementSystem.Client import JobMinorStatus, JobStatus
-from DIRAC.WorkloadManagementSystem.Client.JobManagerClient import JobManagerClient
-from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
-from DIRAC.WorkloadManagementSystem.Client.PilotManagerClient import PilotManagerClient
-from DIRAC.WorkloadManagementSystem.Client.WMSClient import WMSClient
 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
+from DIRAC.WorkloadManagementSystem.Utilities.Utils import rescheduleJobs
 
 
 class StalledJobAgent(AgentModule):
@@ -235,7 +235,7 @@ 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 = self._sendKillCommand(jobID)
+            res = kill_delete_jobs(RIGHT_KILL, [jobID], nonauthJobList=[], force=True)
             if not res["OK"]:
                 self.log.error("Failed to kill job", jobID)
 
@@ -254,15 +254,15 @@ class StalledJobAgent(AgentModule):
 
     def _getJobPilotStatus(self, jobID):
         """Get the job pilot status."""
-        result = JobMonitoringClient().getJobParameter(jobID, "Pilot_Reference")
+        result = getJobParameters([jobID], "Pilot_Reference")
         if not result["OK"]:
             return result
-        pilotReference = result["Value"].get("Pilot_Reference", "Unknown")
-        if pilotReference == "Unknown":
+        pilotReference = result["Value"].get("Pilot_Reference")
+        if not pilotReference:
             # There is no pilot reference, hence its status is unknown
             return S_OK("NoPilot")
 
-        result = PilotManagerClient().getPilotInfo(pilotReference)
+        result = 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']}")
@@ -389,11 +389,11 @@ class StalledJobAgent(AgentModule):
             if lastHeartBeatTime is not None and lastHeartBeatTime > endTime:
                 endTime = lastHeartBeatTime
 
-            result = JobMonitoringClient().getJobParameter(jobID, "CPUNormalizationFactor")
-            if not result["OK"] or not result["Value"]:
+            result = getJobParameters([jobID], "CPUNormalizationFactor")
+            if not result["OK"] or not result["Value"] or not result["Value"].get("CPUNormalizationFactor"):
                 self.log.error(
                     "Error getting Job Parameter CPUNormalizationFactor, setting 0",
-                    result.get("Message", "No such value"),
+                    result.get("Message"),
                 )
                 cpuNormalization = 0.0
             else:
@@ -518,8 +518,7 @@ class StalledJobAgent(AgentModule):
         return startTime, endTime
 
     def _kickStuckJobs(self):
-        """Reschedule jobs stuck in initialization status Rescheduled,
-        Matched."""
+        """Reschedule jobs stuck in initialization status Rescheduled, Matched."""
 
         message = ""
 
@@ -530,17 +529,12 @@ class StalledJobAgent(AgentModule):
             return result
 
         jobIDs = result["Value"]
-        jobManagerClient = JobManagerClient()
         if jobIDs:
             self.log.info(f"Rescheduling {len(jobIDs)} jobs stuck in {JobStatus.MATCHED} status")
-            result = jobManagerClient.rescheduleJob(jobIDs)
+            result = rescheduleJobs(jobIDs)
             if not result["OK"]:
                 message = f"Failed to reschedule jobs stuck in {JobStatus.MATCHED} status"
                 message += "\n" + result["Message"]
-                if "InvalidJobIDs" in result:
-                    message += "\n" + "\tInvalid job IDs: " + str(result["InvalidJobIDs"])
-                if "NonauthorizedJobIDs" in result:
-                    message += "\n" + "\tNon authorized job IDs: " + str(result["NonauthorizedJobIDs"])
 
         checkTime = datetime.datetime.utcnow() - self.rescheduledTime * second
         result = self.jobDB.selectJobs({"Status": JobStatus.RESCHEDULED}, older=checkTime)
@@ -550,18 +544,14 @@ class StalledJobAgent(AgentModule):
 
         jobIDs = result["Value"]
         if jobIDs:
-            self.log.info(f"Rescheduling {len(jobIDs)} jobs stuck in Rescheduled status")
-            result = jobManagerClient.rescheduleJob(jobIDs)
+            self.log.info(f"Rescheduling {len(jobIDs)} jobs stuck in {JobStatus.RESCHEDULED} status")
+            result = rescheduleJobs(jobIDs)
             if not result["OK"]:
                 message = f"Failed to reschedule jobs stuck in {JobStatus.RESCHEDULED} status"
                 message += "\n" + result["Message"]
-                if "InvalidJobIDs" in result:
-                    message += "\n" + "\tInvalid job IDs: " + str(result["InvalidJobIDs"])
-                if "NonauthorizedJobIDs" in result:
-                    message += "\n" + "\tNon authorized job IDs: " + str(result["NonauthorizedJobIDs"])
 
         if message:
-            return S_ERROR(message)
+            self.log.error(message)
         return S_OK()
 
     def _failSubmittingJobs(self):
@@ -584,26 +574,3 @@ class StalledJobAgent(AgentModule):
                 continue
 
         return S_OK()
-
-    def _sendKillCommand(self, job):
-        """Send a kill signal to the job such that it cannot continue running.
-
-        :param int job: ID of job to send kill command
-        """
-
-        res = self.jobDB.getJobAttribute(job, "Owner")
-        if not res["OK"]:
-            return res
-        owner = res["Value"]
-
-        res = self.jobDB.getJobAttribute(job, "OwnerGroup")
-        if not res["OK"]:
-            return res
-        ownerGroup = res["Value"]
-
-        wmsClient = WMSClient(
-            useCertificates=True,
-            delegatedDN=getDNForUsername(owner)["Value"][0] if owner else None,
-            delegatedGroup=ownerGroup,
-        )
-        return wmsClient.killJob(job)

DIRAC/WorkloadManagementSystem/Agent/StatesAccountingAgent.py

@@ -9,10 +9,11 @@
 """
 import datetime
 
-from DIRAC import S_ERROR, S_OK
+from DIRAC import S_ERROR, S_OK, gConfig
 from DIRAC.AccountingSystem.Client.DataStoreClient import DataStoreClient
 from DIRAC.AccountingSystem.Client.Types.WMSHistory import WMSHistory
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
+from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
 from DIRAC.Core.Base.AgentModule import AgentModule
 from DIRAC.Core.Utilities import TimeUtilities
 from DIRAC.MonitoringSystem.Client.MonitoringReporter import MonitoringReporter
@@ -77,6 +78,8 @@ class StatesAccountingAgent(AgentModule):
     def execute(self):
         """Main execution method"""
 
+        site_metadata = self._getSitesMetadata()
+
         # on the first iteration of the agent, do nothing in order to avoid double committing after a restart
         if self.am_getModuleParam("cyclesDone") == 0:
             self.log.notice("Skipping the first iteration of the agent")
@@ -131,6 +134,16 @@ class StatesAccountingAgent(AgentModule):
 
             for backend in self.datastores:
                 if backend.lower() == "monitoring":
+                    site_name = rD["Site"]
+                    if site_name not in site_metadata:
+                        self.log.warn(
+                            f"Site {site_name} not found in site metadata, using default values",
+                        )
+                        rD["Tier"] = "4"
+                        rD["Type"] = site_name.split(".")[0]
+                    else:
+                        rD["Tier"] = site_metadata[site_name]["Tier"]
+                        rD["Type"] = site_metadata[site_name]["Type"]
                     rD["timestamp"] = int(TimeUtilities.toEpochMilliSeconds(now))
                     self.datastores["Monitoring"].addRecord(rD)
 
@@ -154,3 +167,30 @@ class StatesAccountingAgent(AgentModule):
             self.log.verbose(f"Done committing WMSHistory to {backend} backend")
 
         return S_OK()
+
+    def _getSitesMetadata(self):
+        """Get the metadata for the sites"""
+        res = getSites()
+        if not res["OK"]:
+            return res
+        sites = res["Value"]
+        site_metadata = {}
+
+        for site in sites:
+            site_metadata[site] = {}
+
+            # Get the site metadata from the Configuration System
+            grid = site.split(".")[0]
+            res = gConfig.getOptionsDict(f"Resources/Sites/{grid}/{site}")
+            if not res["OK"]:
+                self.log.error("Failure getting options dict for site", f"{site}: {res['Message']}")
+                continue
+            siteInfoCS = res["Value"]
+
+            # The site tier is normally 1 or 2. Few VOs may define tier 3.
+            # If the tier is not defined, we assume it is 4, with 4 meaning "not pledged" (opportunistic).
+            site_metadata[site]["Tier"] = siteInfoCS.get("MoUTierLevel", "4")
+            # The site type is defined by the first part of the site name.
+            # It needs to be interpreted at the Monitoring side (e.g. in Grafana).
+            site_metadata[site]["Type"] = site.split(".")[0]
+        return site_metadata

DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_JobAgent.py

@@ -260,6 +260,7 @@ def test__checkMatcherInfo(mocker, matcherInfo, matcherParams, expectedResult):
 #############################################################################
 
 
+@pytest.mark.slow
 @pytest.mark.parametrize(
     "mockGCReply, mockPMReply, expected",
     [
@@ -308,6 +309,7 @@ def test__setupProxy(mocker, mockGCReply, mockPMReply, expected):
         assert result["Message"] == expected["Message"]
 
 
+@pytest.mark.slow
 @pytest.mark.parametrize(
     "mockGCReply, mockPMReply, expected",
     [

DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_JobCleaningAgent.py

@@ -1,10 +1,11 @@
 """ Test class for Job Cleaning Agent
 """
-import pytest
 from unittest.mock import MagicMock
 
+import pytest
+
 # DIRAC Components
-from DIRAC import gLogger, S_OK
+from DIRAC import S_OK, gLogger
 from DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent import JobCleaningAgent
 
 gLogger.setLevel("DEBUG")
@@ -32,7 +33,6 @@ def jca(mocker):
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.JobDB.selectJobs", side_effect=mockReply)
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.JobDB.__init__", side_effect=mockNone)
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.ReqClient", return_value=mockNone)
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.JobMonitoringClient", return_value=mockJMC)
 
     jca = JobCleaningAgent()
     jca.log = gLogger
@@ -98,7 +98,7 @@ def test_deleteJobsByStatus(jca, conditions, mockReplyInput, expected):
     "inputs, params, expected",
     [
         ([], {"OK": True, "Value": {}}, {"OK": True, "Value": {"Failed": {}, "Successful": {}}}),
-        (["a", "b"], {"OK": True, "Value": {}}, {"OK": True, "Value": {"Failed": {}, "Successful": {}}}),
+        (["123", "456"], {"OK": True, "Value": {}}, {"OK": True, "Value": {"Failed": {}, "Successful": {}}}),
         (
             [],
             {"OK": True, "Value": {1: {"OutputSandboxLFN": "/some/lfn/1.txt"}}},
@@ -113,11 +113,11 @@ def test_deleteJobsByStatus(jca, conditions, mockReplyInput, expected):
             {"OK": True, "Value": {"Failed": {}, "Successful": {1: "/some/lfn/1.txt", 2: "/some/other/lfn/2.txt"}}},
         ),
         (
-            ["a", "b"],
+            ["123", "456"],
             {"OK": True, "Value": {1: {"OutputSandboxLFN": "/some/lfn/1.txt"}}},
             {"OK": True, "Value": {"Failed": {}, "Successful": {1: "/some/lfn/1.txt"}}},
         ),
-        (["a", "b"], {"OK": False}, {"OK": False}),
+        (["123", "456"], {"OK": False}, {"OK": False}),
     ],
 )
 def test_deleteJobOversizedSandbox(mocker, inputs, params, expected):
@@ -127,10 +127,10 @@ def test_deleteJobOversizedSandbox(mocker, inputs, params, expected):
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.AgentModule.am_getOption", return_value=mockAM)
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.JobDB", return_value=mockNone)
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.ReqClient", return_value=mockNone)
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.JobMonitoringClient", return_value=mockJMC)
     mocker.patch(
         "DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.getDNForUsername", return_value=S_OK(["/bih/boh/DN"])
     )
+    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobCleaningAgent.getJobParameters", return_value=params)
 
     jobCleaningAgent = JobCleaningAgent()
     jobCleaningAgent.log = gLogger
@@ -138,8 +138,6 @@ def test_deleteJobOversizedSandbox(mocker, inputs, params, expected):
     jobCleaningAgent._AgentModule__configDefaults = mockAM
     jobCleaningAgent.initialize()
 
-    mockJMC.getJobParameters.return_value = params
-
     result = jobCleaningAgent.deleteJobOversizedSandbox(inputs)
 
     assert result == expected

DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_PushJobAgent.py

@@ -178,6 +178,7 @@ def jobID():
     shutil.rmtree(jobID)
 
 
+@pytest.mark.slow
 def test_submitJobWrapper(mocker, jobID):
     """Test JobAgent._submitJobWrapper()"""
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobAgent.AgentModule.__init__")

DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_SiteDirector.py

@@ -169,10 +169,16 @@ def sd(mocker, config):
         gConfig.getSections("Resources/Sites/LCG")["Value"] + gConfig.getSections("Resources/Sites/DIRAC")["Value"]
     )
     mocker.patch(
-        "DIRAC.WorkloadManagementSystem.Agent.SiteDirector.SiteStatus.getUsableSites", return_values=usableSites
+        "DIRAC.WorkloadManagementSystem.Agent.SiteDirector.SiteStatus.getUsableSites", return_value=S_OK(usableSites)
     )
+
+    # Mock getElementStatus to return a properly formatted dictionary
+    def mock_getElementStatus(ceNamesList, *args, **kwargs):
+        return S_OK({ceName: {"all": "Active"} for ceName in ceNamesList})
+
     mocker.patch(
-        "DIRAC.WorkloadManagementSystem.Agent.SiteDirector.ResourceStatus.getElementStatus", return_values=usableSites
+        "DIRAC.WorkloadManagementSystem.Agent.SiteDirector.ResourceStatus.getElementStatus",
+        side_effect=mock_getElementStatus,
     )
     mocker.patch(
         "DIRAC.WorkloadManagementSystem.Agent.SiteDirector.gProxyManager.downloadProxy", side_effect=mockPMProxyReply

DIRAC/WorkloadManagementSystem/Agent/test/Test_Agent_StalledJobAgent.py

@@ -25,11 +25,10 @@ def sja(mocker):
     )
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobDB")
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobLoggingDB")
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobMonitoringClient", return_value=MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.JobManagerClient", return_value=MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.PilotManagerClient", return_value=MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.WMSClient", return_value=MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.StalledJobAgent.getDNForUsername", return_value=MagicMock())
+    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())
 
     stalledJobAgent = StalledJobAgent()
     stalledJobAgent._AgentModule__configDefaults = mockAM

DIRAC/WorkloadManagementSystem/Client/DownloadInputData.py

@@ -1,6 +1,7 @@
-""" The Download Input Data module wraps around the Replica Management
-    components to provide access to datasets by downloading locally
+"""The Download Input Data module wraps around the Replica Management
+components to provide access to datasets by downloading locally
 """
+
 import os
 import random
 import tempfile
@@ -226,7 +227,7 @@ class DownloadInputData:
         diskSpace = getDiskSpace(self.__getDownloadDir(False))  # MB
         availableBytes = diskSpace * 1024 * 1024  # bytes
         bufferGBs = gConfig.getValue(
-            os.path.join("/Systems/WorkloadManagement/JobWrapper", "JobWrapper", "MinOutputDataBufferGB"), 5.0
+            os.path.join("/Systems/WorkloadManagement/JobWrapper", "MinOutputDataBufferGB"), 5.0
         )
         data = bufferGBs * 1024 * 1024 * 1024  # bufferGBs in bytes
         if (data + totalSize) < availableBytes:
@@ -243,12 +244,13 @@ class DownloadInputData:
             return S_ERROR(msg)
 
     def __getDownloadDir(self, incrementCounter=True):
+        jobIDPath = str(self.configuration.get("JobIDPath", os.getcwd()))
         if self.inputDataDirectory == "PerFile":
             if incrementCounter:
                 self.counter += 1
-            return tempfile.mkdtemp(prefix=f"InputData_{self.counter}", dir=os.getcwd())
+            return tempfile.mkdtemp(prefix=f"InputData_{self.counter}", dir=jobIDPath)
         elif self.inputDataDirectory == "CWD":
-            return os.getcwd()
+            return jobIDPath
         else:
             return self.inputDataDirectory
 

DIRAC/WorkloadManagementSystem/Client/JobMonitoringClient.py

@@ -14,12 +14,14 @@ except ImportError:
 
 @createClient("WorkloadManagement/JobMonitoring")
 class JobMonitoringClient(Client):
+    # Set to None to raise an error if this service is set as "legacy adapted"
+    # See ClientSelector
+    diracxClient = None
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.setServer("WorkloadManagement/JobMonitoring")
 
-    diracxClient = futureJobMonitoringClient
-
     @ignoreEncodeWarning
     def getJobsStatus(self, jobIDs):
         res = self._getRPC().getJobsStatus(jobIDs)
@@ -38,15 +40,6 @@ class JobMonitoringClient(Client):
             res["Value"] = strToIntDict(res["Value"])
         return res
 
-    @ignoreEncodeWarning
-    def getJobsParameters(self, jobIDs, parameters):
-        res = self._getRPC().getJobsParameters(jobIDs, parameters)
-
-        # Cast the str keys to int
-        if res["OK"]:
-            res["Value"] = strToIntDict(res["Value"])
-        return res
-
     @ignoreEncodeWarning
     def getJobsMinorStatus(self, jobIDs):
         res = self._getRPC().getJobsMinorStatus(jobIDs)
@@ -79,3 +72,9 @@ class JobMonitoringClient(Client):
         if res["OK"]:
             res["Value"] = strToIntDict(res["Value"])
         return res
+
+    def getInputData(self, jobIDs):
+        res = self._getRPC().getInputData(jobIDs)
+        if res["OK"] and isinstance(res["Value"], dict):
+            res["Value"] = strToIntDict(res["Value"])
+        return res