DIRAC 9.0.0a64__py3-none-any.whl → 9.0.0a66__py3-none-any.whl

DIRAC/ConfigurationSystem/Client/LocalConfiguration.py

@@ -1,5 +1,5 @@
-""" This is the guy that parses and interprets the local configuration options.
-"""
+"""This is the guy that parses and interprets the local configuration options."""
+
 import re
 import os
 import sys
@@ -286,16 +286,18 @@ class LocalConfiguration:
             gLogger.exception()
             return S_ERROR(str(e))
 
-    def initialize(self, *, returnErrors=False):
+    def initialize(self, *, returnErrors=False, requireSuccessfulSync=False):
         """Entrypoint used by :py:class:`DIRAC.initialize`
 
+        :param requireSuccessfulSync: fails if syncing with the remote did not work
+
         TODO: This is currently a hack that returns a list of errors for so it
         can be used by ``__addUserDataToConfiguration``. This entire module
         should be refactored and simplified with ``Script.parseCommandLine``.
         """
         errorsList = self.__loadCFGFiles()
         if gConfigurationData.getServers():
-            retVal = self.syncRemoteConfiguration()
+            retVal = self.syncRemoteConfiguration(strict=requireSuccessfulSync)
             if not retVal["OK"]:
                 return retVal
         else:
@@ -321,7 +323,7 @@ class LocalConfiguration:
             gLogger.showHeaders(True)
             gLogger.enableLogsFromExternalLibs()
 
-    def loadUserData(self):
+    def loadUserData(self, requireSuccessfulSync=False):
         """
         This is the magic method that reads the command line and processes it
         It is used by the Script Base class and the dirac-service and dirac-agent scripts
@@ -329,6 +331,7 @@ class LocalConfiguration:
         - any additional switches to be processed
         - mandatory and default configuration configuration options must be defined.
 
+        :param requireSuccessfulSync: if True, will fail if the sync with remote server failed
         """
         if self.initialized:
             return S_OK()
@@ -336,7 +339,7 @@ class LocalConfiguration:
         try:
             if not self.isParsed:
                 self.__parseCommandLine()  # Parse command line
-            retVal = self.__addUserDataToConfiguration()
+            retVal = self.__addUserDataToConfiguration(requireSuccessfulSync=requireSuccessfulSync)
 
             for optionTuple in self.optionalEntryList:
                 optionPath = self.__getAbsolutePath(optionTuple[0])
@@ -496,8 +499,8 @@ class LocalConfiguration:
 
         return errorsList
 
-    def __addUserDataToConfiguration(self):
-        retVal = self.initialize(returnErrors=True)
+    def __addUserDataToConfiguration(self, requireSuccessfulSync=False):
+        retVal = self.initialize(returnErrors=True, requireSuccessfulSync=requireSuccessfulSync)
         if not retVal["OK"]:
             return retVal
         errorsList = retVal["Value"]

DIRAC/Core/Utilities/DErrno.py

@@ -37,320 +37,16 @@
                              DErrno.ERRX : ['An error message for ERRX that is specific to LHCb']}
 
 """
-import os
 import importlib
 import sys
 
-from DIRAC.Core.Utilities.Extensions import extensionsByPriority
-
-# To avoid conflict, the error numbers should be greater than 1000
-# We decided to group the by range of 100 per system
-
-# 1000: Generic
-# 1100: Core
-# 1200: Framework
-# 1300: Interfaces
-# 1400: Config
-# 1500: WMS + Workflow
-# 1600: DMS + StorageManagement
-# 1700: RMS
-# 1800: Accounting + Monitoring
-# 1900: TS + Production
-# 2000: Resources + RSS
-
-# ## Generic (10XX)
-# Python related: 0X
-ETYPE = 1000
-EIMPERR = 1001
-ENOMETH = 1002
-ECONF = 1003
-EVALUE = 1004
-EEEXCEPTION = 1005
-# Files manipulation: 1X
-ECTMPF = 1010
-EOF = 1011
-ERF = 1012
-EWF = 1013
-ESPF = 1014
-
-# ## Core (11XX)
-# Certificates and Proxy: 0X
-EX509 = 1100
-EPROXYFIND = 1101
-EPROXYREAD = 1102
-ECERTFIND = 1103
-ECERTREAD = 1104
-ENOCERT = 1105
-ENOCHAIN = 1106
-ENOPKEY = 1107
-ENOGROUP = 1108
-# DISET: 1X
-EDISET = 1110
-ENOAUTH = 1111
-# 3rd party security: 2X
-E3RDPARTY = 1120
-EVOMS = 1121
-# Databases : 3X
-EDB = 1130
-EMYSQL = 1131
-ESQLA = 1132
-# Message Queues: 4X
-EMQUKN = 1140
-EMQNOM = 1141
-EMQCONN = 1142
-# OpenSearch
-EELNOFOUND = 1146
-# Tokens
-EATOKENFIND = 1150
-EATOKENREAD = 1151
-ETOKENTYPE = 1152
-
-# config
-ESECTION = 1400
-
-# processes
-EEZOMBIE = 1147
-EENOPID = 1148
-
-# ## WMS/Workflow
-EWMSUKN = 1500
-EWMSJDL = 1501
-EWMSRESC = 1502
-EWMSSUBM = 1503
-EWMSJMAN = 1504
-EWMSSTATUS = 1505
-EWMSNOMATCH = 1510
-EWMSPLTVER = 1511
-EWMSNOPILOT = 1550
-
-# ## DMS/StorageManagement (16XX)
-EFILESIZE = 1601
-EGFAL = 1602
-EBADCKS = 1603
-EFCERR = 1604
-
-# ## RMS (17XX)
-ERMSUKN = 1700
-
-# ## TS (19XX)
-ETSUKN = 1900
-ETSDATA = 1901
-
-# ## Resources and RSS (20XX)
-ERESGEN = 2000
-ERESUNA = 2001
-ERESUNK = 2002
-
-# This translates the integer number into the name of the variable
-dErrorCode = {
-    # ## Generic (10XX)
-    # 100X: Python related
-    1000: "ETYPE",
-    1001: "EIMPERR",
-    1002: "ENOMETH",
-    1003: "ECONF",
-    1004: "EVALUE",
-    1005: "EEEXCEPTION",
-    # 101X: Files manipulation
-    1010: "ECTMPF",
-    1011: "EOF",
-    1012: "ERF",
-    1013: "EWF",
-    1014: "ESPF",
-    # ## Core
-    # 110X: Certificates and Proxy
-    1100: "EX509",
-    1101: "EPROXYFIND",
-    1102: "EPROXYREAD",
-    1103: "ECERTFIND",
-    1104: "ECERTREAD",
-    1105: "ENOCERT",
-    1106: "ENOCHAIN",
-    1107: "ENOPKEY",
-    1108: "ENOGROUP",
-    # 111X: DISET
-    1110: "EDISET",
-    1111: "ENOAUTH",
-    # 112X: 3rd party security
-    1120: "E3RDPARTY",
-    1121: "EVOMS",
-    # 113X: Databases
-    1130: "EDB",
-    1131: "EMYSQL",
-    1132: "ESQLA",
-    # 114X: Message Queues
-    1140: "EMQUKN",
-    1141: "EMQNOM",
-    1142: "EMQCONN",
-    # OpenSearch
-    1146: "EELNOFOUND",
-    # 115X: Tokens
-    1150: "EATOKENFIND",
-    1151: "EATOKENREAD",
-    1152: "ETOKENTYPE",
-    # Config
-    1400: "ESECTION",
-    # Processes
-    1147: "EEZOMBIE",
-    1148: "EENOPID",
-    # WMS/Workflow
-    1500: "EWMSUKN",
-    1501: "EWMSJDL",
-    1502: "EWMSRESC",
-    1503: "EWMSSUBM",
-    1504: "EWMSJMAN",
-    1505: "EWMSSTATUS",
-    1510: "EWMSNOMATCH",
-    1511: "EWMSPLTVER",
-    1550: "EWMSNOPILOT",
-    # DMS/StorageManagement
-    1601: "EFILESIZE",
-    1602: "EGFAL",
-    1603: "EBADCKS",
-    1604: "EFCERR",
-    # RMS
-    1700: "ERMSUKN",
-    # Resources and RSS
-    2000: "ERESGEN",
-    2001: "ERESUNA",
-    2002: "ERESUNK",
-    # TS
-    1900: "ETSUKN",
-    1901: "ETSDATA",
-}
-
-
-dStrError = {  # Generic (10XX)
-    # 100X: Python related
-    ETYPE: "Object Type Error",
-    EIMPERR: "Failed to import library",
-    ENOMETH: "No such method or function",
-    ECONF: "Configuration error",
-    EVALUE: "Wrong value passed",
-    EEEXCEPTION: "runtime general exception",
-    # 101X: Files manipulation
-    ECTMPF: "Failed to create temporary file",
-    EOF: "Cannot open file",
-    ERF: "Cannot read from file",
-    EWF: "Cannot write to file",
-    ESPF: "Cannot set permissions to file",
-    # ## Core
-    # 110X: Certificates and Proxy
-    EX509: "Generic Error with X509",
-    EPROXYFIND: "Can't find proxy",
-    EPROXYREAD: "Can't read proxy",
-    ECERTFIND: "Can't find certificate",
-    ECERTREAD: "Can't read certificate",
-    ENOCERT: "No certificate loaded",
-    ENOCHAIN: "No chain loaded",
-    ENOPKEY: "No private key loaded",
-    ENOGROUP: "No DIRAC group",
-    # 111X: DISET
-    EDISET: "DISET Error",
-    ENOAUTH: "Unauthorized query",
-    # 112X: 3rd party security
-    E3RDPARTY: "3rd party security service error",
-    EVOMS: "VOMS Error",
-    # 113X: Databases
-    EDB: "Database Error",
-    EMYSQL: "MySQL Error",
-    ESQLA: "SQLAlchemy Error",
-    # 114X: Message Queues
-    EMQUKN: "Unknown MQ Error",
-    EMQNOM: "No messages",
-    EMQCONN: "MQ connection failure",
-    # 114X OpenSearch
-    EELNOFOUND: "Index not found",
-    # 115X: Tokens
-    EATOKENFIND: "Can't find a bearer access token.",
-    EATOKENREAD: "Can't read a bearer access token.",
-    ETOKENTYPE: "Unsupported access token type.",
-    # Config
-    ESECTION: "Section is not found",
-    # processes
-    EEZOMBIE: "Zombie process",
-    EENOPID: "No PID of process",
-    # WMS/Workflow
-    EWMSUKN: "Unknown WMS error",
-    EWMSJDL: "Invalid job description",
-    EWMSRESC: "Job to reschedule",
-    EWMSSUBM: "Job submission error",
-    EWMSJMAN: "Job management error",
-    EWMSSTATUS: "Job status error",
-    EWMSNOPILOT: "No pilots found",
-    EWMSPLTVER: "Pilot version does not match",
-    EWMSNOMATCH: "No match found",
-    # DMS/StorageManagement
-    EFILESIZE: "Bad file size",
-    EGFAL: "Error with the gfal call",
-    EBADCKS: "Bad checksum",
-    EFCERR: "FileCatalog error",
-    # RMS
-    ERMSUKN: "Unknown RMS error",
-    # Resources and RSS
-    ERESGEN: "Unknown Resource Failure",
-    ERESUNA: "Resource not available",
-    ERESUNK: "Unknown Resource",
-    # TS
-    ETSUKN: "Unknown Transformation System Error",
-    ETSDATA: "Invalid Input Data definition",
-}
+# Import all the stateless parts from DIRACCommon
+from DIRACCommon.Utils.DErrno import *  # noqa: F401, F403
 
+from DIRAC.Core.Utilities.Extensions import extensionsByPriority
 
-def strerror(code: int) -> str:
-    """This method wraps up os.strerror, and behave the same way.
-    It completes it with the DIRAC specific errors.
-    """
-
-    if code == 0:
-        return "Undefined error"
-
-    errMsg = f"Unknown error {code}"
-
-    try:
-        errMsg = dStrError[code]
-    except KeyError:
-        # It is not a DIRAC specific error, try the os one
-        try:
-            errMsg = os.strerror(code)
-            # On some system, os.strerror raises an exception with unknown code,
-            # on others, it returns a message...
-        except ValueError:
-            pass
-
-    return errMsg
-
-
-def cmpError(inErr, candidate):
-    """This function compares an error (in its old form (a string or dictionary) or in its int form
-    with a candidate error code.
-
-    :param inErr: a string, an integer, a S_ERROR dictionary
-    :type inErr: str or int or S_ERROR
-    :param int candidate: error code to compare with
-
-    :return: True or False
-
-    If an S_ERROR instance is passed, we compare the code with S_ERROR['Errno']
-    If it is a Integer, we do a direct comparison
-    If it is a String, we use strerror to check the error string
-    """
-
-    if isinstance(inErr, str):  # old style
-        # Compare error message strings
-        errMsg = strerror(candidate)
-        return errMsg in inErr
-    elif isinstance(inErr, dict):  # if the S_ERROR structure is given
-        # Check if Errno defined in the dict
-        errorNumber = inErr.get("Errno")
-        if errorNumber:
-            return errorNumber == candidate
-        errMsg = strerror(candidate)
-        return errMsg in inErr.get("Message", "")
-    elif isinstance(inErr, int):
-        return inErr == candidate
-    else:
-        raise TypeError(f"Unknown input error type {type(inErr)}")
+# compatErrorString is used by the extension mechanism but not in DIRACCommon
+compatErrorString = {}
 
 
 def includeExtensionErrors():

DIRAC/Core/Utilities/ReturnValues.py

@@ -1,255 +1,10 @@
-"""
-   DIRAC return dictionary
+"""Backward compatibility wrapper - moved to DIRACCommon
 
-   Message values are converted to string
+This module has been moved to DIRACCommon.Utils.ReturnValues to avoid
+circular dependencies and allow DiracX to use these utilities without
+triggering DIRAC's global state initialization.
 
-   keys are converted to string
+All exports are maintained for backward compatibility.
 """
-from __future__ import annotations
-
-import functools
-import sys
-import traceback
-from types import TracebackType
-from typing import Any, Callable, cast, Generic, Literal, overload, Type, TypeVar, Union
-from typing_extensions import TypedDict, ParamSpec, NotRequired
-
-from DIRAC.Core.Utilities.DErrno import strerror
-
-
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-class DOKReturnType(TypedDict, Generic[T]):
-    """used for typing the DIRAC return structure"""
-
-    OK: Literal[True]
-    Value: T
-
-
-class DErrorReturnType(TypedDict):
-    """used for typing the DIRAC return structure"""
-
-    OK: Literal[False]
-    Message: str
-    Errno: int
-    ExecInfo: NotRequired[tuple[type[BaseException], BaseException, TracebackType]]
-    CallStack: NotRequired[list[str]]
-
-
-DReturnType = Union[DOKReturnType[T], DErrorReturnType]
-
-
-def S_ERROR(*args: Any, **kwargs: Any) -> DErrorReturnType:
-    """return value on error condition
-
-    Arguments are either Errno and ErrorMessage or just ErrorMessage fro backward compatibility
-
-    :param int errno: Error number
-    :param string message: Error message
-    :param list callStack: Manually override the CallStack attribute better performance
-    """
-    callStack = kwargs.pop("callStack", None)
-
-    result: DErrorReturnType = {"OK": False, "Errno": 0, "Message": ""}
-
-    message = ""
-    if args:
-        if isinstance(args[0], int):
-            result["Errno"] = args[0]
-            if len(args) > 1:
-                message = args[1]
-        else:
-            message = args[0]
-
-    if result["Errno"]:
-        message = f"{strerror(result['Errno'])} ( {result['Errno']} : {message})"
-    result["Message"] = message
-
-    if callStack is None:
-        try:
-            callStack = traceback.format_stack()
-            callStack.pop()
-        except Exception:
-            callStack = []
-
-    result["CallStack"] = callStack
-
-    return result
-
-
-# mypy doesn't understand default parameter values with generics so use overloads (python/mypy#3737)
-@overload
-def S_OK() -> DOKReturnType[None]:
-    ...
-
-
-@overload
-def S_OK(value: T) -> DOKReturnType[T]:
-    ...
-
-
-def S_OK(value=None):  # type: ignore
-    """return value on success
-
-    :param value: value of the 'Value'
-    :return: dictionary { 'OK' : True, 'Value' : value }
-    """
-    return {"OK": True, "Value": value}
-
-
-def isReturnStructure(unk: Any) -> bool:
-    """Check if value is an `S_OK`/`S_ERROR` object"""
-    if not isinstance(unk, dict):
-        return False
-    if "OK" not in unk:
-        return False
-    if unk["OK"]:
-        return "Value" in unk
-    else:
-        return "Message" in unk
-
-
-def isSError(value: Any) -> bool:
-    """Check if value is an `S_ERROR` object"""
-    if not isinstance(value, dict):
-        return False
-    if "OK" not in value:
-        return False
-    return "Message" in value
-
-
-def reprReturnErrorStructure(struct: DErrorReturnType, full: bool = False) -> str:
-    errorNumber = struct.get("Errno", 0)
-    message = struct.get("Message", "")
-    if errorNumber:
-        reprStr = f"{strerror(errorNumber)} ( {errorNumber} : {message})"
-    else:
-        reprStr = message
-
-    if full:
-        callStack = struct.get("CallStack")
-        if callStack:
-            reprStr += "\n" + "".join(callStack)
-
-    return reprStr
-
-
-def returnSingleResult(dictRes: DReturnType[Any]) -> DReturnType[Any]:
-    """Transform the S_OK{Successful/Failed} dictionary convention into
-    an S_OK/S_ERROR return. To be used when a single returned entity
-    is expected from a generally bulk call.
-
-    :param dictRes: S_ERROR or S_OK( "Failed" : {}, "Successful" : {})
-    :returns: S_ERROR or S_OK(value)
-
-    The following rules are applied:
-
-    - if dictRes is an S_ERROR: returns it as is
-    - we start by looking at the Failed directory
-    - if there are several items in a dictionary, we return the first one
-    - if both dictionaries are empty, we return S_ERROR
-    - For an item in Failed, we return S_ERROR
-    - Far an item in Successful we return S_OK
-
-    Behavior examples (would be perfect unit test :-) )::
-
-      {'Message': 'Kaput', 'OK': False} -> {'Message': 'Kaput', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {}, 'Failed': {'a': 1}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {}}} -> {'OK': True, 'Value': 2}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {'a': 1}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2}, 'Failed': {'a': 1, 'c': 3}}} -> {'Message': '1', 'OK': False}
-      {'OK': True, 'Value': {'Successful': {'b': 2, 'd': 4}, 'Failed': {}}} -> {'OK': True, 'Value': 2}
-      {'OK': True, 'Value': {'Successful': {}, 'Failed': {}}} ->
-          {'Message': 'returnSingleResult: Failed and Successful dictionaries are empty', 'OK': False}
-    """
-    # if S_ERROR was returned, we return it as well
-    if not dictRes["OK"]:
-        return dictRes
-    # if there is a Failed, we return the first one in an S_ERROR
-    if "Failed" in dictRes["Value"] and len(dictRes["Value"]["Failed"]):
-        errorMessage = list(dictRes["Value"]["Failed"].values())[0]
-        if isinstance(errorMessage, dict):
-            if isReturnStructure(errorMessage):
-                return cast(DErrorReturnType, errorMessage)
-            else:
-                return S_ERROR(str(errorMessage))
-        return S_ERROR(errorMessage)
-    # if there is a Successful, we return the first one in an S_OK
-    elif "Successful" in dictRes["Value"] and len(dictRes["Value"]["Successful"]):
-        return S_OK(list(dictRes["Value"]["Successful"].values())[0])
-    else:
-        return S_ERROR("returnSingleResult: Failed and Successful dictionaries are empty")
-
-
-class SErrorException(Exception):
-    """Exception class for use with `convertToReturnValue`"""
-
-    def __init__(self, result: DErrorReturnType | str, errCode: int = 0):
-        """Create a new exception return value
-
-        If `result` is a `S_ERROR` return it directly else convert it to an
-        appropriate value using `S_ERROR(errCode, result)`.
-
-        :param result: The error to propagate
-        :param errCode: the error code to propagate
-        """
-        if not isSError(result):
-            result = S_ERROR(errCode, result)
-        self.result = cast(DErrorReturnType, result)
-
-
-def returnValueOrRaise(result: DReturnType[T], *, errorCode: int = 0) -> T:
-    """Unwrap an S_OK/S_ERROR response into a value or Exception
-
-    This method assists with using exceptions in DIRAC code by raising
-    :exc:`SErrorException` if `result` is an error. This can then by propagated
-    automatically as an `S_ERROR` by wrapping public facing functions with
-    `@convertToReturnValue`.
-
-    :param result: Result of a DIRAC function which returns `S_OK`/`S_ERROR`
-    :returns: The value associated with the `S_OK` object
-    :raises: If `result["OK"]` is falsey the original exception is re-raised.
-             If no exception is known an :exc:`SErrorException` is raised.
-    """
-    if not result["OK"]:
-        if "ExecInfo" in result:
-            raise result["ExecInfo"][0]
-        else:
-            raise SErrorException(result, errorCode)
-    return result["Value"]
-
-
-def convertToReturnValue(func: Callable[P, T]) -> Callable[P, DReturnType[T]]:
-    """Decorate a function to convert return values to `S_OK`/`S_ERROR`
-
-    If `func` returns, wrap the return value in `S_OK`.
-    If `func` raises :exc:`SErrorException`, return the associated `S_ERROR`
-    If `func` raises any other exception type, convert it to an `S_ERROR` object
-
-    :param result: The bare result of a function call
-    :returns: `S_OK`/`S_ERROR`
-    """
-
-    @functools.wraps(func)
-    def wrapped(*args: P.args, **kwargs: P.kwargs) -> DReturnType[T]:
-        try:
-            value = func(*args, **kwargs)
-        except SErrorException as e:
-            return e.result
-        except Exception as e:
-            retval = S_ERROR(f"{repr(e)}: {e}")
-            # Replace CallStack with the one from the exception
-            # Use cast as mypy doesn't understand that sys.exc_info can't return None in an exception block
-            retval["ExecInfo"] = cast(tuple[type[BaseException], BaseException, TracebackType], sys.exc_info())
-            exc_type, exc_value, exc_tb = retval["ExecInfo"]
-            retval["CallStack"] = traceback.format_tb(exc_tb)
-            return retval
-        else:
-            return S_OK(value)
-
-    # functools will copy the annotations. Since we change the return type
-    # we have to update it
-    wrapped.__annotations__["return"] = DReturnType
-    return wrapped
+# Re-export everything from DIRACCommon for backward compatibility
+from DIRACCommon.Utils.ReturnValues import *  # noqa: F401, F403

DIRAC/Core/scripts/dirac_agent.py

@@ -25,7 +25,7 @@ def main():
     localCfg.setConfigurationForAgent(agentName)
     localCfg.addDefaultEntry("/DIRAC/Security/UseServerCertificate", "yes")
     localCfg.addDefaultEntry("LogColor", True)
-    resultDict = localCfg.loadUserData()
+    resultDict = localCfg.loadUserData(requireSuccessfulSync=True)
     if not resultDict["OK"]:
         gLogger.error("There were errors when loading configuration", resultDict["Message"])
         sys.exit(1)

DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py

@@ -37,7 +37,7 @@ from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
     RIGHT_DELETE,
     RIGHT_KILL,
 )
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 
 # # agent's name
 AGENT_NAME = "Transformation/TransformationCleaningAgent"

DIRAC/WorkloadManagementSystem/Agent/JobCleaningAgent.py

@@ -39,7 +39,7 @@ from DIRAC.WorkloadManagementSystem.Client.WMSClient import WMSClient
 from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
 from DIRAC.WorkloadManagementSystem.DB.SandboxMetadataDB import SandboxMetadataDB
 from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_DELETE
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import getJobParameters
 
 

DIRAC/WorkloadManagementSystem/Agent/StalledJobAgent.py

@@ -23,7 +23,7 @@ from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
 from DIRAC.WorkloadManagementSystem.DB.JobLoggingDB import JobLoggingDB
 from DIRAC.WorkloadManagementSystem.DB.PilotAgentsDB import PilotAgentsDB
 from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_KILL
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 from DIRAC.WorkloadManagementSystem.Utilities.JobParameters import getJobParameters
 from DIRAC.WorkloadManagementSystem.Utilities.Utils import rescheduleJobs
 

DIRAC/WorkloadManagementSystem/DB/StatusUtils.py

@@ -0,0 +1,125 @@
+from DIRAC import S_ERROR, S_OK, gLogger
+from DIRAC.StorageManagementSystem.DB.StorageManagementDB import StorageManagementDB
+from DIRAC.WorkloadManagementSystem.Client import JobStatus
+from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
+from DIRAC.WorkloadManagementSystem.DB.PilotAgentsDB import PilotAgentsDB
+from DIRAC.WorkloadManagementSystem.DB.TaskQueueDB import TaskQueueDB
+from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_DELETE, RIGHT_KILL
+from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import _filterJobStateTransition
+
+
+def _deleteJob(jobID, force=False):
+    """Set the job status to "Deleted"
+    and remove the pilot that ran and its logging info if the pilot is finished.
+
+    :param int jobID: job ID
+    :return: S_OK()/S_ERROR()
+    """
+    if not (result := JobDB().setJobStatus(jobID, JobStatus.DELETED, "Checking accounting", force=force))["OK"]:
+        gLogger.warn("Failed to set job Deleted status", result["Message"])
+        return result
+
+    if not (result := TaskQueueDB().deleteJob(jobID))["OK"]:
+        gLogger.warn("Failed to delete job from the TaskQueue")
+
+    # if it was the last job for the pilot
+    result = PilotAgentsDB().getPilotsForJobID(jobID)
+    if not result["OK"]:
+        gLogger.error("Failed to get Pilots for JobID", result["Message"])
+        return result
+    for pilot in result["Value"]:
+        res = PilotAgentsDB().getJobsForPilot(pilot)
+        if not res["OK"]:
+            gLogger.error("Failed to get jobs for pilot", res["Message"])
+            return res
+        if not res["Value"]:  # if list of jobs for pilot is empty, delete pilot
+            result = PilotAgentsDB().getPilotInfo(pilotID=pilot)
+            if not result["OK"]:
+                gLogger.error("Failed to get pilot info", result["Message"])
+                return result
+            ret = PilotAgentsDB().deletePilot(result["Value"]["PilotJobReference"])
+            if not ret["OK"]:
+                gLogger.error("Failed to delete pilot from PilotAgentsDB", ret["Message"])
+                return ret
+
+    return S_OK()
+
+
+def _killJob(jobID, sendKillCommand=True, force=False):
+    """Kill one job
+
+    :param int jobID: job ID
+    :param bool sendKillCommand: send kill command
+
+    :return: S_OK()/S_ERROR()
+    """
+    if sendKillCommand:
+        if not (result := JobDB().setJobCommand(jobID, "Kill"))["OK"]:
+            gLogger.warn("Failed to set job Kill command", result["Message"])
+            return result
+
+    gLogger.info("Job marked for termination", jobID)
+    if not (result := JobDB().setJobStatus(jobID, JobStatus.KILLED, "Marked for termination", force=force))["OK"]:
+        gLogger.warn("Failed to set job Killed status", result["Message"])
+    if not (result := TaskQueueDB().deleteJob(jobID))["OK"]:
+        gLogger.warn("Failed to delete job from the TaskQueue", result["Message"])
+
+    return S_OK()
+
+
+def kill_delete_jobs(right, validJobList, nonauthJobList=[], force=False):
+    """Kill (== set the status to "KILLED") or delete (== set the status to "DELETED") jobs as necessary
+
+    :param str right: RIGHT_KILL or RIGHT_DELETE
+
+    :return: S_OK()/S_ERROR()
+    """
+    badIDs = []
+
+    killJobList = []
+    deleteJobList = []
+    if validJobList:
+        result = JobDB().getJobsAttributes(killJobList, ["Status"])
+        if not result["OK"]:
+            return result
+        jobStates = result["Value"]
+
+        # Get the jobs allowed to transition to the Killed state
+        killJobList.extend(_filterJobStateTransition(jobStates, JobStatus.KILLED))
+
+        if right == RIGHT_DELETE:
+            # Get the jobs allowed to transition to the Deleted state
+            deleteJobList.extend(_filterJobStateTransition(jobStates, JobStatus.DELETED))
+
+        for jobID in killJobList:
+            result = _killJob(jobID, force=force)
+            if not result["OK"]:
+                badIDs.append(jobID)
+
+        for jobID in deleteJobList:
+            result = _deleteJob(jobID, force=force)
+            if not result["OK"]:
+                badIDs.append(jobID)
+
+        # Look for jobs that are in the Staging state to send kill signal to the stager
+        stagingJobList = [jobID for jobID, sDict in jobStates.items() if sDict["Status"] == JobStatus.STAGING]
+
+        if stagingJobList:
+            stagerDB = StorageManagementDB()
+            gLogger.info("Going to send killing signal to stager as well!")
+            result = stagerDB.killTasksBySourceTaskID(stagingJobList)
+            if not result["OK"]:
+                gLogger.warn("Failed to kill some Stager tasks", result["Message"])
+
+    if nonauthJobList or badIDs:
+        result = S_ERROR("Some jobs failed deletion")
+        if nonauthJobList:
+            gLogger.warn("Non-authorized JobIDs won't be deleted", str(nonauthJobList))
+            result["NonauthorizedJobIDs"] = nonauthJobList
+        if badIDs:
+            gLogger.warn("JobIDs failed to be deleted", str(badIDs))
+            result["FailedJobIDs"] = badIDs
+        return result
+
+    jobsList = killJobList if right == RIGHT_KILL else deleteJobList
+    return S_OK(jobsList)

DIRAC/WorkloadManagementSystem/DB/tests/Test_StatusUtils.py

@@ -0,0 +1,28 @@
+""" unit test (pytest) of JobAdministration module
+"""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+# sut
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
+
+
+@pytest.mark.parametrize(
+    "jobIDs_list, right",
+    [
+        ([], "Kill"),
+        ([], "Delete"),
+        (1, "Kill"),
+        ([1, 2], "Kill"),
+    ],
+)
+def test___kill_delete_jobs(mocker, jobIDs_list, right):
+    mocker.patch("DIRAC.WorkloadManagementSystem.DB.StatusUtils.JobDB", MagicMock())
+    mocker.patch("DIRAC.WorkloadManagementSystem.DB.StatusUtils.TaskQueueDB", MagicMock())
+    mocker.patch("DIRAC.WorkloadManagementSystem.DB.StatusUtils.PilotAgentsDB", MagicMock())
+    mocker.patch("DIRAC.WorkloadManagementSystem.DB.StatusUtils.StorageManagementDB", MagicMock())
+
+    res = kill_delete_jobs(right, jobIDs_list)
+    assert res["OK"]

DIRAC/WorkloadManagementSystem/Service/JobManagerHandler.py

@@ -30,7 +30,7 @@ from DIRAC.WorkloadManagementSystem.Service.JobPolicy import (
     RIGHT_SUBMIT,
     JobPolicy,
 )
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
+from DIRAC.WorkloadManagementSystem.DB.StatusUtils import kill_delete_jobs
 from DIRAC.WorkloadManagementSystem.Utilities.JobModel import JobDescriptionModel
 from DIRAC.WorkloadManagementSystem.Utilities.ParametricJob import generateParametricJobs, getParameterVectorLength
 from DIRAC.WorkloadManagementSystem.Utilities.Utils import rescheduleJobs

DIRAC/WorkloadManagementSystem/Utilities/jobAdministration.py

@@ -1,127 +1,4 @@
-from DIRAC import S_ERROR, S_OK, gLogger
-from DIRAC.StorageManagementSystem.DB.StorageManagementDB import StorageManagementDB
 from DIRAC.WorkloadManagementSystem.Client import JobStatus
-from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
-from DIRAC.WorkloadManagementSystem.DB.PilotAgentsDB import PilotAgentsDB
-from DIRAC.WorkloadManagementSystem.DB.TaskQueueDB import TaskQueueDB
-from DIRAC.WorkloadManagementSystem.Service.JobPolicy import RIGHT_DELETE, RIGHT_KILL
-
-
-def _deleteJob(jobID, force=False):
-    """Set the job status to "Deleted"
-    and remove the pilot that ran and its logging info if the pilot is finished.
-
-    :param int jobID: job ID
-    :return: S_OK()/S_ERROR()
-    """
-    if not (result := JobDB().setJobStatus(jobID, JobStatus.DELETED, "Checking accounting", force=force))["OK"]:
-        gLogger.warn("Failed to set job Deleted status", result["Message"])
-        return result
-
-    if not (result := TaskQueueDB().deleteJob(jobID))["OK"]:
-        gLogger.warn("Failed to delete job from the TaskQueue")
-
-    # if it was the last job for the pilot
-    result = PilotAgentsDB().getPilotsForJobID(jobID)
-    if not result["OK"]:
-        gLogger.error("Failed to get Pilots for JobID", result["Message"])
-        return result
-    for pilot in result["Value"]:
-        res = PilotAgentsDB().getJobsForPilot(pilot)
-        if not res["OK"]:
-            gLogger.error("Failed to get jobs for pilot", res["Message"])
-            return res
-        if not res["Value"]:  # if list of jobs for pilot is empty, delete pilot
-            result = PilotAgentsDB().getPilotInfo(pilotID=pilot)
-            if not result["OK"]:
-                gLogger.error("Failed to get pilot info", result["Message"])
-                return result
-            ret = PilotAgentsDB().deletePilot(result["Value"]["PilotJobReference"])
-            if not ret["OK"]:
-                gLogger.error("Failed to delete pilot from PilotAgentsDB", ret["Message"])
-                return ret
-
-    return S_OK()
-
-
-def _killJob(jobID, sendKillCommand=True, force=False):
-    """Kill one job
-
-    :param int jobID: job ID
-    :param bool sendKillCommand: send kill command
-
-    :return: S_OK()/S_ERROR()
-    """
-    if sendKillCommand:
-        if not (result := JobDB().setJobCommand(jobID, "Kill"))["OK"]:
-            gLogger.warn("Failed to set job Kill command", result["Message"])
-            return result
-
-    gLogger.info("Job marked for termination", jobID)
-    if not (result := JobDB().setJobStatus(jobID, JobStatus.KILLED, "Marked for termination", force=force))["OK"]:
-        gLogger.warn("Failed to set job Killed status", result["Message"])
-    if not (result := TaskQueueDB().deleteJob(jobID))["OK"]:
-        gLogger.warn("Failed to delete job from the TaskQueue", result["Message"])
-
-    return S_OK()
-
-
-def kill_delete_jobs(right, validJobList, nonauthJobList=[], force=False):
-    """Kill (== set the status to "KILLED") or delete (== set the status to "DELETED") jobs as necessary
-
-    :param str right: RIGHT_KILL or RIGHT_DELETE
-
-    :return: S_OK()/S_ERROR()
-    """
-    badIDs = []
-
-    killJobList = []
-    deleteJobList = []
-    if validJobList:
-        result = JobDB().getJobsAttributes(killJobList, ["Status"])
-        if not result["OK"]:
-            return result
-        jobStates = result["Value"]
-
-        # Get the jobs allowed to transition to the Killed state
-        killJobList.extend(_filterJobStateTransition(jobStates, JobStatus.KILLED))
-
-        if right == RIGHT_DELETE:
-            # Get the jobs allowed to transition to the Deleted state
-            deleteJobList.extend(_filterJobStateTransition(jobStates, JobStatus.DELETED))
-
-        for jobID in killJobList:
-            result = _killJob(jobID, force=force)
-            if not result["OK"]:
-                badIDs.append(jobID)
-
-        for jobID in deleteJobList:
-            result = _deleteJob(jobID, force=force)
-            if not result["OK"]:
-                badIDs.append(jobID)
-
-        # Look for jobs that are in the Staging state to send kill signal to the stager
-        stagingJobList = [jobID for jobID, sDict in jobStates.items() if sDict["Status"] == JobStatus.STAGING]
-
-        if stagingJobList:
-            stagerDB = StorageManagementDB()
-            gLogger.info("Going to send killing signal to stager as well!")
-            result = stagerDB.killTasksBySourceTaskID(stagingJobList)
-            if not result["OK"]:
-                gLogger.warn("Failed to kill some Stager tasks", result["Message"])
-
-    if nonauthJobList or badIDs:
-        result = S_ERROR("Some jobs failed deletion")
-        if nonauthJobList:
-            gLogger.warn("Non-authorized JobIDs won't be deleted", str(nonauthJobList))
-            result["NonauthorizedJobIDs"] = nonauthJobList
-        if badIDs:
-            gLogger.warn("JobIDs failed to be deleted", str(badIDs))
-            result["FailedJobIDs"] = badIDs
-        return result
-
-    jobsList = killJobList if right == RIGHT_KILL else deleteJobList
-    return S_OK(jobsList)
 
 
 def _filterJobStateTransition(jobStates, candidateState):

DIRAC/__init__.py

@@ -1,59 +1,60 @@
 """
-   DIRAC - Distributed Infrastructure with Remote Agent Control
-
-   The distributed data production and analysis system of LHCb and other VOs.
-
-   DIRAC is a software framework for distributed computing which
-   allows to integrate various computing resources in a single
-   system. At the same time it integrates all kinds of computing
-   activities like Monte Carlo simulations, data processing, or
-   final user analysis.
-
-   It is build as number of cooperating systems:
-    - Accounting
-    - Configuration
-    - Core
-      - Base
-      - Security
-      - Utilities
-      - Workflow
-    - Framework
-    - RequestManagement
-    - Resources
-    - Transformation
-
-    Which are used by other system providing functionality to
-    the end user:
-    - DataManagement
-    - Interfaces
-    - ResourceStatus
-    - StorageManagement
-    - WorkloadManagement
-
-    It defines the following data members:
-    - version:       DIRAC version string
-
-    - errorMail:     mail address for important errors
-    - alarmMail:     mail address for important alarms
-
-    It loads Modules from :
-    - DIRAC.Core.Utililies
-
-    It loads:
-    - S_OK:           OK return structure
-    - S_ERROR:        ERROR return structure
-    - gLogger:        global Logger object
-    - gConfig:        global Config object
-
-    It defines the following functions:
-    - abort:          aborts execution
-    - exit:           finish execution using callbacks
-    - siteName:       returns DIRAC name for current site
-
-    - getPlatform():      DIRAC platform string for current host
-    - getPlatformTuple(): DIRAC platform tuple for current host
+DIRAC - Distributed Infrastructure with Remote Agent Control
+
+The distributed data production and analysis system of LHCb and other VOs.
+
+DIRAC is a software framework for distributed computing which
+allows to integrate various computing resources in a single
+system. At the same time it integrates all kinds of computing
+activities like Monte Carlo simulations, data processing, or
+final user analysis.
+
+It is build as number of cooperating systems:
+ - Accounting
+ - Configuration
+ - Core
+   - Base
+   - Security
+   - Utilities
+   - Workflow
+ - Framework
+ - RequestManagement
+ - Resources
+ - Transformation
+
+ Which are used by other system providing functionality to
+ the end user:
+ - DataManagement
+ - Interfaces
+ - ResourceStatus
+ - StorageManagement
+ - WorkloadManagement
+
+ It defines the following data members:
+ - version:       DIRAC version string
+
+ - errorMail:     mail address for important errors
+ - alarmMail:     mail address for important alarms
+
+ It loads Modules from :
+ - DIRAC.Core.Utililies
+
+ It loads:
+ - S_OK:           OK return structure
+ - S_ERROR:        ERROR return structure
+ - gLogger:        global Logger object
+ - gConfig:        global Config object
+
+ It defines the following functions:
+ - abort:          aborts execution
+ - exit:           finish execution using callbacks
+ - siteName:       returns DIRAC name for current site
+
+ - getPlatform():      DIRAC platform string for current host
+ - getPlatformTuple(): DIRAC platform tuple for current host
 
 """
+
 import importlib.metadata
 import os
 import re
@@ -237,7 +238,7 @@ def initialize(
         log_level = getattr(LogLevel, gLogger.getLevel())
         gLogger.setLevel(LogLevel.ALWAYS)
     try:
-        returnValueOrRaise(localCfg.initialize())
+        returnValueOrRaise(localCfg.initialize(requireSuccessfulSync=require_auth))
     finally:
         # Restore the pre-existing log level
         gLogger.setLevel(log_level)

{dirac-9.0.0a64.dist-info → dirac-9.0.0a66.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DIRAC
-Version: 9.0.0a64
+Version: 9.0.0a66
 Summary: DIRAC is an interware, meaning a software framework for distributed computing.
 Home-page: https://github.com/DIRACGrid/DIRAC/
 License: GPL-3.0-only
@@ -19,6 +19,7 @@ Requires-Dist: cachetools
 Requires-Dist: certifi
 Requires-Dist: cwltool
 Requires-Dist: diraccfg
+Requires-Dist: DIRACCommon==v9.0.0a66
 Requires-Dist: diracx-client>=v0.0.1a18
 Requires-Dist: diracx-core>=v0.0.1a18
 Requires-Dist: db12

{dirac-9.0.0a64.dist-info → dirac-9.0.0a66.dist-info}/RECORD

@@ -1,4 +1,4 @@
-DIRAC/__init__.py,sha256=IrCjUEvcKwE2KLYNuxiADIGrtOgSCb8MOoK8QVDsERU,11301
+DIRAC/__init__.py,sha256=uEe7WZkuhG6uOif8DHAsP5fT045vFDNK8DSlU3e3u64,11207
 DIRAC/AccountingSystem/ConfigTemplate.cfg,sha256=xT_JHJGumwEx_w1aditaxn3zq0r4ehIScX4qYFwjT3o,819
 DIRAC/AccountingSystem/__init__.py,sha256=E88siUatzE7vxErfezaEuZxK4yfHvkKCqqC9toGvqwg,539
 DIRAC/AccountingSystem/Agent/NetworkAgent.py,sha256=qHY-aewzEYS99VsW_Ka-aoap2kqNEAe9qcH3jg25yqI,10999
@@ -58,7 +58,7 @@ DIRAC/ConfigurationSystem/Client/CSShellCLI.py,sha256=dlkGA-2-YJV8mwllJ2qG8_dvQf
 DIRAC/ConfigurationSystem/Client/Config.py,sha256=b8UBxKSJ3ZXVpIDGVXPR95dPs4RApEiLtqdN3fDo22k,524
 DIRAC/ConfigurationSystem/Client/ConfigurationClient.py,sha256=Eb0rzqYAhrAYsXDNELWBvfjV2x-9LisaYy5tIk8oQBQ,2434
 DIRAC/ConfigurationSystem/Client/ConfigurationData.py,sha256=3BhUZUne2KiMKSNqs1ePqiczKdT7sAh210CmWbbIYhw,124
-DIRAC/ConfigurationSystem/Client/LocalConfiguration.py,sha256=fZf00LRJOIOtobHFtJ_yrn444fG51yk1AmqBPkYbT-A,32060
+DIRAC/ConfigurationSystem/Client/LocalConfiguration.py,sha256=KaVGD4YVEfxCspVavddAEQpcetynvek-msfFIquawE4,32442
 DIRAC/ConfigurationSystem/Client/PathFinder.py,sha256=wxOWC0_UznF7XJc0LP9DX8y3yltOApJXwZehx1ghgpU,11054
 DIRAC/ConfigurationSystem/Client/Utilities.py,sha256=lQepoCgaAvg9GW3_-s-IXkWb3fN3HJJP95pYhNEC2_4,27200
 DIRAC/ConfigurationSystem/Client/VOMS2CSSynchronizer.py,sha256=U-y7vc8NYwsyQLFkSzKCXnVEJMIoLsxgthFC0z9x7Dk,31426
@@ -223,7 +223,7 @@ DIRAC/Core/Utilities/CGroups2.py,sha256=dKJf0yAACpcO5wIGsOgvf5Sh7ZZNua_gSn_u95gj
 DIRAC/Core/Utilities/CountryMapping.py,sha256=6OfH_sYS0F3qrJn-Hp_YSR0l7WWNsglHtH6AIDGR58A,1080
 DIRAC/Core/Utilities/DAG.py,sha256=ME-oxtsV2PYIuWikL8-571RR3U21siHxo1hFQGi3s9Q,3587
 DIRAC/Core/Utilities/DEncode.py,sha256=O-5Yi185V05tBNyXCxoourRQkuOCP6pTyDYaRgNdi8w,15578
-DIRAC/Core/Utilities/DErrno.py,sha256=KzjtYQhMD5X196u4LMPQzf5uak1ON-hscYM234Rrfp4,10471
+DIRAC/Core/Utilities/DErrno.py,sha256=hnRO64KrCrhETHAEiJh44CQfc0VoC8L-FNi7UOlWvUU,3193
 DIRAC/Core/Utilities/DIRACSingleton.py,sha256=UqJHJNJyX4ehCB5PGDuA74FuCaoih6V979ftr8KboH4,1219
 DIRAC/Core/Utilities/Decorators.py,sha256=WAYke0p9VKov24stHO-S4HEia-HGCSA1c1XDyxxZtw8,7153
 DIRAC/Core/Utilities/Devloader.py,sha256=nPEinBId-NzyG1zcjcnUQOO-pWmNJsmWkj-Xkt5dn_c,2572
@@ -254,7 +254,7 @@ DIRAC/Core/Utilities/ProcessPool.py,sha256=AQ-ABejCKbdYVn4SD_Qy2DWZYA39fIt_3Occp
 DIRAC/Core/Utilities/Profiler.py,sha256=sSMe9Mp-C1lNT_AkMbZMcOsD2vxlKNWGa-eMSCp4t4c,7531
 DIRAC/Core/Utilities/PromptUser.py,sha256=Pg51ZPZwXLYk8ncwrVvpimXfelWKxCeocRekRlqs2fQ,1441
 DIRAC/Core/Utilities/Proxy.py,sha256=BDAq_PXcuN6AlGX1gs9n8_yY9xT7JOtlKIO2cdTS24I,9816
-DIRAC/Core/Utilities/ReturnValues.py,sha256=xVDsGNLglVdZKKjlwF0DluBaGhaVveqogKBf7HlIGqo,8727
+DIRAC/Core/Utilities/ReturnValues.py,sha256=utF0CJ5PQX4D3J7KBRBJwOiNVm8ut8bgToXmWs0k_c8,438
 DIRAC/Core/Utilities/Shifter.py,sha256=EkJGPR_zbL0SS3E2_cq1-MjkTH91ZaFJlh-tQ2PxDGk,2571
 DIRAC/Core/Utilities/SiteSEMapping.py,sha256=Uynx_evXQPmfbMKH-TfqzLq4e_7APVrP6gC20cJEBYs,5683
 DIRAC/Core/Utilities/StateMachine.py,sha256=jxPsFSlqQvbNBZiKCuiztpTf9onsHeQDhk_1piNQcyw,6691
@@ -322,7 +322,7 @@ DIRAC/Core/Workflow/test/WFSamples.py,sha256=BNQSG31x393ho2-2TIjGKJQjbisNXx-5cx3
 DIRAC/Core/Workflow/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 DIRAC/Core/Workflow/test/step_g.py,sha256=hlncZ_tbb74wz0mRxyHTl0NnjRut2ysWLgUfiTvi9yo,21830
 DIRAC/Core/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-DIRAC/Core/scripts/dirac_agent.py,sha256=Nx1qlr2YOQobWkO1FtzFyL00tF8TH1HmonDsfbsCDzk,1644
+DIRAC/Core/scripts/dirac_agent.py,sha256=cjR5wuh4j5D5nTvu9ZfPbjdbZiEnRG34GJj7iSh47qk,1670
 DIRAC/Core/scripts/dirac_apptainer_exec.py,sha256=6zs6PepCtLj96OoDDxpRUQk9nKgs9ksAG8o6J6djbFo,4666
 DIRAC/Core/scripts/dirac_cert_convert.py,sha256=3ThPmb1Tg-UgeH-3ZV0ilkZ8-H4RsK8SOszLuuYG-vs,2498
 DIRAC/Core/scripts/dirac_configure.py,sha256=c3ZfQUe_JUJASi3iuvl4qD83kyfWvS_QixISyG833sg,29494
@@ -1053,7 +1053,7 @@ DIRAC/TransformationSystem/Agent/RequestTaskAgent.py,sha256=0FxuRVONDkC6DtDqfSC4
 DIRAC/TransformationSystem/Agent/TaskManagerAgentBase.py,sha256=M8CVPGCY4UMNfKNDdcfgUd2er3JPAIeNzGghsk0ohUQ,30824
 DIRAC/TransformationSystem/Agent/TransformationAgent.py,sha256=rUPyfX_Ip3ZUyBrmVBrYiddVmgeTx6gKiYPEzwUDOcY,33813
 DIRAC/TransformationSystem/Agent/TransformationAgentsUtilities.py,sha256=XrgrjQWSDQm0uxG-wyEY-W0A_MBJyIE-22TafqrLP3A,2805
-DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py,sha256=AIzfICpz-siuIApZJ5w7biq3HanDcOFUGlSvPsSeYTc,32911
+DIRAC/TransformationSystem/Agent/TransformationCleaningAgent.py,sha256=uAu_aQxko4GF_cTxDxY4KmARqjuytBO89e4XVy5PPUM,32898
 DIRAC/TransformationSystem/Agent/TransformationPlugin.py,sha256=EpWil1Bla9xdrJkhj61oUFDpGzyWfC8acW3tjBh5JpQ,11322
 DIRAC/TransformationSystem/Agent/ValidateOutputDataAgent.py,sha256=tsE0yE2bqSKwdjJml3Mros-tMOfpSDr9Bt8R3MTeqRo,10108
 DIRAC/TransformationSystem/Agent/WorkflowTaskAgent.py,sha256=UBNVVx0ZgiFnzAPCNC1dSuJXKkt2pPfpSqhy0CREFlg,1741
@@ -1122,13 +1122,13 @@ DIRAC/Workflow/Utilities/test/Test_Utilities.py,sha256=DNjFPpBmpojwCWhZSUSoG3AIh
 DIRAC/WorkloadManagementSystem/ConfigTemplate.cfg,sha256=EpXTiHV-omMuMcWDzQzWZ_LmAZFMRTabfJpfZmVfzEA,9065
 DIRAC/WorkloadManagementSystem/__init__.py,sha256=9-_-HOT_8S3i-TMmTR_gFVVlNyktBRk-S2qSuOBKoIc,50
 DIRAC/WorkloadManagementSystem/Agent/JobAgent.py,sha256=Hi3zPfK9h7CwNO2pK4IABCqO_uShCIaKvZGlUdgsWPA,41034
-DIRAC/WorkloadManagementSystem/Agent/JobCleaningAgent.py,sha256=oY530fCi1Lq36UgDaLUcUt4SjRVwtcvyt_40wwyTxfk,14721
+DIRAC/WorkloadManagementSystem/Agent/JobCleaningAgent.py,sha256=TR8nDO43DuJxOQVIdOUrqpWjRjJp52dVzOKUUewL9U4,14708
 DIRAC/WorkloadManagementSystem/Agent/PilotLoggingAgent.py,sha256=ZIgvFpasGTh76GW3G7O4hKC_Kkm31uWymlH-MTT3AXg,10541
 DIRAC/WorkloadManagementSystem/Agent/PilotStatusAgent.py,sha256=qY6TbYCPOFFXhHffmRJLNEbWvZPyg5Lc5B_8BbyQ7zc,9711
 DIRAC/WorkloadManagementSystem/Agent/PilotSyncAgent.py,sha256=Q50axgfx_D9iF2hT0aNaJ1KA85idOluBeBWDcjR6j8c,4845
 DIRAC/WorkloadManagementSystem/Agent/PushJobAgent.py,sha256=OkIIFnJrwUYCroWEc5bgAfsnGks98y0gO1GLKamBXO0,38820
 DIRAC/WorkloadManagementSystem/Agent/SiteDirector.py,sha256=ZnbjKca8tWLekObALrsFXm7EoXAYxEpHSGRAbrqU5mk,45229
-DIRAC/WorkloadManagementSystem/Agent/StalledJobAgent.py,sha256=ybTMUqZCKOVfzMi9k8wvrl3KslnlSUWhTp6wWR3mt7E,24585
+DIRAC/WorkloadManagementSystem/Agent/StalledJobAgent.py,sha256=foEbmRotEmfeQG6nyIsJv1kSJkm4flkQsPYbSylS3SM,24572
 DIRAC/WorkloadManagementSystem/Agent/StatesAccountingAgent.py,sha256=iNIlWQEDBk6R1S8oHOIusZUwxOwLtgwuzR_4s32-o5w,8707
 DIRAC/WorkloadManagementSystem/Agent/TaskQueuesAgent.py,sha256=ypsmo233TFXq9IC5uz6pum7_joOh2gFPUYNmmCpukAY,943
 DIRAC/WorkloadManagementSystem/Agent/__init__.py,sha256=Pp2qIXA0zZxJXBQwPEDUt23Y_ct5cjs77w8ZEV6Ll6M,56
@@ -1186,10 +1186,12 @@ DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.py,sha256=tUSuhv59CQgB7NkxsXo5r-
 DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.sql,sha256=RnCDCDGa__7sDxjSFGlu_5OwKbzxeK3a9TOMpV5ftRw,2738
 DIRAC/WorkloadManagementSystem/DB/SandboxMetadataDB.py,sha256=a4tHv19jN2lKi4o5SYvfkG6JPbVcjJO_SgJBJORUV7Y,15631
 DIRAC/WorkloadManagementSystem/DB/SandboxMetadataDB.sql,sha256=2TcyLiewFuPWqBhD43geHG0obCFRGTSLbQwPUwENYnQ,23
+DIRAC/WorkloadManagementSystem/DB/StatusUtils.py,sha256=K4fIDNOWbSxUaxVfKbsSKzPAlF5v_S5FSCGxHRkPScM,5124
 DIRAC/WorkloadManagementSystem/DB/TaskQueueDB.py,sha256=4ClljoQUnHKq1KHAIFpUwL_5-NrUUuM8oHKzOZULXZg,54623
 DIRAC/WorkloadManagementSystem/DB/TaskQueueDB.sql,sha256=GfeceE3VY7l15pMwt6MzI8pGqdk772XuIg_DE0vkj74,541
 DIRAC/WorkloadManagementSystem/DB/__init__.py,sha256=1H5briNEaZlSL6pMxzjDmkZkVvGxHix8DtfkM-mOwGc,53
 DIRAC/WorkloadManagementSystem/DB/tests/Test_JobDB.py,sha256=PppmPBWFKQMeNUZXHcfl07hVu7hdrJcqFXFloXO2JMU,1068
+DIRAC/WorkloadManagementSystem/DB/tests/Test_StatusUtils.py,sha256=nibKxynwLdJZafC0k01oE1FwOFgSlEMw2hUlrlacwEo,845
 DIRAC/WorkloadManagementSystem/DB/tests/Test_TaskQueueDB.py,sha256=QWGxTbGez9wojkHzbpqksdKc6I6_X-Dh49tXB8gxc8s,6368
 DIRAC/WorkloadManagementSystem/Executor/InputData.py,sha256=ybhBMXkXf1JxLYKpNCAiyvtoiAICzvrm4UOnMSurmVA,18049
 DIRAC/WorkloadManagementSystem/Executor/JobPath.py,sha256=ovsRPGQiPixnTBsK4WRTZ2wqeXazK_tEloSgNwAtF80,2511
@@ -1219,7 +1221,7 @@ DIRAC/WorkloadManagementSystem/JobWrapper/test/script-RESC.sh,sha256=kiY-Af9a1bs
 DIRAC/WorkloadManagementSystem/JobWrapper/test/script-fail.sh,sha256=f1R0qtgJgOI3AbEoxGBqN8ClA6Y8Bz8tHlBXrxjySDs,63
 DIRAC/WorkloadManagementSystem/JobWrapper/test/script-long.sh,sha256=yzaSDg7P5hGv9SSCBsl8FLuj6-udCcpd0qId9kSv4Nc,41
 DIRAC/WorkloadManagementSystem/JobWrapper/test/script.sh,sha256=fbYLJJTVw9K7f9NdMvW_a-NkBI6SPup4NebPFYFKsbQ,9
-DIRAC/WorkloadManagementSystem/Service/JobManagerHandler.py,sha256=wXuBomLurY_EgYp69CrdrWR3pCr25nHVypzKa-oGJzo,21111
+DIRAC/WorkloadManagementSystem/Service/JobManagerHandler.py,sha256=flr1tqCQpRKb0u-RMBdCxqJJ4Ns-XL6XxPlbteRClCY,21098
 DIRAC/WorkloadManagementSystem/Service/JobMonitoringHandler.py,sha256=sFJOme3KDLeAppH_AF5dTt8om_g_zUSQvPnIs9BAQkc,7586
 DIRAC/WorkloadManagementSystem/Service/JobPolicy.py,sha256=o88xR3roe_JRB5F53oxb1LIuqY2qCCw6w5njprrJFMI,8057
 DIRAC/WorkloadManagementSystem/Service/JobStateUpdateHandler.py,sha256=TiSnLQTNd-HgAhPoqwebzN6G95pVXXgETJ5Hbw29XnY,9226
@@ -1246,8 +1248,7 @@ DIRAC/WorkloadManagementSystem/Utilities/QueueUtilities.py,sha256=J5-n_lvWbW_TRj
 DIRAC/WorkloadManagementSystem/Utilities/RemoteRunner.py,sha256=7FcEtlYSJMzdbLIFBUKD-j_wqRHya-ISqk8w-JRy3kw,12159
 DIRAC/WorkloadManagementSystem/Utilities/Utils.py,sha256=A6M-GnyC5LXeO0pJxwzqNdLjZLMC3WZ1o7dVFXumrsU,5331
 DIRAC/WorkloadManagementSystem/Utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-DIRAC/WorkloadManagementSystem/Utilities/jobAdministration.py,sha256=wBkf2gSaSOl5QZ3tecQOAgRCbGa3F-96K2HRUEmS6_A,5515
-DIRAC/WorkloadManagementSystem/Utilities/test/Test_JobAdministration.py,sha256=m4ZwTx6xKtUDIJu93MRmATBncVPbWfjPWp_CM6vAKuk,910
+DIRAC/WorkloadManagementSystem/Utilities/jobAdministration.py,sha256=uLgB0QLFPKUlZoWCOJYtQHaKykgCpodalHnMWpGld4s,548
 DIRAC/WorkloadManagementSystem/Utilities/test/Test_JobModel.py,sha256=dY7rRU8iOVYEgVLLXwjbx6vCUUHUZqOytDQO6ziarM8,8200
 DIRAC/WorkloadManagementSystem/Utilities/test/Test_JobStatusUtility.py,sha256=3Oj4zhiysp-Qiax1BsXK1fEyCuppln4tT5hmXx_BFxA,7931
 DIRAC/WorkloadManagementSystem/Utilities/test/Test_ParametricJob.py,sha256=mo_u-m4lM65c1Sgq6As4NpIiKRC0ny1oeBVYRBo61CM,3334
@@ -1295,9 +1296,9 @@ DIRAC/tests/Workflow/Integration/exe-script.py,sha256=B_slYdTocEzqfQLRhwuPiLyYUn
 DIRAC/tests/Workflow/Integration/helloWorld.py,sha256=tBgEHH3ZF7ZiTS57gtmm3DW-Qxgm_57HWHpM-Y8XSws,205
 DIRAC/tests/Workflow/Regression/helloWorld.py,sha256=69eCgFuVSYo-mK3Dj2dw1c6g86sF5FksKCf8V2aGVoM,509
 DIRAC/tests/Workflow/Regression/helloWorld.xml,sha256=xwydIcFTAHIX-YPfQfyxuQ7hzvIO3IhR3UAF7ORgkGg,5310
-dirac-9.0.0a64.dist-info/licenses/LICENSE,sha256=uyr4oV6jmjUeepXZPPjkJRwa5q5MrI7jqJz5sVXNblQ,32452
-dirac-9.0.0a64.dist-info/METADATA,sha256=IMy_Ti0nyOeTaXc0KqADf7e5VkZxyTyub-cZNohsfvc,9982
-dirac-9.0.0a64.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dirac-9.0.0a64.dist-info/entry_points.txt,sha256=hupzIL8aVmjK3nn7RLKdhcaiPmLOiD3Kulh3CSDHKmw,16492
-dirac-9.0.0a64.dist-info/top_level.txt,sha256=RISrnN9kb_mPqmVu8_o4jF-DSX8-h6AcgfkO9cgfkHA,6
-dirac-9.0.0a64.dist-info/RECORD,,
+dirac-9.0.0a66.dist-info/licenses/LICENSE,sha256=uyr4oV6jmjUeepXZPPjkJRwa5q5MrI7jqJz5sVXNblQ,32452
+dirac-9.0.0a66.dist-info/METADATA,sha256=O7cq5FZoLgGPJiwSKDLOIcAwemtym0zmOo9JHwNjXpc,10020
+dirac-9.0.0a66.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dirac-9.0.0a66.dist-info/entry_points.txt,sha256=hupzIL8aVmjK3nn7RLKdhcaiPmLOiD3Kulh3CSDHKmw,16492
+dirac-9.0.0a66.dist-info/top_level.txt,sha256=RISrnN9kb_mPqmVu8_o4jF-DSX8-h6AcgfkO9cgfkHA,6
+dirac-9.0.0a66.dist-info/RECORD,,

DIRAC/WorkloadManagementSystem/Utilities/test/Test_JobAdministration.py

@@ -1,28 +0,0 @@
-""" unit test (pytest) of JobAdministration module
-"""
-
-from unittest.mock import MagicMock
-
-import pytest
-
-# sut
-from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import kill_delete_jobs
-
-
-@pytest.mark.parametrize(
-    "jobIDs_list, right",
-    [
-        ([], "Kill"),
-        ([], "Delete"),
-        (1, "Kill"),
-        ([1, 2], "Kill"),
-    ],
-)
-def test___kill_delete_jobs(mocker, jobIDs_list, right):
-    mocker.patch("DIRAC.WorkloadManagementSystem.Utilities.jobAdministration.JobDB", MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Utilities.jobAdministration.TaskQueueDB", MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Utilities.jobAdministration.PilotAgentsDB", MagicMock())
-    mocker.patch("DIRAC.WorkloadManagementSystem.Utilities.jobAdministration.StorageManagementDB", MagicMock())
-
-    res = kill_delete_jobs(right, jobIDs_list)
-    assert res["OK"]