DIRAC 9.0.0a68__py3-none-any.whl → 9.0.0a70__py3-none-any.whl

DIRAC/Core/Utilities/Subprocess.py

@@ -1,7 +1,7 @@
 """
 DIRAC Wrapper to execute python and system commands with a wrapper, that might
 set a timeout.
-3 FUNCTIONS are provided:
+3 functions are provided:
 
      - shellCall( iTimeOut, cmdSeq, callbackFunction = None, env = None ):
        it uses subprocess.Popen class with "shell = True".
@@ -26,6 +26,7 @@ set a timeout.
        should be used to wrap third party python functions
 
 """
+
 import os
 import selectors
 import signal
@@ -161,7 +162,6 @@ class Subprocess:
 
         self.child = None
         self.childPID = 0
-        self.childKilled = False
         self.callback = None
         self.bufferList = []
         self.cmdSeq = []
@@ -193,7 +193,7 @@ class Subprocess:
                     f"First and last data in buffer: \n{dataString[:100]} \n....\n {dataString[-100:]} ",
                 )
                 retDict = S_ERROR(
-                    "Reached maximum allowed length (%d bytes) " "for called function return value" % self.bufferLimit
+                    "Reached maximum allowed length (%d bytes) for called function return value" % self.bufferLimit
                 )
                 retDict["Value"] = dataString
                 return retDict
@@ -241,60 +241,71 @@ class Subprocess:
         events = sel.select(timeout=timeout or self.timeout or None)
         return [key.fileobj for key, event in events if event & selectors.EVENT_READ]
 
-    def __killPid(self, pid, sig=9):
-        """send signal :sig: to process :pid:
-
-        :param int pid: process id
-        :param int sig: signal to send, default 9 (SIGKILL)
-        """
+    def __terminateProcess(self, process):
+        """Tries to terminate a process with SIGTERM. Returns a (gone, alive) tuple"""
+        self.log.verbose(f"Sending SIGTERM signal to PID {process.pid}")
         try:
-            os.kill(pid, sig)
-        except Exception as x:
-            if str(x) != "[Errno 3] No such process":
-                self.log.exception("Exception while killing timed out process")
-                raise x
-
-    def __poll(self, pid):
-        """wait for :pid:"""
+            process.terminate()
+        except psutil.NoSuchProcess:
+            return ([], [])
+        return psutil.wait_procs([process], timeout=60)
+
+    def __poll(self, process):
+        """Non-blocking check of whether process `pid` is still alive.
+        Returns:
+        - (0, 0) if process is still running  (like os.waitpid(pid, os.WNOHANG))
+        - (pid, exitcode) if process has terminated
+        - None if process info cannot be retrieved
+        """
         try:
-            return os.waitpid(pid, os.WNOHANG)
-        except os.error:
-            if self.childKilled:
-                return False
+            exitcode = process.wait(timeout=0)
+            return (process.pid, exitcode)  # exited
+        except psutil.TimeoutExpired:
+            return (0, 0)  # still running
+        except psutil.NoSuchProcess:
             return None
 
     def killChild(self, recursive=True):
-        """kill child process
-
-        :param boolean recursive: flag to kill all descendants
+        """Kills a process tree (including children) with signal SIGTERM. If that fails, escalate to SIGKILL
+        returns (gone, alive) tuple.
         """
-        pgid = os.getpgid(self.childPID)
-        if pgid != os.getpgrp():
-            try:
-                # Child is in its own group: kill the group
-                os.killpg(pgid, signal.SIGTERM)
-            except OSError:
-                # Process is already dead
-                pass
-        else:
-            # No separate group: walk the tree
-            parent = psutil.Process(self.childPID)
-            procs = parent.children(recursive=recursive)
-            procs.append(parent)
-            for p in procs:
+
+        self.log.info(f"Killing childPID {self.childPID}")
+
+        gone, alive = [], []
+        try:
+            child_process = psutil.Process(self.childPID)
+        except psutil.NoSuchProcess:
+            self.log.warn(f"Child PID {self.childPID} no longer exists")
+            return (gone, alive)
+
+        if recursive:
+            # grandchildren
+            children = child_process.children(recursive=True)
+            self.log.info(f"Sending kill signal to {len(children)} children PIDs")
+            for p in children:
                 try:
                     p.terminate()
                 except psutil.NoSuchProcess:
-                    pass
-            _gone, alive = psutil.wait_procs(procs, timeout=10)
-            # Escalate any survivors
+                    continue
+            g, a = psutil.wait_procs(children, timeout=60)
+            gone.extend(g)
+            alive.extend(a)
+
+        # now killing the child_process
+        g, a = self.__terminateProcess(child_process)
+        gone.extend(g)
+        alive.extend(a)
+
+        # if there's something still alive, use SIGKILL
+        if alive:
             for p in alive:
                 try:
                     p.kill()
                 except psutil.NoSuchProcess:
                     pass
 
-        self.childKilled = True
+        return psutil.wait_procs(alive, timeout=60)
 
     def pythonCall(self, function, *stArgs, **stKeyArgs):
         """call python function :function: with :stArgs: and :stKeyArgs:"""
@@ -309,8 +320,6 @@ class Subprocess:
         if pid == 0:
             os.close(readFD)
             self.__executePythonFunction(function, writeFD, *stArgs, **stKeyArgs)
-            # FIXME: the close it is done at __executePythonFunction, do we need it here?
-            os.close(writeFD)
         else:
             os.close(writeFD)
             readSeq = self.__selectFD([readFD])
@@ -319,14 +328,13 @@ class Subprocess:
             try:
                 if len(readSeq) == 0:
                     self.log.debug("Timeout limit reached for pythonCall", function.__name__)
-                    self.__killPid(pid)
-
-                    # HACK to avoid python bug
-                    # self.wait()
-                    retries = 10000
-                    while os.waitpid(pid, 0) == -1 and retries > 0:
-                        time.sleep(0.001)
-                        retries -= 1
+                    gone, alive = self.__terminateProcess(psutil.Process(pid))
+                    if alive:
+                        for p in alive:
+                            try:
+                                p.kill()
+                            except psutil.NoSuchProcess:
+                                continue
 
                     return S_ERROR('%d seconds timeout for "%s" call' % (self.timeout, function.__name__))
                 elif readSeq[0] == readFD:
@@ -400,7 +408,7 @@ class Subprocess:
         if len(dataString) + baseLength > self.bufferLimit:
             self.log.error("Maximum output buffer length reached")
             retDict = S_ERROR(
-                "Reached maximum allowed length (%d bytes) for called " "function return value" % self.bufferLimit
+                "Reached maximum allowed length (%d bytes) for called function return value" % self.bufferLimit
             )
             retDict["Value"] = dataString
             return retDict
@@ -446,6 +454,7 @@ class Subprocess:
                 start_new_session=start_new_session,
             )
             self.childPID = self.child.pid
+            child_process = psutil.Process(self.childPID)
         except OSError as v:
             retDict = S_ERROR(repr(v))
             retDict["Value"] = (-1, "", str(v))
@@ -464,9 +473,9 @@ class Subprocess:
             self.bufferList = [["", 0], ["", 0]]
             initialTime = time.time()
 
-            exitStatus = self.__poll(self.child.pid)
+            exitStatus = self.__poll(child_process)
 
-            while (0, 0) == exitStatus or exitStatus is None:
+            while (0, 0) == exitStatus:  # This means that the process is still alive
                 retDict = self.__readFromCommand()
                 if not retDict["OK"]:
                     return retDict
@@ -478,14 +487,14 @@ class Subprocess:
                         1, "Timeout (%d seconds) for '%s' call" % (self.timeout, cmdSeq)
                     )
                 time.sleep(0.01)
-                exitStatus = self.__poll(self.child.pid)
+                exitStatus = self.__poll(child_process)
 
             self.__readFromCommand()
 
             if exitStatus:
                 exitStatus = exitStatus[1]
 
-            if exitStatus >= 256:
+            if exitStatus and exitStatus >= 256:
                 exitStatus = int(exitStatus / 256)
             return S_OK((exitStatus, self.bufferList[0][0], self.bufferList[1][0]))
         finally:

DIRAC/Core/Utilities/test/Test_Profiler.py

@@ -29,50 +29,50 @@ def test_base():
     time.sleep(1)
     p = Profiler(mainProcess.pid)
     res = p.pid()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.status()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.runningTime()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
 
     res = p.memoryUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.memoryUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.vSizeUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.vSizeUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.vSizeUsage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.vSizeUsage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.numThreads()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resWC = p.numThreads(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] > 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.cpuPercentage()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] >= 0
     resWC = p.cpuPercentage(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] >= 0
     assert resWC["Value"] >= res["Value"]
 
@@ -88,13 +88,13 @@ def test_cpuUsage():
     time.sleep(2)
     p = Profiler(mainProcess.pid)
     res = p.pid()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     res = p.status()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
 
     # user
     res = p.cpuUsageUser()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageUser(withChildren=True)
     assert resC["OK"] is True
@@ -102,7 +102,7 @@ def test_cpuUsage():
     assert resC["Value"] >= res["Value"]
 
     res = p.cpuUsageUser()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageUser(withChildren=True)
     assert resC["OK"] is True
@@ -121,15 +121,15 @@ def test_cpuUsage():
 
     # system
     res = p.cpuUsageSystem()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] >= 0
     resWC = p.cpuUsageSystem(withChildren=True)
-    assert resWC["OK"] is True
+    assert resWC["OK"] is True, res
     assert resWC["Value"] >= 0
     assert resWC["Value"] >= res["Value"]
 
     res = p.cpuUsageSystem()
-    assert res["OK"] is True
+    assert res["OK"] is True, res
     assert res["Value"] > 0
     resC = p.cpuUsageSystem(withChildren=True)
     assert resC["OK"] is True

DIRAC/Core/Utilities/test/Test_Subprocess.py

@@ -3,23 +3,25 @@
 # Date: 2012/12/11 18:04:25
 ########################################################################
 
-""" :mod: SubprocessTests
-    =======================
+""":mod: SubprocessTests
+=======================
 
-    .. module: SubprocessTests
-    :synopsis: unittest for Subprocess module
-    .. moduleauthor:: Krzysztof.Ciba@NOSPAMgmail.com
+.. module: SubprocessTests
+:synopsis: unittest for Subprocess module
+.. moduleauthor:: Krzysztof.Ciba@NOSPAMgmail.com
 
-    unittest for Subprocess module
+unittest for Subprocess module
 """
-import time
+
 import platform
+import time
 from os.path import dirname, join
 from subprocess import Popen
 
+import psutil
 import pytest
 
-from DIRAC.Core.Utilities.Subprocess import systemCall, shellCall, pythonCall, getChildrenPIDs, Subprocess
+from DIRAC.Core.Utilities.Subprocess import Subprocess, getChildrenPIDs, pythonCall, shellCall, systemCall
 
 # Mark this entire module as slow
 pytestmark = pytest.mark.slow
@@ -72,3 +74,51 @@ def test_decodingCommandOutput():
     retVal = sp.systemCall(r"""python -c 'import os; os.fdopen(2, "wb").write(b"\xdf")'""", shell=True)
     assert retVal["OK"]
     assert retVal["Value"] == (0, "", "\ufffd")
+
+
+@pytest.fixture
+def subprocess_instance():
+    """Provides a Subprocess instance for testing."""
+    subp = Subprocess()
+    return subp
+
+
+@pytest.fixture
+def dummy_child():
+    """Spawn a dummy process tree: parent -> child."""
+    # Start a shell that sleeps, with a subprocess child
+    parent = Popen(["bash", "-c", "sleep 10 & wait"])
+    time.sleep(0.2)  # give it a moment to start
+    yield parent
+    # Ensure cleanup
+    try:
+        parent.terminate()
+        parent.wait(timeout=1)
+    except Exception:
+        pass
+
+
+def test_kill_child_process_tree(subprocess_instance, dummy_child):
+    """Test that killChild kills both parent and its children."""
+    subprocess_instance.childPID = dummy_child.pid
+    parent_proc = psutil.Process(subprocess_instance.childPID)
+
+    # Sanity check: parent should exist
+    assert parent_proc.is_running()
+
+    # It should have at least one sleeping child
+    children = parent_proc.children(recursive=True)
+    assert children, "Expected dummy process to have at least one child"
+
+    # Kill the tree
+    gone, alive = subprocess_instance.killChild(recursive=True)
+
+    # Verify the parent and children are terminated
+    for p in gone:
+        assert not p.is_running(), f"Process {p.pid} still alive"
+    for p in alive:
+        assert not p.is_running(), f"Process {p.pid} still alive"
+
+    # Verify parent is gone
+    with pytest.raises(psutil.NoSuchProcess):
+        psutil.Process(subprocess_instance.childPID)

DIRAC/Core/scripts/dirac_apptainer_exec.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
-""" Starts a DIRAC command inside an apptainer container.
-"""
+"""Starts a DIRAC command inside an apptainer container."""
 
 import os
 import sys
@@ -52,8 +51,9 @@ def main():
         if switch[0].lower() == "i" or switch[0].lower() == "image":
             user_image = switch[1]
 
-    dirac_env_var = os.environ.get("DIRAC", os.getcwd())
-    diracos_env_var = os.environ.get("DIRACOS", os.getcwd())
+    cwd = os.path.realpath(os.getcwd())
+    dirac_env_var = os.environ.get("DIRAC", cwd)
+    diracos_env_var = os.environ.get("DIRACOS", cwd)
     etc_dir = os.path.join(DIRAC.rootPath, "etc")
     rc_script = os.path.join(os.path.realpath(sys.base_prefix), "diracosrc")
 
@@ -74,7 +74,7 @@ def main():
     cmd.extend(["--contain"])  # use minimal /dev and empty other directories (e.g. /tmp and $HOME)
     cmd.extend(["--ipc"])  # run container in a new IPC namespace
     cmd.extend(["--pid"])  # run container in a new PID namespace
-    cmd.extend(["--bind", f"{os.getcwd()}"])  # bind current directory for dirac_container.sh
+    cmd.extend(["--bind", cwd])  # bind current directory for dirac_container.sh
     if proxy_location:
         cmd.extend(["--bind", f"{proxy_location}:/etc/proxy"])  # bind proxy file
     cmd.extend(["--bind", f"{getCAsLocation()}:/etc/grid-security/certificates"])  # X509_CERT_DIR
@@ -89,13 +89,13 @@ def main():
         if safe_listdir(bind_path):
             cmd.extend(["--bind", f"{bind_path}:{bind_path}"])
         else:
-            gLogger.warning(f"Bind path {bind_path} does not exist, skipping")
-    cmd.extend(["--cwd", f"{os.getcwd()}"])  # set working directory
+            gLogger.warn(f"Bind path {bind_path} does not exist, skipping")
+    cmd.extend(["--cwd", cwd])  # set working directory
 
     rootImage = user_image or gConfig.getValue("/Resources/Computing/Singularity/ContainerRoot") or CONTAINER_DEFROOT
 
     if os.path.isdir(rootImage) or os.path.isfile(rootImage):
-        cmd.extend([rootImage, f"{os.getcwd()}/dirac_container.sh"])
+        cmd.extend([rootImage, f"{cwd}/dirac_container.sh"])
     else:
         # if we are here is because there's no image, or it is not accessible (e.g. not on CVMFS)
         gLogger.error("Apptainer image to exec not found: ", rootImage)

DIRAC/DataManagementSystem/Agent/FTS3Agent.py

@@ -719,10 +719,11 @@ class FTS3Agent(AgentModule):
         return self.dataOpSender.concludeSending()
 
     def __sendAccounting(self, ftsJob):
-        self.dataOpSender.sendData(
-            ftsJob.accountingDict,
-            commitFlag=True,
-            delayedCommit=True,
-            startTime=fromString(ftsJob.submitTime),
-            endTime=fromString(ftsJob.lastUpdate),
-        )
+        for accountingDict in ftsJob.accountingDicts:
+            self.dataOpSender.sendData(
+                accountingDict,
+                commitFlag=True,
+                delayedCommit=True,
+                startTime=fromString(ftsJob.submitTime),
+                endTime=fromString(ftsJob.lastUpdate),
+            )

DIRAC/DataManagementSystem/Client/DataManager.py

@@ -10,11 +10,11 @@ This module consists of DataManager and related classes.
 """
 
 # # imports
-from datetime import datetime, timedelta
+import errno
 import fnmatch
 import os
 import time
-import errno
+from datetime import datetime, timedelta
 
 # # from DIRAC
 import DIRAC
@@ -25,13 +25,13 @@ from DIRAC.Core.Utilities.File import makeGuid, getSize
 from DIRAC.Core.Utilities.List import randomize, breakListIntoChunks
 from DIRAC.Core.Utilities.ReturnValues import returnSingleResult
 from DIRAC.Core.Security.ProxyInfo import getProxyInfo
+from DIRAC.Core.Security.ProxyInfo import getVOfromProxyGroup
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.DataManagementSystem.Client import MAX_FILENAME_LENGTH
-from DIRAC.MonitoringSystem.Client.DataOperationSender import DataOperationSender
 from DIRAC.DataManagementSystem.Utilities.DMSHelpers import DMSHelpers
+from DIRAC.MonitoringSystem.Client.DataOperationSender import DataOperationSender
 from DIRAC.Resources.Catalog.FileCatalog import FileCatalog
 from DIRAC.Resources.Storage.StorageElement import StorageElement
-from DIRAC.ResourceStatusSystem.Client.ResourceStatus import ResourceStatus
 
 
 # # RSCID
@@ -89,7 +89,7 @@ class DataManager:
         :param vo: the VO for which the DataManager is created, get VO from the current proxy if not specified
         """
         self.log = gLogger.getSubLogger(self.__class__.__name__)
-        self.voName = vo
+        self.voName = vo if vo else getVOfromProxyGroup().get("Value", None)
 
         if catalogs is None:
             catalogs = []
@@ -97,10 +97,9 @@ class DataManager:
 
         self.fileCatalog = FileCatalog(catalogs=catalogsToUse, vo=self.voName)
         self.accountingClient = None
-        self.resourceStatus = ResourceStatus()
         self.ignoreMissingInFC = Operations(vo=self.voName).getValue("DataManagement/IgnoreMissingInFC", False)
         self.useCatalogPFN = Operations(vo=self.voName).getValue("DataManagement/UseCatalogPFN", True)
-        self.dmsHelper = DMSHelpers(vo=vo)
+        self.dmsHelper = DMSHelpers(vo=self.voName)
         self.registrationProtocol = self.dmsHelper.getRegistrationProtocols()
         self.thirdPartyProtocols = self.dmsHelper.getThirdPartyProtocols()
         self.dataOpSender = DataOperationSender()