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

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",
     [
@@ -611,7 +613,7 @@ def test_submitJob(mocker, mockJWInput, expected):
         ("Pool/Singularity", jobScript % "1", (["Failed to find singularity"], []), ([], [])),
     ],
 )
-def test_submitAndCheckJob(mocker, manageJobFiles, localCE, job, expectedResult1, expectedResult2):
+def test_submitAndCheckJob(mocker, manageJobFiles, localCE, job, expectedResult1, expectedResult2, tmp_path):
     """Test the submission and the management of the job status."""
     jobID = "123"
     jobExecutablePath, jobWrapperPath, jobWrapperConfigPath = manageJobFiles
@@ -635,7 +637,12 @@ def test_submitAndCheckJob(mocker, manageJobFiles, localCE, job, expectedResult1
         ),
     )
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobAgent.JobAgent._sendFailoverRequest", return_value=S_OK())
-    mocker.patch("DIRAC.Core.Security.X509Chain.X509Chain.dumpAllToString", return_value=S_OK())
+    empty_file_path = tmp_path / "empty_file"
+    empty_file_path.touch()
+    mocker.patch(
+        "DIRAC.WorkloadManagementSystem.Agent.JobAgent.writeChainToTemporaryFile",
+        return_value=S_OK(str(empty_file_path)),
+    )
     mocker.patch(
         "DIRAC.Resources.Computing.SingularityComputingElement.SingularityComputingElement.submitJob",
         return_value=S_ERROR("Failed to find singularity"),
@@ -712,7 +719,7 @@ def test_submitAndCheckJob(mocker, manageJobFiles, localCE, job, expectedResult1
     assert len(jobAgent.computingElement.taskResults) == 0
 
 
-def test_submitAndCheck2Jobs(mocker):
+def test_submitAndCheck2Jobs(mocker, tmp_path):
     """Test the submission and the management of the job status.
 
     This time, a first job is successfully submitted, but the second submission fails.
@@ -728,7 +735,17 @@ def test_submitAndCheck2Jobs(mocker):
         ),
     )
     mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobAgent.JobAgent._sendFailoverRequest", return_value=S_OK())
-    mocker.patch("DIRAC.Core.Security.X509Chain.X509Chain.dumpAllToString", return_value=S_OK())
+
+    def make_empty_file(*args, **kwargs):
+        """Create an empty file and return its path."""
+        empty_file_path = tmp_path / "empty_file"
+        empty_file_path.touch()
+        return S_OK(str(empty_file_path))
+
+    mocker.patch(
+        "DIRAC.WorkloadManagementSystem.Agent.JobAgent.writeChainToTemporaryFile",
+        make_empty_file,
+    )
     mocker.patch(
         "DIRAC.Resources.Computing.InProcessComputingElement.InProcessComputingElement.submitJob",
         side_effect=[S_OK(), S_ERROR("ComputingElement error")],
@@ -788,3 +805,27 @@ def test_submitAndCheck2Jobs(mocker):
 
     # From here, taskResults should be empty
     assert len(jobAgent.computingElement.taskResults) == 0
+
+
+def test_failureBeforeSubmission(mocker):
+    """Test that a failure before job submission is handled correctly.
+
+    We want to make sure that there is no endless loop in the finalize method.
+    """
+    # Mock the JobAgent
+    mocker.patch("DIRAC.WorkloadManagementSystem.Agent.JobAgent.AgentModule.__init__")
+
+    jobAgent = JobAgent("JobAgent", "Test")
+    jobAgent.log = gLogger.getSubLogger("JobAgent")
+
+    # Here we simulate a failure before the job submission: no TaskID
+    jobID = "123"
+    jobAgent.jobs[jobID] = {}
+    jobAgent.jobs[jobID]["JobReport"] = JobReport(jobID)
+
+    # Make sure that the job is removed from jobAgent.jobs
+    result = jobAgent._checkSubmittedJobs()
+    assert result["OK"]
+    assert result["Value"] == ([], [])
+
+    assert jobAgent.jobs == {}

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
@@ -261,6 +267,7 @@ def test_getPilotWrapper(mocker, sd, pilotWrapperDirectory):
     # Get pilot options
     pilotOptions = sd._getPilotOptions("ce1.site1.com_condor")
     assert {
+        "--architectureScript=123",
         "--preinstalledEnv=123",
         "--wnVO=dteam",
         "-n LCG.Site1.com",

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
@@ -12,8 +13,6 @@ from DIRAC.DataManagementSystem.Utilities.DMSHelpers import DMSHelpers
 from DIRAC.Resources.Storage.StorageElement import StorageElement
 from DIRAC.WorkloadManagementSystem.Client.JobStateUpdateClient import JobStateUpdateClient
 
-COMPONENT_NAME = "DownloadInputData"
-
 
 def _isCached(lfn, seName):
     result = returnSingleResult(StorageElement(seName).getFileMetadata(lfn))
@@ -137,7 +136,7 @@ class DownloadInputData:
         if not result["Value"]:
             self.log.warn("Not enough disk space available for download", f"{result['Value']} / {totalSize} bytes")
             self.__setJobParam(
-                COMPONENT_NAME,
+                self.__class__.__name__,
                 f"Not enough disk space available for download: {result['Value']} / {totalSize} bytes",
             )
             return S_OK({"Failed": self.inputData, "Successful": {}})
@@ -216,7 +215,7 @@ class DownloadInputData:
             report += "\n".join(failedReplicas)
 
         if report:
-            self.__setJobParam(COMPONENT_NAME, report)
+            self.__setJobParam(self.__class__.__name__, report)
 
         return S_OK({"Successful": resolvedData, "Failed": failedReplicas})
 
@@ -228,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:
@@ -245,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/InputDataResolution.py

@@ -6,13 +6,14 @@
     result and in principle has all the necessary information to resolve input data
     for applications.
 """
+from pathlib import Path
+
 import DIRAC
-from DIRAC import S_OK, S_ERROR, gLogger, gConfig
+from DIRAC import S_ERROR, S_OK, gConfig, gLogger
+from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
 from DIRAC.WorkloadManagementSystem.Client.PoolXMLSlice import PoolXMLSlice
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 
-COMPONENT_NAME = "InputDataResolution"
 CREATE_CATALOG = False
 
 
@@ -22,8 +23,7 @@ class InputDataResolution:
     def __init__(self, argumentsDict):
         """Standard constructor"""
         self.arguments = argumentsDict
-        self.name = COMPONENT_NAME
-        self.log = gLogger.getSubLogger(self.name)
+        self.log = gLogger.getSubLogger(self.__class__.__name__)
         op = Operations()
         self.arguments.setdefault("Configuration", {})["AllReplicas"] = op.getValue(
             "InputDataPolicy/AllReplicas", False
@@ -78,7 +78,7 @@ class InputDataResolution:
         self.log.verbose(f"Catalog name will be: {catalogName}")
 
         resolvedData = tmpDict
-        appCatalog = PoolXMLSlice(catalogName)
+        appCatalog = PoolXMLSlice(catalogName, Path(self.arguments["Configuration"].get("JobIDPath", "")))
         return appCatalog.execute(resolvedData)
 
     def __resolveInputData(self):

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

DIRAC/WorkloadManagementSystem/Client/JobReport.py

@@ -4,7 +4,7 @@
 import datetime
 from collections import defaultdict
 
-from DIRAC import S_OK, S_ERROR, gLogger
+from DIRAC import S_ERROR, S_OK, gLogger
 from DIRAC.Core.Utilities import DEncode
 from DIRAC.RequestManagementSystem.Client.Operation import Operation
 from DIRAC.WorkloadManagementSystem.Client.JobStateUpdateClient import JobStateUpdateClient

DIRAC/WorkloadManagementSystem/Client/JobState/CachedJobState.py

@@ -364,6 +364,9 @@ class CachedJobState:
     def getInputData(self):
         return self.__cacheResult("inputData", self.__jobState.getInputData)
 
+    def setInputData(self, inputData):
+        return self.__jobState.setInputData(inputData)
+
     def insertIntoTQ(self):
         if self.valid:
             self.__insertIntoTQ = True

DIRAC/WorkloadManagementSystem/Client/JobState/JobManifest.py

@@ -1,266 +1,37 @@
-from diraccfg import CFG
+from __future__ import annotations
 
-from DIRAC import S_OK, S_ERROR
-from DIRAC.Core.Utilities import List
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
-from DIRAC.Core.Utilities.JDL import loadJDLAsCFG, dumpCFGAsJDL
-
-
-class JobManifest:
-    def __init__(self, manifest=""):
-        self.__manifest = CFG()
-        self.__dirty = False
-        self.__ops = False
-        if manifest:
-            result = self.load(manifest)
-            if not result["OK"]:
-                raise Exception(result["Message"])
-
-    def isDirty(self):
-        return self.__dirty
-
-    def setDirty(self):
-        self.__dirty = True
-
-    def clearDirty(self):
-        self.__dirty = False
-
-    def load(self, dataString):
-        """
-        Auto discover format type based on [ .. ] of JDL
-        """
-        dataString = dataString.strip()
-        if dataString[0] == "[" and dataString[-1] == "]":
-            return self.loadJDL(dataString)
-        else:
-            return self.loadCFG(dataString)
-
-    def loadJDL(self, jdlString):
-        """
-        Load job manifest from JDL format
-        """
-        result = loadJDLAsCFG(jdlString.strip())
-        if not result["OK"]:
-            self.__manifest = CFG()
-            return result
-        self.__manifest = result["Value"][0]
-        return S_OK()
-
-    def loadCFG(self, cfgString):
-        """
-        Load job manifest from CFG format
-        """
-        try:
-            self.__manifest.loadFromBuffer(cfgString)
-        except Exception as e:
-            return S_ERROR(f"Can't load manifest from cfg: {str(e)}")
-        return S_OK()
-
-    def dumpAsCFG(self):
-        return str(self.__manifest)
-
-    def getAsCFG(self):
-        return self.__manifest.clone()
-
-    def dumpAsJDL(self):
-        return dumpCFGAsJDL(self.__manifest)
-
-    def __getCSValue(self, varName, defaultVal=None):
-        if not self.__ops:
-            self.__ops = Operations(group=self.__manifest["OwnerGroup"])
-        if varName[0] != "/":
-            varName = f"JobDescription/{varName}"
-        return self.__ops.getValue(varName, defaultVal)
-
-    def __checkNumericalVar(self, varName, defaultVal, minVal, maxVal):
-        """
-        Check a numerical var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            varValue = self.__getCSValue(f"Default{varName}", defaultVal)
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        try:
-            varValue = int(varValue)
-        except ValueError:
-            return S_ERROR(f"{varName} must be a number")
-        minVal = self.__getCSValue(f"Min{varName}", minVal)
-        maxVal = self.__getCSValue(f"Max{varName}", maxVal)
-        varValue = max(minVal, min(varValue, maxVal))
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
-
-    def __checkChoiceVar(self, varName, defaultVal, choices):
-        """
-        Check a choice var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            varValue = self.__getCSValue(f"Default{varName}", defaultVal)
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        if varValue not in self.__getCSValue(f"Choices{varName}", choices):
-            return S_ERROR(f"{varValue} is not a valid value for {varName}")
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
-
-    def __checkMultiChoice(self, varName, choices):
-        """
-        Check a multi choice var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            return S_OK()
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        choices = self.__getCSValue(f"Choices{varName}", choices)
-        for v in List.fromChar(varValue):
-            if v not in choices:
-                return S_ERROR(f"{v} is not a valid value for {varName}")
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
+from DIRACCommon.WorkloadManagementSystem.Client.JobState.JobManifest import *  # noqa: F401, F403
 
-    def __checkMaxInputData(self, maxNumber):
-        """
-        Check Maximum Number of Input Data files allowed
-        """
-        varName = "InputData"
-        if varName not in self.__manifest:
-            return S_OK()
-        varValue = self.__manifest[varName]
-        if len(List.fromChar(varValue)) > maxNumber:
-            return S_ERROR(
-                "Number of Input Data Files (%s) greater than current limit: %s"
-                % (len(List.fromChar(varValue)), maxNumber)
-            )
-        return S_OK()
-
-    def __contains__(self, key):
-        """Check if the manifest has the required key"""
-        return key in self.__manifest
+from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 
-    def setOptionsFromDict(self, varDict):
-        for k in sorted(varDict):
-            self.setOption(k, varDict[k])
 
+def makeJobManifestConfig(ownerGroup: str) -> JobManifestConfig:
+    ops = Operations(group=ownerGroup)
+
+    allowedJobTypesForGroup = ops.getValue(
+        "JobDescription/ChoicesJobType",
+        ops.getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
+        + ops.getValue("Transformations/DataProcessing", []),
+    )
+
+    return {
+        "defaultForGroup": {
+            "CPUTime": ops.getValue("JobDescription/DefaultCPUTime", 86400),
+            "Priority": ops.getValue("JobDescription/DefaultPriority", 1),
+        },
+        "minForGroup": {
+            "CPUTime": ops.getValue("JobDescription/MinCPUTime", 100),
+            "Priority": ops.getValue("JobDescription/MinPriority", 0),
+        },
+        "maxForGroup": {
+            "CPUTime": ops.getValue("JobDescription/MaxCPUTime", 500000),
+            "Priority": ops.getValue("JobDescription/MaxPriority", 10),
+        },
+        "allowedJobTypesForGroup": allowedJobTypesForGroup,
+        "maxInputData": Operations().getValue("JobDescription/MaxInputData", 500),
+    }
+
+
+class JobManifest(JobManifest):  # noqa: F405 pylint: disable=function-redefined
     def check(self):
-        """
-        Check that the manifest is OK
-        """
-        for k in ["Owner", "OwnerGroup"]:
-            if k not in self.__manifest:
-                return S_ERROR(f"Missing var {k} in manifest")
-
-        # Check CPUTime
-        result = self.__checkNumericalVar("CPUTime", 86400, 100, 500000)
-        if not result["OK"]:
-            return result
-
-        result = self.__checkNumericalVar("Priority", 1, 0, 10)
-        if not result["OK"]:
-            return result
-
-        maxInputData = Operations().getValue("JobDescription/MaxInputData", 500)
-        result = self.__checkMaxInputData(maxInputData)
-        if not result["OK"]:
-            return result
-
-        operation = Operations(group=self.__manifest["OwnerGroup"])
-        allowedJobTypes = operation.getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
-        transformationTypes = operation.getValue("Transformations/DataProcessing", [])
-        result = self.__checkMultiChoice("JobType", allowedJobTypes + transformationTypes)
-        if not result["OK"]:
-            return result
-        return S_OK()
-
-    def createSection(self, secName, contents=False):
-        if secName not in self.__manifest:
-            if contents and not isinstance(contents, CFG):
-                return S_ERROR(f"Contents for section {secName} is not a cfg object")
-            self.__dirty = True
-            return S_OK(self.__manifest.createNewSection(secName, contents=contents))
-        return S_ERROR(f"Section {secName} already exists")
-
-    def getSection(self, secName):
-        self.__dirty = True
-        if secName not in self.__manifest:
-            return S_ERROR(f"{secName} does not exist")
-        sec = self.__manifest[secName]
-        if not sec:
-            return S_ERROR(f"{secName} section empty")
-        return S_OK(sec)
-
-    def setSectionContents(self, secName, contents):
-        if contents and not isinstance(contents, CFG):
-            return S_ERROR(f"Contents for section {secName} is not a cfg object")
-        self.__dirty = True
-        if secName in self.__manifest:
-            self.__manifest[secName].reset()
-            self.__manifest[secName].mergeWith(contents)
-        else:
-            self.__manifest.createNewSection(secName, contents=contents)
-
-    def setOption(self, varName, varValue):
-        """
-        Set a var in job manifest
-        """
-        self.__dirty = True
-        levels = List.fromChar(varName, "/")
-        cfg = self.__manifest
-        for l in levels[:-1]:
-            if l not in cfg:
-                cfg.createNewSection(l)
-            cfg = cfg[l]
-        cfg.setOption(levels[-1], varValue)
-
-    def remove(self, opName):
-        levels = List.fromChar(opName, "/")
-        cfg = self.__manifest
-        for l in levels[:-1]:
-            if l not in cfg:
-                return S_ERROR(f"{opName} does not exist")
-            cfg = cfg[l]
-        if cfg.deleteKey(levels[-1]):
-            self.__dirty = True
-            return S_OK()
-        return S_ERROR(f"{opName} does not exist")
-
-    def getOption(self, varName, defaultValue=None):
-        """
-        Get a variable from the job manifest
-        """
-        cfg = self.__manifest
-        return cfg.getOption(varName, defaultValue)
-
-    def getOptionList(self, section=""):
-        """
-        Get a list of variables in a section of the job manifest
-        """
-        cfg = self.__manifest.getRecursive(section)
-        if not cfg or "value" not in cfg:
-            return []
-        cfg = cfg["value"]
-        return cfg.listOptions()
-
-    def isOption(self, opName):
-        """
-        Check if it is a valid option
-        """
-        return self.__manifest.isOption(opName)
-
-    def getSectionList(self, section=""):
-        """
-        Get a list of sections in the job manifest
-        """
-        cfg = self.__manifest.getRecursive(section)
-        if not cfg or "value" not in cfg:
-            return []
-        cfg = cfg["value"]
-        return cfg.listSections()
+        return super().check(config=makeJobManifestConfig(self.__manifest["OwnerGroup"]))