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

DIRAC/TransformationSystem/Client/TransformationClient.py

@@ -48,13 +48,6 @@ class TransformationClient(Client):
 
         getFileSummary(lfns)
         exists(lfns)
-
-    Web monitoring tools
-
-        getDistinctAttributeValues(attribute, selectDict)
-        getTransformationStatusCounters()
-        getTransformationSummary()
-        getTransformationSummaryWeb(selectDict, sortList, startItem, maxItems)
     """
 
     def __init__(self, **kwargs):

DIRAC/TransformationSystem/Client/Utilities.py

@@ -9,6 +9,8 @@ Utilities for Transformation system
 import ast
 import random
 
+from cachetools import LRUCache, cachedmethod
+from cachetools.keys import hashkey
 from DIRAC import S_OK, S_ERROR, gLogger
 
 from DIRAC.Core.Utilities.List import breakListIntoChunks
@@ -22,6 +24,9 @@ from DIRAC.Resources.Catalog.FileCatalog import FileCatalog
 from DIRAC.Resources.Storage.StorageElement import StorageElement
 from DIRAC.TransformationSystem.Client.TransformationClient import TransformationClient
 
+# Module-level cache for isSameSEInList method (shared across PluginUtilities instances)
+_is_same_se_in_list_cache = LRUCache(maxsize=1024)
+
 
 class PluginUtilities:
     """
@@ -400,6 +405,10 @@ class PluginUtilities:
 
         return StorageElement(se1).isSameSE(StorageElement(se2))
 
+    @cachedmethod(
+        lambda self: _is_same_se_in_list_cache,
+        key=lambda _, a, b: hashkey(a, *sorted(b)),
+    )
     def isSameSEInList(self, se1, seList):
         """Check if an SE is the same as any in a list"""
         if se1 in seList:

DIRAC/TransformationSystem/Service/TransformationManagerHandler.py

@@ -3,22 +3,12 @@
 import datetime
 
 from DIRAC import S_ERROR, S_OK
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.DISET.RequestHandler import RequestHandler
 from DIRAC.Core.Security.Properties import SecurityProperty
 from DIRAC.Core.Utilities.Decorators import deprecated
 from DIRAC.Core.Utilities.DEncode import ignoreEncodeWarning
 from DIRAC.Core.Utilities.JEncode import encode as jencode
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
-from DIRAC.RequestManagementSystem.Client.Operation import Operation
-from DIRAC.RequestManagementSystem.Client.Request import Request
-from DIRAC.TransformationSystem.Client import TransformationFilesStatus
-from DIRAC.WorkloadManagementSystem.Client import JobStatus
-
-TASKS_STATE_NAMES = ["TotalCreated", "Created"] + sorted(
-    set(JobStatus.JOB_STATES) | set(Request.ALL_STATES) | set(Operation.ALL_STATES)
-)
-FILES_STATE_NAMES = ["PercentProcessed", "Total"] + TransformationFilesStatus.TRANSFORMATION_FILES_STATES
 
 
 class TransformationManagerHandlerMixin:
@@ -530,39 +520,12 @@ class TransformationManagerHandlerMixin:
         """Set metadata to a file or to a directory (path)"""
         return cls.transformationDB.setMetadata(path, querydict)
 
-    ####################################################################
-    #
-    # These are the methods used for web monitoring
-    #
-
-    # TODO Get rid of this (talk to Matvey)
-    types_getDistinctAttributeValues = [str, dict]
-
-    @classmethod
-    def export_getDistinctAttributeValues(cls, attribute, selectDict):
-        res = cls.transformationDB.getTableDistinctAttributeValues("Transformations", [attribute], selectDict)
-        if not res["OK"]:
-            return res
-        return S_OK(res["Value"][attribute])
-
     types_getTableDistinctAttributeValues = [str, list, dict]
 
     @classmethod
     def export_getTableDistinctAttributeValues(cls, table, attributes, selectDict):
         return cls.transformationDB.getTableDistinctAttributeValues(table, attributes, selectDict)
 
-    types_getTransformationStatusCounters = []
-
-    @classmethod
-    def export_getTransformationStatusCounters(cls):
-        res = cls.transformationDB.getCounters("Transformations", ["Status"], {})
-        if not res["OK"]:
-            return res
-        statDict = {}
-        for attrDict, count in res["Value"]:
-            statDict[attrDict["Status"]] = count
-        return S_OK(statDict)
-
     types_getTransformationSummary = []
 
     def export_getTransformationSummary(self):
@@ -587,305 +550,6 @@ class TransformationManagerHandlerMixin:
             resultDict[transID] = transDict
         return S_OK(resultDict)
 
-    types_getTabbedSummaryWeb = [str, dict, dict, list, int, int]
-
-    def export_getTabbedSummaryWeb(self, table, requestedTables, selectDict, sortList, startItem, maxItems):
-        tableDestinations = {
-            "Transformations": {
-                "TransformationFiles": ["TransformationID"],
-                "TransformationTasks": ["TransformationID"],
-            },
-            "TransformationFiles": {
-                "Transformations": ["TransformationID"],
-                "TransformationTasks": ["TransformationID", "TaskID"],
-            },
-            "TransformationTasks": {
-                "Transformations": ["TransformationID"],
-                "TransformationFiles": ["TransformationID", "TaskID"],
-            },
-        }
-
-        tableSelections = {
-            "Transformations": ["TransformationID", "AgentType", "Type", "TransformationGroup", "Plugin"],
-            "TransformationFiles": ["TransformationID", "TaskID", "Status", "UsedSE", "TargetSE"],
-            "TransformationTasks": ["TransformationID", "TaskID", "ExternalStatus", "TargetSE"],
-        }
-
-        tableTimeStamps = {
-            "Transformations": "CreationDate",
-            "TransformationFiles": "LastUpdate",
-            "TransformationTasks": "CreationTime",
-        }
-
-        tableStatusColumn = {
-            "Transformations": "Status",
-            "TransformationFiles": "Status",
-            "TransformationTasks": "ExternalStatus",
-        }
-
-        resDict = {}
-        res = self.__getTableSummaryWeb(
-            table,
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=tableSelections[table],
-            timeStamp=tableTimeStamps[table],
-            statusColumn=tableStatusColumn[table],
-        )
-        if not res["OK"]:
-            self.log.error("Failed to get Summary for table", f"{table} {res['Message']}")
-            return res
-        resDict[table] = res["Value"]
-        selections = res["Value"]["Selections"]
-        tableSelection = {}
-        for destination in tableDestinations[table].keys():
-            tableSelection[destination] = {}
-            for parameter in tableDestinations[table][destination]:
-                tableSelection[destination][parameter] = selections.get(parameter, [])
-
-        for table, paramDict in requestedTables.items():
-            sortList = paramDict.get("SortList", [])
-            startItem = paramDict.get("StartItem", 0)
-            maxItems = paramDict.get("MaxItems", 50)
-            res = self.__getTableSummaryWeb(
-                table,
-                tableSelection[table],
-                sortList,
-                startItem,
-                maxItems,
-                selectColumns=tableSelections[table],
-                timeStamp=tableTimeStamps[table],
-                statusColumn=tableStatusColumn[table],
-            )
-            if not res["OK"]:
-                self.log.error("Failed to get Summary for table", f"{table} {res['Message']}")
-                return res
-            resDict[table] = res["Value"]
-        return S_OK(resDict)
-
-    types_getTransformationsSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationsSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "Transformations",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "AgentType", "Type", "Group", "Plugin"],
-            timeStamp="CreationDate",
-            statusColumn="Status",
-        )
-
-    types_getTransformationTasksSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationTasksSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "TransformationTasks",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "ExternalStatus", "TargetSE"],
-            timeStamp="CreationTime",
-            statusColumn="ExternalStatus",
-        )
-
-    types_getTransformationFilesSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationFilesSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "TransformationFiles",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "Status", "UsedSE", "TargetSE"],
-            timeStamp="LastUpdate",
-            statusColumn="Status",
-        )
-
-    def __getTableSummaryWeb(
-        self, table, selectDict, sortList, startItem, maxItems, selectColumns=[], timeStamp=None, statusColumn="Status"
-    ):
-        fromDate = selectDict.get("FromDate", None)
-        if fromDate:
-            del selectDict["FromDate"]
-        # if not fromDate:
-        #  fromDate = last_update
-        toDate = selectDict.get("ToDate", None)
-        if toDate:
-            del selectDict["ToDate"]
-        # Sorting instructions. Only one for the moment.
-        if sortList:
-            orderAttribute = sortList[0][0] + ":" + sortList[0][1]
-        else:
-            orderAttribute = None
-        # Get the columns that match the selection
-        fcn = None
-        fcnName = f"get{table}"
-        if hasattr(self.transformationDB, fcnName) and callable(getattr(self.transformationDB, fcnName)):
-            fcn = getattr(self.transformationDB, fcnName)
-        if not fcn:
-            return S_ERROR(f"Unable to invoke gTransformationDB.{fcnName}, it isn't a member function")
-        res = fcn(condDict=selectDict, older=toDate, newer=fromDate, timeStamp=timeStamp, orderAttribute=orderAttribute)
-        if not res["OK"]:
-            return res
-
-        # The full list of columns in contained here
-        allRows = res["Value"]
-        # Prepare the standard structure now within the resultDict dictionary
-        resultDict = {}
-        # Create the total records entry
-        resultDict["TotalRecords"] = len(allRows)
-
-        # Get the rows which are within the selected window
-        if resultDict["TotalRecords"] == 0:
-            return S_OK(resultDict)
-        ini = startItem
-        last = ini + maxItems
-        if ini >= resultDict["TotalRecords"]:
-            return S_ERROR("Item number out of range")
-        if last > resultDict["TotalRecords"]:
-            last = resultDict["TotalRecords"]
-
-        selectedRows = allRows[ini:last]
-        resultDict["Records"] = []
-        for row in selectedRows:
-            resultDict["Records"].append(list(row.values()))
-
-        # Create the ParameterNames entry
-        resultDict["ParameterNames"] = list(selectedRows[0].keys())
-        # Find which element in the tuple contains the requested status
-        if statusColumn not in resultDict["ParameterNames"]:
-            return S_ERROR("Provided status column not present")
-
-        # Generate the status dictionary
-        statusDict = {}
-        for row in selectedRows:
-            status = row[statusColumn]
-            statusDict[status] = statusDict.setdefault(status, 0) + 1
-        resultDict["Extras"] = statusDict
-
-        # Obtain the distinct values of the selection parameters
-        res = self.transformationDB.getTableDistinctAttributeValues(
-            table, selectColumns, selectDict, older=toDate, newer=fromDate
-        )
-        distinctSelections = zip(selectColumns, [])
-        if res["OK"]:
-            distinctSelections = res["Value"]
-        resultDict["Selections"] = distinctSelections
-
-        return S_OK(resultDict)
-
-    types_getTransformationSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        """Get the summary of the transformation information for a given page in the generic format"""
-
-        # Obtain the timing information from the selectDict
-        last_update = selectDict.get("CreationDate", None)
-        if last_update:
-            del selectDict["CreationDate"]
-        fromDate = selectDict.get("FromDate", None)
-        if fromDate:
-            del selectDict["FromDate"]
-        if not fromDate:
-            fromDate = last_update
-        toDate = selectDict.get("ToDate", None)
-        if toDate:
-            del selectDict["ToDate"]
-        # Sorting instructions. Only one for the moment.
-        if sortList:
-            orderAttribute = []
-            for i in sortList:
-                orderAttribute += [i[0] + ":" + i[1]]
-        else:
-            orderAttribute = None
-
-        # Get the transformations that match the selection
-        res = self.transformationDB.getTransformations(
-            condDict=selectDict, older=toDate, newer=fromDate, orderAttribute=orderAttribute
-        )
-        if not res["OK"]:
-            return res
-
-        ops = Operations()
-        # Prepare the standard structure now within the resultDict dictionary
-        resultDict = {}
-        trList = res["Records"]
-        # 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"])
-        # Add the job states to the ParameterNames entry
-        taskStateNames = TASKS_STATE_NAMES + ops.getValue("Transformations/AdditionalTaskStates", [])
-        resultDict["ParameterNames"] += ["Jobs_" + x for x in taskStateNames]
-        # Add the file states to the ParameterNames entry
-        fileStateNames = FILES_STATE_NAMES + ops.getValue("Transformations/AdditionalFileStates", [])
-        resultDict["ParameterNames"] += ["Files_" + x for x in fileStateNames]
-
-        # Get the transformations which are within the selected window
-        if nTrans == 0:
-            return S_OK(resultDict)
-        ini = startItem
-        last = ini + maxItems
-        if ini >= nTrans:
-            return S_ERROR("Item number out of range")
-        if last > nTrans:
-            last = nTrans
-        transList = trList[ini:last]
-
-        statusDict = {}
-        extendableTranfs = ops.getValue("Transformations/ExtendableTransfTypes", ["Simulation", "MCsimulation"])
-        givenUpFileStatus = ops.getValue("Transformations/GivenUpFileStatus", ["MissingInFC"])
-        problematicStatuses = ops.getValue("Transformations/ProblematicStatuses", ["Problematic"])
-        # Add specific information for each selected transformation
-        for trans in transList:
-            transDict = dict(zip(resultDict["ParameterNames"], trans))
-
-            # Update the status counters
-            status = transDict["Status"]
-            statusDict[status] = statusDict.setdefault(status, 0) + 1
-
-            # Get the statistics on the number of jobs for the transformation
-            transID = transDict["TransformationID"]
-            res = self.transformationDB.getTransformationTaskStats(transID)
-            taskDict = {}
-            if res["OK"] and res["Value"]:
-                taskDict = res["Value"]
-            for state in taskStateNames:
-                trans.append(taskDict.get(state, 0))
-
-            # Get the statistics for the number of files for the transformation
-            fileDict = {}
-            transType = transDict["Type"]
-            if transType.lower() in extendableTranfs:
-                fileDict["PercentProcessed"] = "-"
-            else:
-                res = self.transformationDB.getTransformationStats(transID)
-                if res["OK"]:
-                    fileDict = res["Value"]
-                    total = fileDict["Total"]
-                    for stat in givenUpFileStatus:
-                        total -= fileDict.get(stat, 0)
-                    processed = fileDict.get(TransformationFilesStatus.PROCESSED, 0)
-                    fileDict["PercentProcessed"] = f"{int(processed * 1000.0 / total) / 10.0:.1f}" if total else 0.0
-            problematic = 0
-            for stat in problematicStatuses:
-                problematic += fileDict.get(stat, 0)
-            fileDict["Problematic"] = problematic
-            for state in fileStateNames:
-                trans.append(fileDict.get(state, 0))
-
-        resultDict["Records"] = transList
-        resultDict["Extras"] = statusDict
-        return S_OK(resultDict)
-
 
 class TransformationManagerHandler(TransformationManagerHandlerMixin, RequestHandler):
     pass

DIRAC/TransformationSystem/Utilities/ReplicationCLIParameters.py

@@ -1,10 +1,10 @@
 """
 Command Line Parameters for creating the Replication transformations Script
 """
-from DIRAC import S_OK, S_ERROR, gLogger
+from DIRAC import S_ERROR, S_OK, gLogger
+from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOForGroup
 from DIRAC.Core.Security.Properties import SecurityProperty
 from DIRAC.Core.Security.ProxyInfo import getProxyInfo
-from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOMSVOForGroup
 
 
 class Params:
@@ -144,7 +144,7 @@ class Params:
             return False
         proxyValues = proxyInfo.get("Value", {})
         group = proxyValues.get("group", "")
-        vomsvo = getVOMSVOForGroup(group)
+        vomsvo = getVOForGroup(group)
         if not vomsvo:
             self.errorMessages.append("ERROR: ProxyGroup not associated to VOMS VO, get a different proxy")
             return False

DIRAC/TransformationSystem/scripts/dirac_production_runjoblocal.py

@@ -16,7 +16,7 @@ from urllib.request import urlopen
 from DIRAC.Interfaces.API.Dirac import Dirac
 from DIRAC.Core.Utilities.File import mkDir
 from DIRAC.Core.Base.Script import Script
-from DIRAC.ConfigurationSystem.Client.Helpers.CSGlobals import getVO, getSetup
+from DIRAC.ConfigurationSystem.Client.Helpers.CSGlobals import getVO
 from DIRAC.ConfigurationSystem.Client.ConfigurationData import gConfigurationData
 
 
@@ -79,14 +79,12 @@ def __configurePilot(basepath, vo):
     This method was created specifically for LHCb pilots, more info
     about othe VOs is needed to make it more general.
     """
-    currentSetup = getSetup()
     masterCS = gConfigurationData.getMasterServer()
 
     os.system(
         "python "
         + basepath
-        + "dirac-pilot.py -S %s -l %s -C %s -N ce.debug.ch -Q default -n DIRAC.JobDebugger.ch -dd"
-        % (currentSetup, vo, masterCS)
+        + f"dirac-pilot.py -l {vo} -C {masterCS} -N ce.debug.ch -Q default -n DIRAC.JobDebugger.ch -dd"
     )
 
     diracdir = os.path.expanduser("~") + os.path.sep

DIRAC/TransformationSystem/test/Test_replicationTransformation.py

@@ -1,14 +1,13 @@
 """Test the dirac-transformation-replication script and helper"""
 import unittest
+from unittest.mock import MagicMock as Mock
+from unittest.mock import patch
 
-from unittest.mock import MagicMock as Mock, patch
-
-from DIRAC import S_OK, S_ERROR
-
-from DIRAC.TransformationSystem.Utilities.ReplicationTransformation import createDataTransformation
+from DIRAC import S_ERROR, S_OK
 from DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters import Params
+from DIRAC.TransformationSystem.Utilities.ReplicationTransformation import createDataTransformation
 
-GET_VOMS = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getVOMSVOForGroup"
+GET_VOMS = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getVOForGroup"
 GET_PROXY = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getProxyInfo"
 
 

DIRAC/Workflow/Modules/test/Test_Modules.py

@@ -5,6 +5,8 @@ import os
 import copy
 import shutil
 
+import pytest
+
 from unittest.mock import MagicMock as Mock
 
 from DIRAC import gLogger
@@ -742,6 +744,7 @@ class FailoverRequestSuccess(ModulesTestCase):
 class ScriptSuccess(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]
@@ -770,6 +773,7 @@ class ScriptSuccess(ModulesTestCase):
 class ScriptUnicode(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]
@@ -799,6 +803,7 @@ class ScriptUnicode(ModulesTestCase):
 class ScriptFailure(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]

DIRAC/WorkloadManagementSystem/Agent/JobAgent.py

@@ -236,7 +236,6 @@ class JobAgent(AgentModule):
         jobGroup = matcherInfo["Group"]
         owner = matcherInfo["Owner"]
         ceDict = matcherInfo["CEDict"]
-        matchTime = matcherInfo["matchTime"]
 
         optimizerParams = {}
         for key in matcherInfo:
@@ -263,9 +262,6 @@ class JobAgent(AgentModule):
         self.log.verbose("Job request successful: \n", jobRequest["Value"])
         self.log.info("Received", f"JobID={jobID}, JobType={jobType}, Owner={owner}, JobGroup={jobGroup}")
         self.jobCount += 1
-        self.jobs[jobID]["JobReport"].setJobParameter(
-            par_name="MatcherServiceTime", par_value=str(matchTime), sendFlag=False
-        )
 
         self.jobs[jobID]["JobReport"].setJobStatus(minorStatus="Job Received by Agent", sendFlag=False)
         result_setupProxy = self._setupProxy(owner, jobGroup)
@@ -547,7 +543,7 @@ class JobAgent(AgentModule):
             jobRequest = MatcherClient().requestJob(ceDict)
             matchTime = time.time() - start
 
-            self.log.info("MatcherTime", f"= {matchTime:.2f} (s)")
+            self.log.verbose("MatcherTime", f"= {matchTime:.2f} (s)")
             if jobRequest["OK"]:
                 jobRequest["Value"]["matchTime"] = matchTime
                 jobRequest["Value"]["CEDict"] = ceDict

DIRAC/WorkloadManagementSystem/Agent/JobCleaningAgent.py

@@ -35,10 +35,12 @@ from DIRAC.RequestManagementSystem.Client.Operation import Operation
 from DIRAC.RequestManagementSystem.Client.ReqClient import ReqClient
 from DIRAC.RequestManagementSystem.Client.Request import Request
 from DIRAC.WorkloadManagementSystem.Client import JobStatus
-from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
-from DIRAC.WorkloadManagementSystem.Client.SandboxStoreClient import SandboxStoreClient
 from DIRAC.WorkloadManagementSystem.Client.WMSClient import WMSClient
 from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
+from DIRAC.WorkloadManagementSystem.DB.SandboxMetadataDB import SandboxMetadataDB
+from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_DELETE
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import getJobParameters
 
 
 class JobCleaningAgent(AgentModule):
@@ -152,8 +154,9 @@ class JobCleaningAgent(AgentModule):
             return S_OK()
 
         self.log.info("Unassigning sandboxes from soon to be deleted jobs", f"({len(jobList)})")
-        result = SandboxStoreClient(useCertificates=True).unassignJobs(jobList)
-        if not result["OK"]:
+
+        entitiesList = [f"Job:{jobId}" for jobId in jobList]
+        if not (result := SandboxMetadataDB().unassignEntities(entitiesList))["OK"]:
             self.log.error("Cannot unassign jobs to sandboxes", result["Message"])
             return result
 
@@ -229,11 +232,11 @@ class JobCleaningAgent(AgentModule):
             if not res["OK"]:
                 self.log.error("No DN found", f"for {user}")
                 return res
-            wmsClient = WMSClient(useCertificates=True, delegatedDN=res["Value"][0], delegatedGroup=ownerGroup)
             if remove:
+                wmsClient = WMSClient(useCertificates=True, delegatedDN=res["Value"][0], delegatedGroup=ownerGroup)
                 result = wmsClient.removeJob(jobsList)
             else:
-                result = wmsClient.deleteJob(jobsList)
+                result = kill_delete_jobs(RIGHT_DELETE, jobsList)
             if not result["OK"]:
                 self.log.error(
                     f"Could not {'remove' if remove else 'delete'} jobs",
@@ -293,7 +296,8 @@ class JobCleaningAgent(AgentModule):
         failed = {}
         successful = {}
 
-        result = JobMonitoringClient().getJobParameters(jobIDList, ["OutputSandboxLFN"])
+        jobIDs = [int(jobID) for jobID in jobIDList]
+        result = getJobParameters(jobIDs, "OutputSandboxLFN")
         if not result["OK"]:
             return result
         osLFNDict = result["Value"]

DIRAC/WorkloadManagementSystem/Agent/PilotSyncAgent.py

@@ -1,4 +1,4 @@
-""" This agent syncs CS and pilot files to a web server of your choice
+"""This agent syncs CS and pilot files to a web server of your choice
 
 .. literalinclude:: ../ConfigTemplate.cfg
   :start-after: ##BEGIN PilotSyncAgent
@@ -7,6 +7,7 @@
   :caption: PilotsSyncAgent options
 
 """
+
 import os
 import json
 import shutil
@@ -38,8 +39,8 @@ class PilotSyncAgent(AgentModule):
         self.workingDirectory = self.am_getOption("WorkDirectory")
         self.saveDir = self.am_getOption("SaveDirectory", self.saveDir)
         self.uploadLocations = self.am_getOption("UploadLocations", self.uploadLocations)
-        includeMasterCS = self.am_getOption("IncludeMasterCS", self.includeMasterCS)
-        if isinstance(includeMasterCS, str) and includeMasterCS.lower() in ["n", "no", "false"]:
+        self.includeMasterCS = self.am_getOption("IncludeMasterCS", self.includeMasterCS)
+        if isinstance(self.includeMasterCS, str) and self.includeMasterCS.lower() in ["n", "no", "false"]:
             self.includeMasterCS = False
 
         self.certAndKeyLocation = getHostCertificateAndKeyLocation()