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

DIRAC/Resources/Computing/BatchSystems/Condor.py

@@ -6,6 +6,7 @@
 from __future__ import print_function
 from __future__ import absolute_import
 from __future__ import division
+import json
 import re
 import tempfile
 import subprocess
@@ -25,6 +26,8 @@ STATES_MAP = {
 
 HOLD_REASON_SUBCODE = "55"
 
+STATE_ATTRIBUTES = "ClusterId,ProcId,JobStatus,HoldReasonCode,HoldReasonSubCode,HoldReason"
+
 subTemplate = """
 # Environment
 # -----------
@@ -62,6 +65,7 @@ environment = "DIRAC_PILOT_STAMP=$(stamp) %(environment)s"
 # Requirements
 # ------------
 request_cpus = %(processors)s
+requirements = NumJobStarts == 0
 
 # Exit options
 # ------------
@@ -73,7 +77,8 @@ on_exit_hold = ExitCode =!= 0
 # A subcode of our choice to identify who put the job on hold
 on_exit_hold_subcode = %(holdReasonSubcode)s
 # Jobs are then deleted from the system after N days if they are not idle or running
-periodic_remove = (JobStatus != 1) && (JobStatus != 2) && ((time() - EnteredCurrentStatus) > (%(daysToKeepRemoteLogs)s * 24 * 3600))
+periodic_remove = ((JobStatus == 1) && (NumJobStarts > 0)) || \
+    ((JobStatus != 1) && (JobStatus != 2) && ((time() - EnteredCurrentStatus) > (%(daysToKeepRemoteLogs)s * 24 * 3600)))
 
 # Specific options
 # ----------------
@@ -87,63 +92,34 @@ Queue stamp in %(pilotStampList)s
 """
 
 
-def parseCondorStatus(lines, jobID):
+def getCondorStatus(jobMetadata):
     """parse the condor_q or condor_history output for the job status
 
-    :param lines: list of lines from the output of the condor commands, each line is a tuple of jobID, statusID, and holdReasonCode
-    :type lines: python:list
-    :param str jobID: jobID of condor job, e.g.: 123.53
+    :param jobMetadata: dict with job metadata
+    :type jobMetadata: dict[str, str | int]
     :returns: Status as known by DIRAC, and a reason if the job is being held
     """
-    jobID = str(jobID)
-
-    holdReason = ""
-    status = None
-    for line in lines:
-        l = line.strip().split()
-
-        # Make sure the job ID exists
-        if len(l) < 1 or l[0] != jobID:
-            continue
-
-        # Make sure the status is present and is an integer
-        try:
-            status = int(l[1])
-        except (ValueError, IndexError):
-            break
-
-        # Stop here if the status is not held (5): result should be found in STATES_MAP
-        if status != 5:
-            break
-
-        # A job can be held for various reasons,
-        # we need to further investigate with the holdReasonCode & holdReasonSubCode
-        # Details in:
-        # https://htcondor.readthedocs.io/en/latest/classad-attributes/job-classad-attributes.html#HoldReasonCode
-
-        # By default, a held (5) job is defined as Aborted in STATES_MAP, but there might be some exceptions
-        status = 3
-        try:
-            holdReasonCode = l[2]
-            holdReasonSubcode = l[3]
-            holdReason = " ".join(l[4:])
-        except IndexError:
-            # This should not happen in theory
-            # Just set the status to unknown such as
-            status = None
-            holdReasonCode = "undefined"
-            holdReasonSubcode = "undefined"
-            break
-
-        # If holdReasonCode is 3 (The PERIODIC_HOLD expression evaluated to True. Or, ON_EXIT_HOLD was true)
-        # And subcode is HOLD_REASON_SUBCODE, then it means the job failed by itself, it needs to be marked as Failed
-        if holdReasonCode == "3" and holdReasonSubcode == HOLD_REASON_SUBCODE:
-            status = 5
-        # If holdReasonCode is 16 (Input files are being spooled), the job should be marked as Waiting
-        elif holdReasonCode == "16":
-            status = 1
-
-    return (STATES_MAP.get(status, "Unknown"), holdReason)
+    if jobMetadata["JobStatus"] != 5:
+        # If the job is not held, we can return the status directly
+        return (STATES_MAP.get(jobMetadata["JobStatus"], "Unknown"), "")
+
+    # A job can be held for various reasons,
+    # we need to further investigate with the holdReasonCode & holdReasonSubCode
+    # Details in:
+    # https://htcondor.readthedocs.io/en/latest/classad-attributes/job-classad-attributes.html#HoldReasonCode
+
+    # By default, a held (5) job is defined as Aborted in STATES_MAP, but there might be some exceptions
+    status = 3
+
+    # If holdReasonCode is 3 (The PERIODIC_HOLD expression evaluated to True. Or, ON_EXIT_HOLD was true)
+    # And subcode is HOLD_REASON_SUBCODE, then it means the job failed by itself, it needs to be marked as Failed
+    if jobMetadata["HoldReasonCode"] == 3 and jobMetadata["HoldReasonSubCode"] == HOLD_REASON_SUBCODE:
+        status = 5
+    # If holdReasonCode is 16 (Input files are being spooled), the job should be marked as Waiting
+    elif jobMetadata["HoldReasonCode"] == 16:
+        status = 1
+
+    return (STATES_MAP.get(status, "Unknown"), jobMetadata["HoldReason"])
 
 
 class Condor(object):
@@ -171,8 +147,6 @@ class Condor(object):
         preamble = kwargs.get("Preamble")
 
         jdlFile = tempfile.NamedTemporaryFile(dir=outputDir, suffix=".jdl", mode="wt")
-        scheddOptions = 'requirements = OpSys == "LINUX"\n'
-        scheddOptions += "gentenv = False"
         jdlFile.write(
             subTemplate
             % dict(
@@ -185,7 +159,7 @@ class Condor(object):
                 holdReasonSubcode=HOLD_REASON_SUBCODE,
                 daysToKeepRemoteLogs=1,
                 scheddOptions="",
-                extraString="",
+                extraString=submitOptions,
                 pilotStampList=",".join(stamps),
             )
         )
@@ -193,7 +167,7 @@ class Condor(object):
         jdlFile.flush()
 
         cmd = "%s; " % preamble if preamble else ""
-        cmd += "condor_submit %s %s" % (submitOptions, jdlFile.name)
+        cmd += "condor_submit -spool %s" % jdlFile.name
         sp = subprocess.Popen(
             cmd,
             shell=True,
@@ -283,7 +257,6 @@ class Condor(object):
 
     def getJobStatus(self, **kwargs):
         """Get status of the jobs in the given list"""
-
         resultDict = {}
 
         MANDATORY_PARAMETERS = ["JobIDList"]
@@ -299,15 +272,11 @@ class Condor(object):
             resultDict["Message"] = "Empty job list"
             return resultDict
 
-        user = kwargs.get("User")
-        if not user:
-            user = os.environ.get("USER")
-        if not user:
-            resultDict["Status"] = -1
-            resultDict["Message"] = "No user name"
-            return resultDict
+        # Prepare the command to get the status of the jobs
+        cmdJobs = " ".join(str(jobID) for jobID in jobIDList)
 
-        cmd = "condor_q -submitter %s -af:j JobStatus HoldReasonCode HoldReasonSubCode HoldReason" % user
+        # Get the status of the jobs currently active
+        cmd = "condor_q %s -attributes %s -json" % (cmdJobs, STATE_ATTRIBUTES)
         sp = subprocess.Popen(
             shlex.split(cmd),
             stdout=subprocess.PIPE,
@@ -321,12 +290,13 @@ class Condor(object):
             resultDict["Status"] = status
             resultDict["Message"] = error
             return resultDict
+        if not output:
+            output = "[]"
 
-        qList = output.strip().split("\n")
+        jobsMetadata = json.loads(output)
 
-        condorHistCall = (
-            "condor_history -af:j JobStatus HoldReasonCode HoldReasonSubCode HoldReason -submitter %s" % user
-        )
+        # Get the status of the jobs in the history
+        condorHistCall = "condor_history %s -attributes %s -json" % (cmdJobs, STATE_ATTRIBUTES)
         sp = subprocess.Popen(
             shlex.split(condorHistCall),
             stdout=subprocess.PIPE,
@@ -335,15 +305,28 @@ class Condor(object):
         )
         output, _ = sp.communicate()
         status = sp.returncode
-        if status == 0:
-            for line in output.split("\n"):
-                qList.append(line)
+
+        if status != 0:
+            resultDict["Status"] = status
+            resultDict["Message"] = error
+            return resultDict
+        if not output:
+            output = "[]"
+
+        jobsMetadata += json.loads(output)
 
         statusDict = {}
-        if len(qList):
-            for job in jobIDList:
-                job = str(job)
-                statusDict[job], _ = parseCondorStatus(qList, job)
+        # Build a set of job IDs found in jobsMetadata
+        foundJobIDs = set()
+        for jobDict in jobsMetadata:
+            jobID = "%s.%s" % (jobDict["ClusterId"], jobDict["ProcId"])
+            statusDict[jobID], _ = getCondorStatus(jobDict)
+            foundJobIDs.add(jobID)
+
+        # For job IDs not found, set status to "Unknown"
+        for jobID in jobIDList:
+            if str(jobID) not in foundJobIDs:
+                statusDict[str(jobID)] = "Unknown"
 
         # Final output
         status = 0
@@ -355,19 +338,30 @@ class Condor(object):
         """Get the overall status of the CE"""
         resultDict = {}
 
-        user = kwargs.get("User")
-        if not user:
-            user = os.environ.get("USER")
-        if not user:
+        cmd = "condor_q -totals -json"
+        sp = subprocess.Popen(
+            shlex.split(cmd),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+        )
+        output, error = sp.communicate()
+        status = sp.returncode
+
+        if status != 0 or not output:
             resultDict["Status"] = -1
-            resultDict["Message"] = "No user name"
+            resultDict["Message"] = error
             return resultDict
 
-        waitingJobs = 0
-        runningJobs = 0
+        jresult = json.loads(output)
+        resultDict["Status"] = 0
+        resultDict["Waiting"] = jresult[0]["Idle"]
+        resultDict["Running"] = jresult[0]["Running"]
 
+        # We also need to check the hold jobs, some of them are actually waiting (e.g. for input files)
+        cmd = 'condor_q -json -constraint "JobStatus == 5" -attributes HoldReasonCode'
         sp = subprocess.Popen(
-            shlex.split("condor_q -submitter %s" % user),
+            shlex.split(cmd),
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             universal_newlines=True,
@@ -376,33 +370,57 @@ class Condor(object):
         status = sp.returncode
 
         if status != 0:
-            if "no record" in output:
-                resultDict["Status"] = 0
-                resultDict["Waiting"] = waitingJobs
-                resultDict["Running"] = runningJobs
-                return resultDict
-            resultDict["Status"] = status
+            resultDict["Status"] = -1
             resultDict["Message"] = error
             return resultDict
 
-        if "no record" in output:
-            resultDict["Status"] = 0
-            resultDict["Waiting"] = waitingJobs
-            resultDict["Running"] = runningJobs
+        # If there are no held jobs, we can return the result
+        if not output:
             return resultDict
 
-        if output:
-            lines = output.split("\n")
-            for line in lines:
-                if not line.strip():
-                    continue
-                if " I " in line:
-                    waitingJobs += 1
-                elif " R " in line:
-                    runningJobs += 1
+        jresult = json.loads(output)
+        for job_metadata in jresult:
+            if job_metadata["HoldReasonCode"] == 16:
+                resultDict["Waiting"] += 1
+
+        return resultDict
+
+    def getJobOutputFiles(self, **kwargs):
+        """Get output file names and templates for the specific CE"""
+        resultDict = {}
+
+        MANDATORY_PARAMETERS = ["JobIDList", "OutputDir", "ErrorDir"]
+        for argument in MANDATORY_PARAMETERS:
+            if argument not in kwargs:
+                resultDict["Status"] = -1
+                resultDict["Message"] = "No %s" % argument
+                return resultDict
+
+        outputDir = kwargs["OutputDir"]
+        errorDir = kwargs["ErrorDir"]
+        jobIDList = kwargs["JobIDList"]
+
+        jobDict = {}
+        for jobID in jobIDList:
+            jobDict[jobID] = {}
+
+            cmd = "condor_transfer_data %s" % jobID
+            sp = subprocess.Popen(
+                shlex.split(cmd),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True,
+            )
+            _, error = sp.communicate()
+            status = sp.returncode
+            if status != 0:
+                resultDict["Status"] = -1
+                resultDict["Message"] = error
+                return resultDict
+
+            jobDict[jobID]["Output"] = "%s/%s.out" % (outputDir, jobID)
+            jobDict[jobID]["Error"] = "%s/%s.err" % (errorDir, jobID)
 
-        # Final output
         resultDict["Status"] = 0
-        resultDict["Waiting"] = waitingJobs
-        resultDict["Running"] = runningJobs
+        resultDict["Jobs"] = jobDict
         return resultDict

DIRAC/Resources/Computing/BatchSystems/SLURM.py

@@ -40,6 +40,7 @@ class SLURM(object):
         executable = kwargs["Executable"]
         account = kwargs.get("Account", "")
         numberOfProcessors = kwargs.get("NumberOfProcessors", 1)
+        wholeNode = kwargs.get("WholeNode", False)
         # numberOfNodes is treated as a string as it can contain values such as "2-4"
         # where 2 would represent the minimum number of nodes to allocate, and 4 the maximum
         numberOfNodes = kwargs.get("NumberOfNodes", "1")
@@ -72,7 +73,10 @@ class SLURM(object):
             # One pilot (task) per node, allocating a certain number of processors
             cmd += "--ntasks-per-node=1 "
             cmd += "--nodes=%s " % numberOfNodes
-            cmd += "--cpus-per-task=%d " % numberOfProcessors
+            if wholeNode:
+                cmd += "--exclusive "
+            else:
+                cmd += "--cpus-per-task=%d " % numberOfProcessors
             if numberOfGPUs:
                 cmd += "--gpus-per-task=%d " % int(numberOfGPUs)
             # Additional options

DIRAC/Resources/Computing/BatchSystems/test/Test_SLURM.py

@@ -198,3 +198,49 @@ def test_getJobOutputFiles(numberOfNodes, outputContent, expectedContent):
 
     os.remove(outputFile)
     os.remove(errorFile)
+
+
+def test_submitJob_cmd_generation(mocker):
+    """Test submitJob() command string generation for various kwargs"""
+    slurm = SLURM()
+    # Mock subprocess.Popen to capture the command
+    popen_mock = mocker.patch("subprocess.Popen")
+    process_mock = popen_mock.return_value
+    process_mock.communicate.return_value = ("Submitted batch job 1234\n", "")
+    process_mock.returncode = 0
+
+    # Minimal kwargs
+    kwargs = {
+        "Executable": "/bin/echo",
+        "OutputDir": "/tmp",
+        "ErrorDir": "/tmp",
+        "Queue": "testq",
+        "SubmitOptions": "",
+        "JobStamps": ["stamp1"],
+        "NJobs": 1,
+    }
+    # Test default (WholeNode False)
+    slurm.submitJob(**kwargs)
+    cmd = popen_mock.call_args[0][0]
+    assert "--cpus-per-task=1" in cmd
+    assert "--exclusive" not in cmd
+
+    # Test WholeNode True disables --cpus-per-task and adds --exclusive
+    kwargs["WholeNode"] = True
+    slurm.submitJob(**kwargs)
+    cmd = popen_mock.call_args[0][0]
+    assert "--exclusive" in cmd
+    assert "--cpus-per-task" not in cmd
+
+    # Test NumberOfProcessors
+    kwargs["WholeNode"] = False
+    kwargs["NumberOfProcessors"] = 8
+    slurm.submitJob(**kwargs)
+    cmd = popen_mock.call_args[0][0]
+    assert "--cpus-per-task=8" in cmd
+
+    # Test NumberOfGPUs
+    kwargs["NumberOfGPUs"] = 2
+    slurm.submitJob(**kwargs)
+    cmd = popen_mock.call_args[0][0]
+    assert "--gpus-per-task=2" in cmd

DIRAC/Resources/Computing/ComputingElement.py

@@ -105,7 +105,7 @@ class ComputingElement:
     def _prepareProxy(self):
         """Set the environment variable X509_USER_PROXY"""
         if self.proxy:
-            result = gProxyManager.dumpProxyToFile(self.proxy, requiredTimeLeft=self.minProxyTime)
+            result = gProxyManager.dumpProxyToFile(self.proxy, requiredTimeLeft=self.minProxyTime, includeToken=False)
             if not result["OK"]:
                 return result
             os.environ["X509_USER_PROXY"] = result["Value"]

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"
@@ -170,7 +175,9 @@ class HTCondorCEComputingElement(ComputingElement):
 
         executable = os.path.join(self.workingDirectory, executable)
 
-        useCredentials = ""
+        # For now, we still need to include a proxy in the submit file
+        # HTCondor extracts VOMS attribute from it for the sites
+        useCredentials = "use_x509userproxy = true"
         # If tokenFile is present, then we transfer it to the worker node
         if tokenFile:
             useCredentials += textwrap.dedent(
@@ -271,6 +278,10 @@ class HTCondorCEComputingElement(ComputingElement):
             htcEnv = {
                 "_CONDOR_SEC_CLIENT_AUTHENTICATION_METHODS": "SCITOKENS",
                 "_CONDOR_SCITOKENS_FILE": self.tokenFile.name,
+                # This options is needed because we are still passing the proxy in the JDL (see use_x509userproxy)
+                # In condor v24.4, there is a bug preventing us from delegating the proxy, so we have to set
+                # it to false: https://opensciencegrid.atlassian.net/browse/HTCONDOR-2904
+                "_CONDOR_DELEGATE_JOB_GSI_CREDENTIALS": "false",
             }
             if cas := getCAsLocation():
                 htcEnv["_CONDOR_AUTH_SSL_CLIENT_CADIR"] = cas
@@ -380,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"""
@@ -418,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/InProcessComputingElement.py

@@ -7,8 +7,8 @@ import os
 import stat
 
 from DIRAC import S_OK, S_ERROR
-from DIRAC.Core.Utilities.Subprocess import systemCall
 from DIRAC.Core.Utilities.ThreadScheduler import gThreadScheduler
+from DIRAC.Core.Utilities.CGroups2 import CG2Manager
 
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
 
@@ -61,7 +61,9 @@ class InProcessComputingElement(ComputingElement):
             os.chmod(executableFile, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)
         cmd = os.path.abspath(executableFile)
         self.log.verbose("CE submission command:", cmd)
-        result = systemCall(0, cmd, callbackFunction=self.sendOutput, env=payloadEnv)
+        result = CG2Manager().systemCall(
+            0, cmd, callbackFunction=self.sendOutput, env=payloadEnv, ceParameters=self.ceParameters
+        )
         if payloadProxy:
             os.unlink(payloadProxy)
 

DIRAC/Resources/Computing/LocalComputingElement.py

@@ -43,7 +43,6 @@ from urllib.parse import urlparse
 from DIRAC import S_OK, S_ERROR
 
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
-from DIRAC.Resources.Computing.PilotBundle import bundleProxy, writeScript
 from DIRAC.Core.Utilities.List import uniqueElements
 from DIRAC.Core.Utilities.Subprocess import systemCall
 
@@ -153,26 +152,12 @@ class LocalComputingElement(ComputingElement):
         if not os.access(executableFile, 5):
             os.chmod(executableFile, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)
 
-        # if no proxy is supplied, the executable can be submitted directly
-        # otherwise a wrapper script is needed to get the proxy to the execution node
-        # The wrapper script makes debugging more complicated and thus it is
-        # recommended to transfer a proxy inside the executable if possible.
-        if self.proxy and not proxy:
-            proxy = self.proxy
-        if proxy:
-            self.log.verbose("Setting up proxy for payload")
-            wrapperContent = bundleProxy(executableFile, proxy)
-            name = writeScript(wrapperContent, os.getcwd())
-            submitFile = name
-        else:  # no proxy
-            submitFile = executableFile
-
         jobStamps = []
         for _i in range(numberOfJobs):
             jobStamps.append(uuid.uuid4().hex)
 
         batchDict = {
-            "Executable": submitFile,
+            "Executable": executableFile,
             "NJobs": numberOfJobs,
             "OutputDir": self.batchOutput,
             "ErrorDir": self.batchError,
@@ -186,8 +171,6 @@ class LocalComputingElement(ComputingElement):
             "NumberOfGPUs": self.numberOfGPUs,
         }
         resultSubmit = self.batchSystem.submitJob(**batchDict)
-        if proxy:
-            os.remove(submitFile)
 
         if resultSubmit["Status"] == 0:
             self.submittedJobs += len(resultSubmit["Jobs"])