DIRAC 9.0.14__py3-none-any.whl → 9.0.16__py3-none-any.whl

DIRAC/Resources/Computing/ComputingElement.py

@@ -1,40 +1,40 @@
-"""  The Computing Element class is a base class for all the various
-     types CEs. It serves several purposes:
+"""The Computing Element class is a base class for all the various
+types CEs. It serves several purposes:
 
-      - collects general CE related parameters to generate CE description
-        for the job matching
-      - provides logic for evaluation of the number of available CPU slots
-      - provides logic for the proxy renewal while executing jobs
+ - collects general CE related parameters to generate CE description
+   for the job matching
+ - provides logic for evaluation of the number of available CPU slots
+ - provides logic for the proxy renewal while executing jobs
 
-     The CE parameters are collected from the following sources, in hierarchy
-     descending order:
+The CE parameters are collected from the following sources, in hierarchy
+descending order:
 
-      - parameters provided through setParameters() method of the class
-      - parameters in /LocalSite configuration section
-      - parameters in /LocalSite/<ceName>/ResourceDict configuration section
-      - parameters in /LocalSite/ResourceDict configuration section
-      - parameters in /LocalSite/<ceName> configuration section
-      - parameters in /Resources/Computing/<ceName> configuration section
-      - parameters in /Resources/Computing/CEDefaults configuration section
+ - parameters provided through setParameters() method of the class
+ - parameters in /LocalSite configuration section
+ - parameters in /LocalSite/<ceName>/ResourceDict configuration section
+ - parameters in /LocalSite/ResourceDict configuration section
+ - parameters in /LocalSite/<ceName> configuration section
+ - parameters in /Resources/Computing/<ceName> configuration section
+ - parameters in /Resources/Computing/CEDefaults configuration section
 
-     The ComputingElement objects are usually instantiated with the help of
-     ComputingElementFactory.
+The ComputingElement objects are usually instantiated with the help of
+ComputingElementFactory.
 
-     The ComputingElement class can be considered abstract. 3 kinds of abstract ComputingElements
-     can be distinguished from it:
+The ComputingElement class can be considered abstract. 3 kinds of abstract ComputingElements
+can be distinguished from it:
 
-      - Remote ComputingElement: includes methods to interact with a remote ComputingElement
-        (e.g. HtCondorCEComputingElement, AREXComputingElement).
-      - Inner ComputingElement: includes methods to locally interact with an underlying worker node.
-        It is worth noting that an Inner ComputingElement provides synchronous submission
-        (the submission of a job is blocking the execution until its completion). It deals with one job at a time.
-      - Inner Pool ComputingElement: includes methods to locally interact with Inner ComputingElements asynchronously.
-        It can manage a pool of jobs running simultaneously.
+ - Remote ComputingElement: includes methods to interact with a remote ComputingElement
+   (e.g. HtCondorCEComputingElement, AREXComputingElement).
+ - Inner ComputingElement: includes methods to locally interact with an underlying worker node.
+   It is worth noting that an Inner ComputingElement provides synchronous submission
+   (the submission of a job is blocking the execution until its completion). It deals with one job at a time.
+ - Inner Pool ComputingElement: includes methods to locally interact with Inner ComputingElements asynchronously.
+   It can manage a pool of jobs running simultaneously.
 
-     To configure the use of Tokens for CEs:
+To configure the use of Tokens for CEs:
 
-     * the CE is able to receive any token. Validation: 'Tag = Token' should be included in the CE parameters.
-     * the CE is able to receive VO-specifc tokens. Validation: 'Tag = Token:<VO>' should be included in the CE parameters.
+* the CE is able to receive any token. Validation: 'Tag = Token' should be included in the CE parameters.
+* the CE is able to receive VO-specifc tokens. Validation: 'Tag = Token:<VO>' should be included in the CE parameters.
 
 """
 
@@ -50,9 +50,10 @@ from DIRAC.FrameworkSystem.Client.ProxyManagerClient import gProxyManager
 from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import (
     getNumberOfGPUs,
     getNumberOfProcessors,
+    getAvailableRAM,
 )
 
-INTEGER_PARAMETERS = ["CPUTime", "NumberOfProcessors", "NumberOfPayloadProcessors", "MaxRAM"]
+INTEGER_PARAMETERS = ["CPUTime", "CPUNormalizationFactor", "NumberOfProcessors", "NumberOfPayloadProcessors", "MaxRAM"]
 FLOAT_PARAMETERS = ["WaitingToRunningRatio"]
 LIST_PARAMETERS = ["Tag", "RequiredTag"]
 WAITING_TO_RUNNING_RATIO = 0.5
@@ -211,12 +212,14 @@ class ComputingElement:
                 generalCEDict.update(self.ceParameters)
                 self.ceParameters = generalCEDict
 
-        # If NumberOfProcessors/GPUs is present in the description but is equal to zero
+        # If NumberOfProcessors/GPUs/MaxRAM is present in the description but is equal to zero
         # interpret it as needing local evaluation
-        if self.ceParameters.get("NumberOfProcessors", -1) == 0:
+        if int(self.ceParameters.get("NumberOfProcessors", -1)) == 0:
             self.ceParameters["NumberOfProcessors"] = getNumberOfProcessors()
-        if self.ceParameters.get("NumberOfGPUs", -1) == 0:
+        if int(self.ceParameters.get("NumberOfGPUs", -1)) == 0:
             self.ceParameters["NumberOfGPUs"] = getNumberOfGPUs()
+        if int(self.ceParameters.get("MaxRAM", 0)) == 0:
+            self.ceParameters["MaxRAM"] = getAvailableRAM()
 
         for key in ceOptions:
             if key in INTEGER_PARAMETERS:
@@ -252,6 +255,7 @@ class ComputingElement:
         runningJobs = result["RunningJobs"]
         waitingJobs = result["WaitingJobs"]
         availableProcessors = result.get("AvailableProcessors")
+
         ceInfoDict = dict(result)
 
         maxTotalJobs = int(self.ceParameters.get("MaxTotalJobs", 0))
@@ -404,6 +408,7 @@ class ComputingElement:
         result = self.getCEStatus()
         if result["OK"]:
             ceDict["NumberOfProcessors"] = result.get("AvailableProcessors", result.get("NumberOfProcessors", 1))
+            ceDict["MaxRAM"] = result.get("AvailableRAM", result.get("MaxRAM", 1024))
         else:
             self.log.error(
                 "Failure getting CE status", "(we keep going without the number of waiting and running pilots/jobs)"
@@ -450,7 +455,7 @@ def getCEConfigDict(section: str) -> dict:
     ceOptions = result["Value"]
     for key in ceOptions:
         if key in INTEGER_PARAMETERS:
-            ceOptions[key] = int(ceOptions[key])
+            ceOptions[key] = int(float(ceOptions[key]))
         if key in FLOAT_PARAMETERS:
             ceOptions[key] = float(ceOptions[key])
         if key in LIST_PARAMETERS:

DIRAC/Resources/Computing/InProcessComputingElement.py

@@ -1,15 +1,15 @@
-""" The simplest of the "inner" CEs (meaning it's used by a jobAgent inside a pilot)
+"""The simplest of the "inner" CEs (meaning it's used by a jobAgent inside a pilot)
 
-    A "InProcess" CE instance submits jobs in the current process.
-    This is the standard "inner CE" invoked from the JobAgent, main alternative being the PoolCE
+A "InProcess" CE instance submits jobs in the current process.
+This is the standard "inner CE" invoked from the JobAgent, main alternative being the PoolCE
 """
+
 import os
 import stat
 
-from DIRAC import S_OK, S_ERROR
-from DIRAC.Core.Utilities.ThreadScheduler import gThreadScheduler
+from DIRAC import S_ERROR, S_OK
 from DIRAC.Core.Utilities.CGroups2 import CG2Manager
-
+from DIRAC.Core.Utilities.ThreadScheduler import gThreadScheduler
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
 
 
@@ -21,7 +21,8 @@ class InProcessComputingElement(ComputingElement):
         self.submittedJobs = 0
         self.runningJobs = 0
 
-        self.processors = int(self.ceParameters.get("NumberOfProcessors", 1))
+        self.processors = 1
+        self.maxRAM = 0
         self.ceParameters["MaxTotalJobs"] = 1
 
     def submitJob(self, executableFile, proxy=None, inputs=None, **kwargs):
@@ -33,6 +34,16 @@ class InProcessComputingElement(ComputingElement):
         :param list inputs: dependencies of executableFile
         :return: S_OK(payload exit code) / S_ERROR() if submission issue
         """
+        self.processors = int(self.ceParameters.get("NumberOfProcessors", self.processors))
+        self.maxRAM = int(self.ceParameters.get("MaxRAM", self.maxRAM))
+
+        if "numberOfProcessors" in kwargs:
+            if self.processors < int(kwargs["numberOfProcessors"]):
+                return S_ERROR("Requesting processors not available")
+        if "MaxRAM" in kwargs:
+            if self.maxRAM < int(kwargs["MaxRAM"]):
+                return S_ERROR("Requesting RAM not available")
+
         payloadEnv = dict(os.environ)
         payloadProxy = ""
         renewTask = None
@@ -118,4 +129,6 @@ class InProcessComputingElement(ComputingElement):
         result["WaitingJobs"] = 0
         # processors
         result["AvailableProcessors"] = self.processors
+        # RAM
+        result["AvailableRAM"] = self.maxRAM
         return result

DIRAC/Resources/Computing/PoolComputingElement.py

@@ -1,4 +1,4 @@
-""" The Pool Computing Element is an "inner" CE (meaning it's used by a jobAgent inside a pilot)
+"""The Pool Computing Element is an "inner" CE (meaning it's used by a jobAgent inside a pilot)
 
 It's used running several jobs simultaneously in separate processes, managed by a ProcessPool.
 
@@ -10,7 +10,7 @@ LocalCEType:
      LocalCEType = Pool
 
    The Pool Computing Element is specific: it embeds an additional "inner" CE
-   (`InProcess` by default, `Sudo`, `Singularity`). The "inner" CE can be specified such as::
+   (`InProcess` by default, or `Singularity`). The "inner" CE can be specified such as::
 
      LocalCEType = Pool/Singularity
 
@@ -19,24 +19,19 @@ NumberOfProcessors:
 
 **Code Documentation**
 """
-import functools
-import os
+
 import concurrent.futures
+import functools
 
-from DIRAC import S_OK, S_ERROR
+from DIRAC import S_ERROR, S_OK
 from DIRAC.ConfigurationSystem.private.ConfigurationData import ConfigurationData
-
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
-
 from DIRAC.Resources.Computing.InProcessComputingElement import InProcessComputingElement
 from DIRAC.Resources.Computing.SingularityComputingElement import SingularityComputingElement
 
-# Number of unix users to run job payloads with sudo
-MAX_NUMBER_OF_SUDO_UNIX_USERS = 32
-
 
-def executeJob(executableFile, proxy, taskID, inputs, **kwargs):
-    """wrapper around ce.submitJob: decides which CE to use (Sudo or InProcess or Singularity)
+def executeJob(executableFile, proxy, taskID, inputs, innerCEParameters, **kwargs):
+    """wrapper around ce.submitJob: decides which inner CE to use (InProcess or Singularity)
 
     :param str executableFile: location of the executable file
     :param str proxy: proxy file location to be used for job submission
@@ -52,6 +47,9 @@ def executeJob(executableFile, proxy, taskID, inputs, **kwargs):
     else:
         ce = InProcessComputingElement("Task-" + str(taskID))
 
+    # adding the number of processors to use and the RAM
+    ce.ceParameters["NumberOfProcessors"] = innerCEParameters["NumberOfProcessors"]
+    ce.ceParameters["MaxRAM"] = innerCEParameters["MaxRAM"]
     return ce.submitJob(executableFile, proxy, inputs=inputs, **kwargs)
 
 
@@ -66,7 +64,8 @@ class PoolComputingElement(ComputingElement):
         self.pPool = None
         self.taskID = 0
         self.processorsPerTask = {}
-        self.userNumberPerTask = {}
+        self.ramPerTask = {}
+        self.ram = 0  # effectively this means "no limits"
 
         # This CE will effectively submit to another "Inner"CE
         # (by default to the InProcess CE)
@@ -80,22 +79,14 @@ class PoolComputingElement(ComputingElement):
 
         self.processors = int(self.ceParameters.get("NumberOfProcessors", self.processors))
         self.ceParameters["MaxTotalJobs"] = self.processors
+        if self.ceParameters.get("MaxRAM", 0):  # if there's a limit, we set it
+            self.ram = int(self.ceParameters["MaxRAM"])
         # Indicates that the submission is done asynchronously
         # The result is not immediately available
         self.ceParameters["AsyncSubmission"] = True
         self.innerCESubmissionType = self.ceParameters.get("InnerCESubmissionType", self.innerCESubmissionType)
         return S_OK()
 
-    def getProcessorsInUse(self):
-        """Get the number of currently allocated processor cores
-
-        :return: number of processors in use
-        """
-        processorsInUse = 0
-        for future in self.processorsPerTask:
-            processorsInUse += self.processorsPerTask[future]
-        return processorsInUse
-
     #############################################################################
     def submitJob(self, executableFile, proxy=None, inputs=None, **kwargs):
         """Method to submit job.
@@ -118,33 +109,42 @@ class PoolComputingElement(ComputingElement):
             self.taskID += 1
             return S_OK(taskID)
 
-        # Now persisting the job limits for later use in pilot.cfg file (pilot 3 default)
+        memoryForJob = self._getMemoryForJobs(kwargs)
+
+        if memoryForJob is None:
+            self.taskResults[self.taskID] = S_ERROR("Not enough memory for the job")
+            taskID = self.taskID
+            self.taskID += 1
+            return S_OK(taskID)
+
+        # Now persisting the job limits for later use in pilot.cfg file
         cd = ConfigurationData(loadDefaultCFG=False)
         res = cd.loadFile("pilot.cfg")
         if not res["OK"]:
             self.log.error("Could not load pilot.cfg", res["Message"])
         else:
-            # only NumberOfProcessors for now, but RAM (or other stuff) can also be added
             jobID = int(kwargs.get("jobDesc", {}).get("jobID", 0))
             cd.setOptionInCFG("/Resources/Computing/JobLimits/%d/NumberOfProcessors" % jobID, processorsForJob)
+            cd.setOptionInCFG("/Resources/Computing/JobLimits/%d/MaxRAM" % jobID, memoryForJob)
             res = cd.dumpLocalCFGToFile("pilot.cfg")
             if not res["OK"]:
                 self.log.error("Could not dump cfg to pilot.cfg", res["Message"])
 
+        # Define the innerCEParameters
+        innerCEParameters = {}
+        innerCEParameters["NumberOfProcessors"] = processorsForJob
+        innerCEParameters["MaxRAM"] = memoryForJob
+
         # Here we define task kwargs: adding complex objects like thread.Lock can trigger errors in the task
         taskKwargs = {"InnerCESubmissionType": self.innerCESubmissionType}
         taskKwargs["jobDesc"] = kwargs.get("jobDesc", {})
-        if self.innerCESubmissionType == "Sudo":
-            for nUser in range(MAX_NUMBER_OF_SUDO_UNIX_USERS):
-                if nUser not in self.userNumberPerTask.values():
-                    break
-            taskKwargs["NUser"] = nUser
-            if "USER" in os.environ:
-                taskKwargs["PayloadUser"] = os.environ["USER"] + f"p{str(nUser).zfill(2)}"
 
         # Submission
-        future = self.pPool.submit(executeJob, executableFile, proxy, self.taskID, inputs, **taskKwargs)
+        future = self.pPool.submit(
+            executeJob, executableFile, proxy, self.taskID, inputs, innerCEParameters, **taskKwargs
+        )
         self.processorsPerTask[future] = processorsForJob
+        self.ramPerTask[future] = memoryForJob
         future.add_done_callback(functools.partial(self.finalizeJob, self.taskID))
 
         taskID = self.taskID
@@ -154,7 +154,7 @@ class PoolComputingElement(ComputingElement):
 
     def _getProcessorsForJobs(self, kwargs):
         """helper function"""
-        processorsInUse = self.getProcessorsInUse()
+        processorsInUse = sum(self.processorsPerTask.values())
         availableProcessors = self.processors - processorsInUse
 
         self.log.verbose(
@@ -191,29 +191,61 @@ class PoolComputingElement(ComputingElement):
 
         return requestedProcessors
 
+    def _getMemoryForJobs(self, kwargs):
+        """helper function to get the memory that will be allocated for the job
+
+        :param kwargs: job parameters
+        :return: memory in MB or None if not enough memory
+        """
+
+        # # job requirements
+        requestedMemory = kwargs.get("MinRAM", kwargs.get("MaxRAM", 0))
+        # if there's no limit, we just let it match the maximum
+        if not self.ram:
+            return max(requestedMemory, kwargs.get("MaxRAM", 0))
+
+        # # now check what the slot can provide
+        # Do we have enough memory?
+        availableMemory = self.ram - sum(self.ramPerTask.values())
+        if availableMemory < requestedMemory:
+            return None
+
+        # if there's a MaxRAM requested, we allocate it all (if it fits),
+        # and if it doesn't, we stop here instead of using MinRAM
+        if kwargs.get("MaxRAM", 0):
+            if availableMemory >= kwargs.get("MaxRAM"):
+                requestedMemory = kwargs.get("MaxRAM")
+            else:
+                return None
+
+        return requestedMemory
+
     def finalizeJob(self, taskID, future):
         """Finalize the job by updating the process utilisation counters
 
         :param future: evaluating the future result
         """
         nProc = self.processorsPerTask.pop(future)
+        ram = self.ramPerTask.pop(future, None)
 
         result = future.result()  # This would be the result of the e.g. InProcess.submitJob()
         if result["OK"]:
-            self.log.info("Task finished successfully:", f"{taskID}; {nProc} processor(s) freed")
+            self.log.info("Task finished successfully:", f"{taskID}; {nProc} processor(s) and {ram}MB freed")
         else:
             self.log.error("Task failed submission:", f"{taskID}; message: {result['Message']}")
         self.taskResults[taskID] = result
 
     def getCEStatus(self):
         """Method to return information on running and waiting jobs,
-            as well as the number of processors (used, and available).
+        as well as the number of processors (used, and available),
+        and the RAM (used, and available)
 
         :return: dictionary of numbers of jobs per status and processors (used, and available)
         """
 
         result = S_OK()
         nJobs = 0
+
         for _j, value in self.processorsPerTask.items():
             if value > 0:
                 nJobs += 1
@@ -222,9 +254,16 @@ class PoolComputingElement(ComputingElement):
         result["WaitingJobs"] = 0
 
         # dealing with processors
-        processorsInUse = self.getProcessorsInUse()
+        processorsInUse = sum(self.processorsPerTask.values())
         result["UsedProcessors"] = processorsInUse
         result["AvailableProcessors"] = self.processors - processorsInUse
+        # dealing with RAM
+        result["UsedRAM"] = sum(self.ramPerTask.values())
+        if self.ram:
+            result["AvailableRAM"] = self.ram - sum(self.ramPerTask.values())
+        else:
+            result["AvailableRAM"] = 0
+
         return result
 
     def getDescription(self):

DIRAC/Resources/Computing/SingularityComputingElement.py

@@ -1,16 +1,17 @@
-""" SingularityCE is a type of "inner" CEs
-    (meaning it's used by a jobAgent inside a pilot).
-    A computing element class using singularity containers,
-    where Singularity is supposed to be found on the WN.
+"""SingularityCE is a type of "inner" CEs
+(meaning it's used by a jobAgent inside a pilot).
+A computing element class using singularity containers,
+where Singularity is supposed to be found on the WN.
 
-    The goal of this CE is to start the job in the container set by
-    the "ContainerRoot" config option.
+The goal of this CE is to start the job in the container set by
+the "ContainerRoot" config option.
 
-    DIRAC can be re-installed within the container.
+DIRAC can be re-installed within the container.
 
-    See the Configuration/Resources/Computing documention for details on
-    where to set the option parameters.
+See the Configuration/Resources/Computing documention for details on
+where to set the option parameters.
 """
+
 import json
 import os
 import re
@@ -115,6 +116,7 @@ class SingularityComputingElement(ComputingElement):
             self.__installDIRACInContainer = False
 
         self.processors = int(self.ceParameters.get("NumberOfProcessors", 1))
+        self.maxRAM = int(self.ceParameters.get("MaxRAM", 0))
 
     @staticmethod
     def __findInstallBaseDir():
@@ -415,6 +417,12 @@ class SingularityComputingElement(ComputingElement):
 
         self.log.debug(f"Execute singularity command: {cmd}")
         self.log.debug(f"Execute singularity env: {self.__getEnv()}")
+        # systemCall below uses ceParameters["MemoryLimitMB"] as CG2 upper memory limit
+        # if there's a max RAM available to the job, use that
+        if self.maxRAM:
+            self.ceParameters["MemoryLimitMB"] = min(
+                self.maxRAM, int(self.ceParameters.get("MemoryLimitMB", 1024 * 1024))
+            )  # 1024 * 1024 is an arbitrary large number
         result = CG2Manager().systemCall(
             0, cmd, callbackFunction=self.sendOutput, env=self.__getEnv(), ceParameters=self.ceParameters
         )
@@ -451,4 +459,6 @@ class SingularityComputingElement(ComputingElement):
         result["WaitingJobs"] = 0
         # processors
         result["AvailableProcessors"] = self.processors
+        # RAM
+        result["AvailableRAM"] = self.maxRAM
         return result

DIRAC/Resources/Computing/test/Test_InProcessComputingElement.py

@@ -8,25 +8,41 @@ import shutil
 
 import pytest
 
-from DIRAC.Resources.Computing.test.Test_PoolComputingElement import jobScript, _stopJob
-from DIRAC.WorkloadManagementSystem.Utilities.Utils import createJobWrapper
-
 # sut
 from DIRAC.Resources.Computing.InProcessComputingElement import InProcessComputingElement
+from DIRAC.Resources.Computing.test.Test_PoolComputingElement import _stopJob, jobScript
+from DIRAC.WorkloadManagementSystem.Utilities.Utils import createJobWrapper
 
 
 @pytest.mark.slow
-def test_submitJob():
+@pytest.mark.parametrize(
+    "ce_parameters, available_processors, ram",
+    [
+        ({}, 1, 0),
+        ({"NumberOfProcessors": 8}, 8, 0),
+        ({"MaxRAM": 2048}, 1, 2048),
+        ({"NumberOfProcessors": 8, "MaxRAM": 2048}, 8, 2048),
+    ],
+)
+def test_submitJob(ce_parameters, available_processors, ram):
+    # initialization
+    ce = InProcessComputingElement("InProcessCE")
+    ce.ceParameters = ce_parameters
+
+    # simple
     with open("testJob.py", "w") as execFile:
         execFile.write(jobScript % "1")
     os.chmod("testJob.py", 0o755)
 
-    ce = InProcessComputingElement("InProcessCE")
     res = ce.submitJob("testJob.py", None)
     assert res["OK"] is True
     res = ce.getCEStatus()
     assert res["OK"] is True
     assert res["SubmittedJobs"] == 1
+    assert res["RunningJobs"] == 0
+    assert res["WaitingJobs"] == 0
+    assert res["AvailableProcessors"] == available_processors
+    assert res["AvailableRAM"] == ram
     _stopJob(1)
     for ff in ["testJob.py", "stop_job_2", "job.info", "std.out"]:
         if os.path.isfile(ff):
@@ -50,21 +66,66 @@ def test_submitJob():
     res = ce.submitJob(
         wrapperFile,
         proxy=None,
-        numberOfProcessors=4,
-        maxNumberOfProcessors=8,
+        numberOfProcessors=available_processors,
+        maxNumberOfProcessors=available_processors,
         wholeNode=False,
         mpTag=True,
+        MinRAM=ram,
+        MaxRAM=ram,
         jobDesc={"jobParams": jobParams, "resourceParams": resourceParams, "optimizerParams": optimizerParams},
     )
     assert res["OK"] is True
+    _stopJob(2)
 
     res = ce.getCEStatus()
     assert res["OK"] is True
     assert res["SubmittedJobs"] == 2
+    assert res["RunningJobs"] == 0
+    assert res["WaitingJobs"] == 0
+    assert res["AvailableProcessors"] == available_processors
+    assert res["AvailableRAM"] == ram
 
-    _stopJob(2)
     for ff in ["testJob.py", "stop_job_2", "job.info", "std.out"]:
         if os.path.isfile(ff):
             os.remove(ff)
     if os.path.isdir("job"):
         shutil.rmtree("job")
+
+    # failing
+    with open("testJob.py", "w") as execFile:
+        execFile.write(jobScript % "3")
+    os.chmod("testJob.py", 0o755)
+
+    jobParams = {"JobType": "User", "Executable": "testJob.py"}
+    resourceParams = {"GridCE": "some_CE"}
+    optimizerParams = {}
+
+    wrapperFile = createJobWrapper(
+        jobID=3, jobParams=jobParams, resourceParams=resourceParams, optimizerParams=optimizerParams, logLevel="DEBUG"
+    )["Value"][
+        "JobExecutablePath"
+    ]  # This is not under test, assuming it works fine
+
+    res = ce.submitJob(
+        wrapperFile,
+        proxy=None,
+        numberOfProcessors=4 + available_processors,
+        maxNumberOfProcessors=8 + available_processors,
+        wholeNode=False,
+        mpTag=True,
+        MinRAM=2500,
+        MaxRAM=4000,
+        jobDesc={"jobParams": jobParams, "resourceParams": resourceParams, "optimizerParams": optimizerParams},
+    )
+    assert res["OK"] is False
+    res = ce.getCEStatus()
+    assert res["OK"] is True
+    assert res["SubmittedJobs"] == 2
+    assert res["RunningJobs"] == 0
+    assert res["WaitingJobs"] == 0
+    assert res["AvailableProcessors"] == available_processors
+    assert res["AvailableRAM"] == ram
+    _stopJob(1)
+    for ff in ["testJob.py", "stop_job_3", "job.info", "std.out"]:
+        if os.path.isfile(ff):
+            os.remove(ff)