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

DIRAC/Resources/Computing/HTCondorCEComputingElement.py

@@ -50,6 +50,7 @@ When using a local condor_schedd look at the HTCondor documentation for enabling
 
 import datetime
 import errno
+import json
 import os
 import subprocess
 import tempfile
@@ -63,10 +64,14 @@ from DIRAC.Core.Utilities.File import mkDir
 from DIRAC.Core.Utilities.List import breakListIntoChunks
 from DIRAC.Core.Utilities.Subprocess import systemCall
 from DIRAC.FrameworkSystem.private.authorization.utils.Tokens import writeToTokenFile
-from DIRAC.Resources.Computing.BatchSystems.Condor import HOLD_REASON_SUBCODE, parseCondorStatus, subTemplate
+from DIRAC.Resources.Computing.BatchSystems.Condor import (
+    HOLD_REASON_SUBCODE,
+    STATE_ATTRIBUTES,
+    getCondorStatus,
+    subTemplate,
+)
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
 from DIRAC.WorkloadManagementSystem.Client import PilotStatus
-from DIRAC.WorkloadManagementSystem.Client.PilotManagerClient import PilotManagerClient
 
 MANDATORY_PARAMETERS = ["Queue"]
 DEFAULT_WORKINGDIRECTORY = "/opt/dirac/pro/runit/WorkloadManagement/SiteDirectorHT"
@@ -386,33 +391,10 @@ class HTCondorCEComputingElement(ComputingElement):
 
     #############################################################################
     def getCEStatus(self):
-        """Method to return information on running and pending jobs.
-
-        Warning: information currently returned depends on the PilotManager and not HTCondor.
-        Results might be wrong if pilots or jobs are submitted manually via the CE.
-        """
-        result = S_OK()
-        result["SubmittedJobs"] = 0
-        result["RunningJobs"] = 0
-        result["WaitingJobs"] = 0
-
-        # getWaitingPilots
-        condDict = {"DestinationSite": self.ceName, "Status": PilotStatus.PILOT_WAITING_STATES}
-        res = PilotManagerClient().countPilots(condDict)
-        if res["OK"]:
-            result["WaitingJobs"] = int(res["Value"])
-        else:
-            self.log.warn(f"Failure getting pilot count for {self.ceName}: {res['Message']} ")
-
-        # getRunningPilots
-        condDict = {"DestinationSite": self.ceName, "Status": PilotStatus.RUNNING}
-        res = PilotManagerClient().countPilots(condDict)
-        if res["OK"]:
-            result["RunningJobs"] = int(res["Value"])
-        else:
-            self.log.warn(f"Failure getting pilot count for {self.ceName}: {res['Message']} ")
-
-        return result
+        """Method to return information on running and pending jobs."""
+        return S_ERROR(
+            "getCEStatus() not supported for HTCondorCEComputingElement: HTCondor does not expose this information"
+        )
 
     def getJobStatus(self, jobIDList):
         """Get the status information for the given list of jobs"""
@@ -424,45 +406,57 @@ class HTCondorCEComputingElement(ComputingElement):
         if isinstance(jobIDList, str):
             jobIDList = [jobIDList]
 
+        self.tokenFile = None
         resultDict = {}
         condorIDs = {}
         # Get all condorIDs so we can just call condor_q and condor_history once
         for jobReference in jobIDList:
             jobReference = jobReference.split(":::")[0]
-            condorIDs[jobReference] = self._jobReferenceToCondorID(jobReference)
+            condorIDs[self._jobReferenceToCondorID(jobReference)] = jobReference
 
-        self.tokenFile = None
-
-        qList = []
-        for _condorIDs in breakListIntoChunks(condorIDs.values(), 100):
-            # This will return a list of 1245.75 3 undefined undefined undefined
+        jobsMetadata = []
+        for _condorIDs in breakListIntoChunks(condorIDs.keys(), 100):
             cmd = ["condor_q"]
             cmd.extend(self.remoteScheddOptions.strip().split(" "))
             cmd.extend(_condorIDs)
-            cmd.extend(["-af:j", "JobStatus", "HoldReasonCode", "HoldReasonSubCode", "HoldReason"])
+            cmd.extend(["-attributes", STATE_ATTRIBUTES])
+            cmd.extend(["-json"])
             result = self._executeCondorCommand(cmd, keepTokenFile=True)
             if not result["OK"]:
                 return result
 
-            qList.extend(result["Value"].split("\n"))
+            if result["Value"]:
+                jobsMetadata.extend(json.loads(result["Value"]))
 
             condorHistCall = ["condor_history"]
             condorHistCall.extend(self.remoteScheddOptions.strip().split(" "))
             condorHistCall.extend(_condorIDs)
-            condorHistCall.extend(["-af:j", "JobStatus", "HoldReasonCode", "HoldReasonSubCode", "HoldReason"])
+            condorHistCall.extend(["-attributes", STATE_ATTRIBUTES])
+            condorHistCall.extend(["-json"])
             result = self._executeCondorCommand(cmd, keepTokenFile=True)
             if not result["OK"]:
                 return result
 
-            qList.extend(result["Value"].split("\n"))
+            if result["Value"]:
+                jobsMetadata.extend(json.loads(result["Value"]))
 
-        for job, jobID in condorIDs.items():
-            jobStatus, reason = parseCondorStatus(qList, jobID)
+        foundJobIDs = set()
+        for jobDict in jobsMetadata:
+            jobStatus, reason = getCondorStatus(jobDict)
+            condorId = f"{jobDict['ClusterId']}.{jobDict['ProcId']}"
+            jobReference = condorIDs.get(condorId)
 
             if jobStatus == PilotStatus.ABORTED:
-                self.log.verbose("Job", f"{jobID} held: {reason}")
+                self.log.verbose("Job", f"{jobReference} held: {reason}")
+
+            resultDict[jobReference] = jobStatus
+            foundJobIDs.add(jobReference)
 
-            resultDict[job] = jobStatus
+        # Check if we have any jobs that were not found in the condor_q or condor_history
+        for jobReference in condorIDs.values():
+            if jobReference not in foundJobIDs:
+                self.log.verbose("Job", f"{jobReference} not found in condor_q or condor_history")
+                resultDict[jobReference] = PilotStatus.UNKNOWN
 
         self.tokenFile = None
 

DIRAC/Resources/Computing/SingularityComputingElement.py

@@ -387,7 +387,12 @@ class SingularityComputingElement(ComputingElement):
                     continue
 
                 mountedPath = se.getStorageParameters(protocol="file")["Value"]["Path"]
-                bindPaths.append(f"{mountedPath}:{mountedPath}:ro")
+                mountOptions = se.getStorageParameters(protocol="file")["Value"].get("MountOptions", "ro")
+                if mountOptions not in ("rw", "ro"):
+                    self.log.warn(f"Unknown mount mode: {mountOptions}")
+                    continue
+
+                bindPaths.append(f"{mountedPath}:{mountedPath}:{mountOptions}")
             except KeyError:
                 pass
 

DIRAC/Resources/Computing/test/Test_HTCondorCEComputingElement.py

@@ -2,6 +2,7 @@
 """
 tests for HTCondorCEComputingElement module
 """
+import json
 import uuid
 
 import pytest
@@ -12,18 +13,30 @@ from DIRAC.Resources.Computing.BatchSystems import Condor
 
 MODNAME = "DIRAC.Resources.Computing.HTCondorCEComputingElement"
 
-STATUS_LINES = """
-123.2 5 4 0 undefined
-123.1 3 undefined undefined undefined
-""".strip().split(
-    "\n"
-)
-
-HISTORY_LINES = """
-123.0 4 undefined undefined undefined
-""".strip().split(
-    "\n"
-)
+STATUS_QUEUE = [
+    {
+        "ClusterId": 123,
+        "ProcId": 2,
+        "JobStatus": 5,
+        "HoldReasonCode": 4,
+        "HoldReasonSubCode": 0,
+        "HoldReason": "The credentials for the job are invalid",
+    },
+    {
+        "ClusterId": 123,
+        "ProcId": 1,
+        "JobStatus": 3,
+    },
+]
+
+
+STATUS_HISTORY = [
+    {
+        "ClusterId": 123,
+        "ProcId": 0,
+        "JobStatus": 4,
+    }
+]
 
 
 @pytest.fixture
@@ -32,42 +45,47 @@ def setUp():
 
 
 def test_parseCondorStatus():
-    statusLines = f"""
-  104098.1 1 undefined undefined undefined
-  104098.2 2 undefined undefined undefined
-  104098.3 3 undefined undefined undefined
-  104098.4 4 undefined undefined undefined
-  104098.5 5 16 57 Input data are being spooled
-  104098.6 5 3 {Condor.HOLD_REASON_SUBCODE} Policy
-  104098.7 5 1 0 undefined
-
-  foo bar
-  104096.1 3 16 test test
-  104096.2 3 test
-  104096.3 5 undefined undefined undefined
-  104096.4 7
-  """.strip().split(
-        "\n"
-    )
-    # force there to be an empty line
+    statusOutput = {"ClusterId": 104098, "ProcId": 1, "JobStatus": 1}
+    assert HTCE.getCondorStatus(statusOutput) == ("Waiting", "")
 
-    expectedResults = {
-        "104098.1": "Waiting",
-        "104098.2": "Running",
-        "104098.3": "Aborted",
-        "104098.4": "Done",
-        "104098.5": "Waiting",
-        "104098.6": "Failed",
-        "104098.7": "Aborted",
-        "foo": "Unknown",
-        "104096.1": "Aborted",
-        "104096.2": "Aborted",
-        "104096.3": "Aborted",
-        "104096.4": "Unknown",
-    }
+    statusOutput = {"ClusterId": 104098, "ProcId": 2, "JobStatus": 2}
+    assert HTCE.getCondorStatus(statusOutput) == ("Running", "")
+
+    statusOutput = {"ClusterId": 104098, "ProcId": 3, "JobStatus": 3}
+    assert HTCE.getCondorStatus(statusOutput) == ("Aborted", "")
+
+    statusOutput = {"ClusterId": 104098, "ProcId": 4, "JobStatus": 4}
+    assert HTCE.getCondorStatus(statusOutput) == ("Done", "")
 
-    for jobID, expected in expectedResults.items():
-        assert HTCE.parseCondorStatus(statusLines, jobID)[0] == expected
+    statusOutput = {
+        "ClusterId": 104098,
+        "ProcId": 5,
+        "JobStatus": 5,
+        "HoldReasonCode": 16,
+        "HoldReasonSubCode": 57,
+        "HoldReason": "Input data are being spooled",
+    }
+    assert HTCE.getCondorStatus(statusOutput) == ("Waiting", "Input data are being spooled")
+
+    statusOutput = {
+        "ClusterId": 104098,
+        "ProcId": 6,
+        "JobStatus": 5,
+        "HoldReasonCode": 3,
+        "HoldReasonSubCode": HTCE.HOLD_REASON_SUBCODE,
+        "HoldReason": "Policy",
+    }
+    assert HTCE.getCondorStatus(statusOutput) == ("Failed", "Policy")
+
+    statusOutput = {
+        "ClusterId": 104098,
+        "ProcId": 7,
+        "JobStatus": 5,
+        "HoldReasonCode": 1,
+        "HoldReasonSubCode": 0,
+        "HoldReason": "Aborted by user",
+    }
+    assert HTCE.getCondorStatus(statusOutput) == ("Aborted", "Aborted by user")
 
 
 def test_getJobStatus(mocker):
@@ -75,8 +93,8 @@ def test_getJobStatus(mocker):
     mocker.patch(
         MODNAME + ".systemCall",
         side_effect=[
-            S_OK((0, "\n".join(STATUS_LINES), "")),
-            S_OK((0, "\n".join(HISTORY_LINES), "")),
+            S_OK((0, json.dumps(STATUS_QUEUE), "")),
+            S_OK((0, json.dumps(STATUS_HISTORY), "")),
             S_OK((0, "", "")),
             S_OK((0, "", "")),
         ],
@@ -110,7 +128,7 @@ def test_getJobStatus(mocker):
 def test_getJobStatusBatchSystem(mocker):
     """Test Condor Batch System plugin getJobStatus"""
     patchPopen = mocker.patch("DIRAC.Resources.Computing.BatchSystems.Condor.subprocess.Popen")
-    patchPopen.return_value.communicate.side_effect = [("\n".join(STATUS_LINES), ""), ("\n".join(HISTORY_LINES), "")]
+    patchPopen.return_value.communicate.side_effect = [(json.dumps(STATUS_QUEUE), ""), (json.dumps(STATUS_HISTORY), "")]
     patchPopen.return_value.returncode = 0
 
     ret = Condor.Condor().getJobStatus(JobIDList=["123.0", "123.1", "123.2", "333.3"])

DIRAC/Resources/Computing/test/Test_PoolComputingElement.py

@@ -25,7 +25,7 @@ while True:
   if os.path.isfile(stopFile):
     os.remove(stopFile)
     break
-  if (time.time() - start) > 30:
+  if (time.time() - start) > 5:
     break
 print("End job", jobNumber, time.time())
 """
@@ -262,6 +262,7 @@ def test_executeJob_wholeNode8(createAndDelete):
             assert "Not enough processors" in submissionResult["Message"]
 
 
+@pytest.mark.slow
 def test_executeJob_submitAndStop(createAndDelete):
     time.sleep(0.5)
 

DIRAC/Resources/IdProvider/CheckInIdProvider.py

@@ -26,3 +26,16 @@ class CheckInIdProvider(OAuth2IdProvider):
 
             idPScope = f"eduperson_entitlement?value=urn:mace:egi.eu:group:{vo}:role={groupElements[1]}#aai.egi.eu"
         return scope_to_list(idPScope)
+
+    def fetchToken(self, **kwargs):
+        """Fetch token
+
+        :param kwargs:
+        :return: dict
+        """
+
+        if "audience" in kwargs:
+            kwargs["resource"] = kwargs["audience"]
+            kwargs.pop("audience")
+
+        return super().fetchToken(**kwargs)

DIRAC/Resources/IdProvider/IdProviderFactory.py

@@ -1,6 +1,7 @@
-"""  The Identity Provider Factory instantiates IdProvider objects
-     according to their configuration
+"""The Identity Provider Factory instantiates IdProvider objects
+according to their configuration
 """
+
 import jwt
 
 from DIRAC import S_OK, S_ERROR, gLogger, gConfig
@@ -40,11 +41,12 @@ class IdProviderFactory:
             return result
         return self.getIdProvider(result["Value"])
 
-    def getIdProvider(self, name, **kwargs):
+    def getIdProvider(self, name, client_name_prefix="", **kwargs):
         """This method returns a IdProvider instance corresponding to the supplied
         name.
 
         :param str name: the name of the Identity Provider client
+        :param str client_name_prefix: name of the client of the IdP
 
         :return: S_OK(IdProvider)/S_ERROR()
         """
@@ -68,8 +70,14 @@ class IdProviderFactory:
             if not result["OK"]:
                 self.log.error("Failed to read configuration", f"{name}: {result['Message']}")
                 return result
+
             pDict = result["Value"]
 
+            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"]
+
         pDict.update(kwargs)
         pDict["ProviderName"] = name
 

DIRAC/Resources/Storage/StorageBase.py

@@ -1,4 +1,4 @@
-""" Base Storage Class provides the base interface for all storage plug-ins
+"""Base Storage Class provides the base interface for all storage plug-ins
 
       exists()
 
@@ -33,6 +33,7 @@ These are the methods for getting information about the Storage:
       getOccupancy()
 
 """
+
 import errno
 import json
 import os
@@ -113,7 +114,8 @@ class StorageBase:
 
     def getParameters(self):
         """Get the parameters with which the storage was instantiated"""
-        parameterDict = dict(self.protocolParameters)
+        parameterDict = dict(self._allProtocolParameters)
+        parameterDict.update(self.protocolParameters)
         parameterDict["StorageName"] = self.name
         parameterDict["PluginName"] = self.pluginName
         parameterDict["URLBase"] = self.getURLBase().get("Value", "")

DIRAC/Resources/Storage/StorageElement.py

@@ -438,10 +438,6 @@ class StorageElementItem:
 
             kwargs["occupancyLFN"] = occupancyLFN
 
-        filteredPlugins = self.__filterPlugins("getOccupancy")
-        if not filteredPlugins:
-            return S_ERROR(errno.EPROTONOSUPPORT, "No storage plugins to query the occupancy")
-
         # Call occupancy plugin if requested
         occupancyPlugin = self.options.get("OccupancyPlugin")
         if occupancyPlugin:
@@ -459,6 +455,10 @@ class StorageElementItem:
             except Exception as e:
                 return S_ERROR(f"Occupancy plugin failed: {str(e)}")
 
+        filteredPlugins = self.__filterPlugins("getOccupancy")
+        if not filteredPlugins:
+            return S_ERROR(errno.EPROTONOSUPPORT, "No storage plugins to query the occupancy")
+
         # Try all of the storages one by one
         for storage in filteredPlugins:
             # The result of the plugin is always in B

DIRAC/TransformationSystem/Agent/TaskManagerAgentBase.py

@@ -7,23 +7,21 @@
     In case you want to further extend it you are required to follow the note on the
     initialize method and on the _getClients method.
 """
-import time
-import datetime
 import concurrent.futures
+import datetime
+import time
 
-from DIRAC import S_OK
-
+from DIRAC import S_OK, gConfig
+from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Base.AgentModule import AgentModule
 from DIRAC.Core.Security.ProxyInfo import getProxyInfo
-from DIRAC.Core.Utilities.List import breakListIntoChunks
 from DIRAC.Core.Utilities.Dictionaries import breakDictionaryIntoChunks
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
+from DIRAC.Core.Utilities.List import breakListIntoChunks
+from DIRAC.TransformationSystem.Agent.TransformationAgentsUtilities import TransformationAgentsUtilities
 from DIRAC.TransformationSystem.Client.FileReport import FileReport
-from DIRAC.TransformationSystem.Client.WorkflowTasks import WorkflowTasks
 from DIRAC.TransformationSystem.Client.TransformationClient import TransformationClient
-from DIRAC.TransformationSystem.Agent.TransformationAgentsUtilities import TransformationAgentsUtilities
+from DIRAC.TransformationSystem.Client.WorkflowTasks import WorkflowTasks
 from DIRAC.WorkloadManagementSystem.Client import JobStatus
-from DIRAC.WorkloadManagementSystem.Client.JobManagerClient import JobManagerClient
 
 AGENT_NAME = "Transformation/TaskManagerAgentBase"
 
@@ -40,7 +38,6 @@ class TaskManagerAgentBase(AgentModule, TransformationAgentsUtilities):
         TransformationAgentsUtilities.__init__(self)
 
         self.transClient = None
-        self.jobManagerClient = None
         self.transType = []
 
         self.tasksPerLoop = 50
@@ -69,7 +66,6 @@ class TaskManagerAgentBase(AgentModule, TransformationAgentsUtilities):
 
         # Default clients
         self.transClient = TransformationClient()
-        self.jobManagerClient = JobManagerClient()
 
         # Bulk submission flag
         self.bulkSubmissionFlag = self.am_getOption("BulkSubmission", self.bulkSubmissionFlag)
@@ -193,11 +189,9 @@ class TaskManagerAgentBase(AgentModule, TransformationAgentsUtilities):
             else:
                 # Get the transformations which should be submitted
                 self.tasksPerLoop = self.am_getOption("TasksPerLoop", self.tasksPerLoop)
-                res = self.jobManagerClient.getMaxParametricJobs()
-                if not res["OK"]:
-                    self.log.warn("Could not get the maxParametricJobs from JobManager", res["Message"])
-                else:
-                    self.maxParametricJobs = res["Value"]
+                self.maxParametricJobs = gConfig.getValue(
+                    "/Systems/WorkloadManagement/Services/JobManager/MaxParametricJobs", self.maxParametricJobs
+                )
 
                 self._addOperationForTransformations(
                     self.operationsOnTransformationDict,

DIRAC/TransformationSystem/Agent/TransformationAgent.py

@@ -1,4 +1,4 @@
-"""  TransformationAgent processes transformations found in the transformation database.
+"""TransformationAgent processes transformations found in the transformation database.
 
 The following options can be set for the TransformationAgent.
 
@@ -8,6 +8,7 @@ The following options can be set for the TransformationAgent.
   :dedent: 2
   :caption: TransformationAgent options
 """
+
 from importlib import import_module
 
 import time
@@ -15,6 +16,7 @@ import os
 import datetime
 import pickle
 import concurrent.futures
+from pathlib import Path
 
 from DIRAC import S_OK, S_ERROR
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
@@ -127,6 +129,9 @@ class TransformationAgent(AgentModule, TransformationAgentsUtilities):
         if not res["OK"]:
             self._logError("Failed to obtain transformations:", res["Message"])
             return S_OK()
+
+        active_trans_ids = [t["TransformationID"] for t in res["Value"]]
+        self.cleanOldTransformationCache(active_trans_ids)
         # Process the transformations
         count = 0
         future_to_transID = {}
@@ -164,6 +169,22 @@ class TransformationAgent(AgentModule, TransformationAgentsUtilities):
 
         return S_OK()
 
+    def cleanOldTransformationCache(self, active_trans_ids: list[int]):
+        cache_filenames = {Path(self.__cacheFile(tid)) for tid in active_trans_ids}
+        existing_caches = set(Path(self.workDirectory).glob("*.pkl"))
+        useless_cache_files = existing_caches - cache_filenames
+
+        if useless_cache_files:
+            self._logInfo(f"Found potentially {len(useless_cache_files)} useless cache files")
+
+        # Since idle transformations aren't in active_trans_ids, let's filter it more
+        # and take only files that haven't been touched for 2 month
+        last_update_threshold = (datetime.datetime.utcnow() - datetime.timedelta(days=60)).timestamp()
+
+        for cache_file in useless_cache_files:
+            if Path(cache_file).stat().st_mtime < last_update_threshold:
+                cache_file.unlink()
+
     def getTransformations(self):
         """Obtain the transformations to be executed - this is executed at the start of every loop (it's really the
         only real thing in the execute()

DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py

@@ -16,14 +16,12 @@ from datetime import datetime, timedelta
 
 # # from DIRAC
 from DIRAC import S_ERROR, S_OK
-from DIRAC.ConfigurationSystem.Client.ConfigurationData import gConfigurationData
 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.Proxy import executeWithUserProxy
 from DIRAC.Core.Utilities.ReturnValues import returnSingleResult
-from DIRAC.DataManagementSystem.Client.DataManager import DataManager
 from DIRAC.RequestManagementSystem.Client.File import File
 from DIRAC.RequestManagementSystem.Client.Operation import Operation
 from DIRAC.RequestManagementSystem.Client.ReqClient import ReqClient
@@ -34,8 +32,12 @@ 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.Client.JobMonitoringClient import JobMonitoringClient
-from DIRAC.WorkloadManagementSystem.Client.WMSClient import WMSClient
+from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
+from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
+    RIGHT_DELETE,
+    RIGHT_KILL,
+)
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 
 # # agent's name
 AGENT_NAME = "Transformation/TransformationCleaningAgent"
@@ -59,12 +61,12 @@ class TransformationCleaningAgent(AgentModule):
 
         # # transformation client
         self.transClient = None
-        # # wms client
-        self.wmsClient = None
         # # request client
         self.reqClient = None
         # # file catalog client
         self.metadataClient = None
+        # # JobDB
+        self.jobDB = None
 
         # # transformations types
         self.transformationTypes = None
@@ -119,14 +121,12 @@ class TransformationCleaningAgent(AgentModule):
 
         # # transformation client
         self.transClient = TransformationClient()
-        # # wms client
-        self.wmsClient = WMSClient()
         # # request client
         self.reqClient = ReqClient()
         # # file catalog client
         self.metadataClient = FileCatalogClient()
-        # # job monitoring client
-        self.jobMonitoringClient = JobMonitoringClient()
+        # # job DB
+        self.jobDB = JobDB()
 
         return S_OK()
 
@@ -224,7 +224,7 @@ class TransformationCleaningAgent(AgentModule):
         So, we should just clean from time to time.
         What I added here is done only when the agent finalize, and it's quite light-ish operation anyway.
         """
-        res = self.jobMonitoringClient.getJobGroups(None, datetime.utcnow() - timedelta(days=365))
+        res = self.jobDB.getDistinctJobAttributes("JobGroup", None, datetime.utcnow() - timedelta(days=365))
         if not res["OK"]:
             self.log.error("Failed to get job groups", res["Message"])
             return res
@@ -268,7 +268,7 @@ class TransformationCleaningAgent(AgentModule):
 
             # Remove JobIDs that were unknown to the TransformationSystem
             jobGroupsToCheck = [str(transDict["TransformationID"]).zfill(8) for transDict in toClean + toArchive]
-            res = self.jobMonitoringClient.getJobs({"JobGroup": jobGroupsToCheck})
+            res = self.jobDB.selectJobs({"JobGroup": jobGroupsToCheck})
             if not res["OK"]:
                 return res
             jobIDsToRemove = [int(jobID) for jobID in res["Value"]]
@@ -610,8 +610,8 @@ class TransformationCleaningAgent(AgentModule):
         # Prevent 0 job IDs
         jobIDs = [int(j) for j in transJobIDs if int(j)]
         allRemove = True
-        for jobList in breakListIntoChunks(jobIDs, 500):
-            res = self.wmsClient.killJob(jobList, force=True)
+        for jobList in breakListIntoChunks(jobIDs, 1000):
+            res = kill_delete_jobs(RIGHT_KILL, jobList, force=True)
             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):
@@ -623,7 +623,7 @@ class TransformationCleaningAgent(AgentModule):
                 self.log.error("Failed to kill jobs", f"(n={len(res['FailedJobIDs'])})")
                 allRemove = False
 
-            res = self.wmsClient.deleteJob(jobList)
+            res = kill_delete_jobs(RIGHT_DELETE, jobList, force=True)
             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/TransformationSystem/Client/Transformation.py

@@ -9,6 +9,7 @@ from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Base.API import API
 from DIRAC.Core.Utilities.JEncode import encode
 from DIRAC.Core.Utilities.PromptUser import promptUser
+from DIRAC.MonitoringSystem.Client.WebAppClient import WebAppClient
 from DIRAC.RequestManagementSystem.Client.Operation import Operation
 from DIRAC.TransformationSystem.Client.BodyPlugin.BaseBody import BaseBody
 from DIRAC.TransformationSystem.Client.TransformationClient import TransformationClient
@@ -498,7 +499,7 @@ class Transformation(API):
         ]
         dictList = []
 
-        result = self.transClient.getTransformationSummaryWeb(condDict, orderby, start, maxitems)
+        result = WebAppClient().getTransformationSummaryWeb(condDict, orderby, start, maxitems)
         if not result["OK"]:
             self._prettyPrint(result)
             return result