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

DIRAC/WorkloadManagementSystem/Service/SandboxStoreHandler.py

@@ -22,7 +22,6 @@ from DIRAC.Core.DISET.RequestHandler import RequestHandler
 from DIRAC.Core.Security import Properties
 from DIRAC.Core.Utilities.File import getGlobbedTotalSize, mkDir
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
-from DIRAC.DataManagementSystem.Service.StorageElementHandler import getDiskSpace
 from DIRAC.FrameworkSystem.Utilities.diracx import TheImpersonator
 
 
@@ -120,7 +119,7 @@ class SandboxStoreHandlerMixin:
                     format=extension,
                 )
 
-                with TheImpersonator(credDict) as client:
+                with TheImpersonator(credDict, source="SandboxStore") as client:
                     res = client.jobs.initiate_sandbox_upload(sandbox_info)
 
                 if res.url:
@@ -139,7 +138,7 @@ class SandboxStoreHandlerMixin:
                     gLogger.debug("Sandbox already exists in storage backend", res.pfn)
 
                 assignTo = {key: [(res.pfn, assignTo[key])] for key in assignTo}
-                result = self.export_assignSandboxesToEntities(assignTo)
+                result = self.sandboxDB.assignSandboxesToEntities(assignTo, credDict["username"], credDict["group"])
                 if not result["OK"]:
                     return result
                 return S_OK(res.pfn)
@@ -153,7 +152,7 @@ class SandboxStoreHandlerMixin:
                 fileHelper.markAsTransferred()
             sbURL = f"SB:{self.__localSEName}|{sbPath}"
             assignTo = {key: [(sbURL, assignTo[key])] for key in assignTo}
-            result = self.export_assignSandboxesToEntities(assignTo)
+            result = self.sandboxDB.assignSandboxesToEntities(assignTo, credDict["username"], credDict["group"])
             if not result["OK"]:
                 return result
             return S_OK(sbURL)
@@ -210,7 +209,9 @@ class SandboxStoreHandlerMixin:
 
         sbURL = f"SB:{self.__localSEName}|{sbPath}"
         assignTo = {key: [(sbURL, assignTo[key])] for key in assignTo}
-        if not (result := self.export_assignSandboxesToEntities(assignTo))["OK"]:
+        if not (result := self.sandboxDB.assignSandboxesToEntities(assignTo, credDict["username"], credDict["group"]))[
+            "OK"
+        ]:
             return result
         return S_OK(sbURL)
 
@@ -328,33 +329,6 @@ class SandboxStoreHandlerMixin:
 
         return result
 
-    ##################
-    # Assigning sbs to jobs
-
-    types_assignSandboxesToEntities = [dict]
-
-    def export_assignSandboxesToEntities(self, enDict, ownerName="", ownerGroup=""):
-        """
-        Assign sandboxes to jobs.
-        Expects a dict of { entityId : [ ( SB, SBType ), ... ] }
-        """
-        credDict = self.getRemoteCredentials()
-        return self.sandboxDB.assignSandboxesToEntities(
-            enDict, credDict["username"], credDict["group"], ownerName, ownerGroup
-        )
-
-    ##################
-    # Unassign sbs to jobs
-
-    types_unassignEntities = [(list, tuple)]
-
-    def export_unassignEntities(self, entitiesList):
-        """
-        Unassign a list of jobs
-        """
-        credDict = self.getRemoteCredentials()
-        return self.sandboxDB.unassignEntities(entitiesList, credDict["username"], credDict["group"])
-
     ##################
     # Getting assigned sandboxes
 
@@ -376,26 +350,6 @@ class SandboxStoreHandlerMixin:
             sbDict[SBType].append(f"SB:{SEName}|{SEPFN}")
         return S_OK(sbDict)
 
-    ##################
-    # Disk space left management
-
-    types_getFreeDiskSpace = []
-
-    def export_getFreeDiskSpace(self):
-        """Get the free disk space of the storage element
-        If no size is specified, terabytes will be used by default.
-        """
-
-        return getDiskSpace(self.getCSOption("BasePath", "/opt/dirac/storage/sandboxes"))
-
-    types_getTotalDiskSpace = []
-
-    def export_getTotalDiskSpace(self):
-        """Get the total disk space of the storage element
-        If no size is specified, terabytes will be used by default.
-        """
-        return getDiskSpace(self.getCSOption("BasePath", "/opt/dirac/storage/sandboxes"), total=True)
-
     ##################
     # Download sandboxes
 
@@ -415,7 +369,7 @@ class SandboxStoreHandlerMixin:
         # If the PFN starts with S3, we know it has been uploaded to the
         # S3 sandbox store, so download it from there before sending it
         if filePath.startswith("/S3"):
-            with TheImpersonator(credDict) as client:
+            with TheImpersonator(credDict, source="SandboxStore") as client:
                 res = client.jobs.get_sandbox_file(pfn=filePath)
                 r = requests.get(res.url)
                 r.raise_for_status()

DIRAC/WorkloadManagementSystem/Service/WMSAdministratorHandler.py

@@ -3,7 +3,6 @@ This is a DIRAC WMS administrator interface.
 """
 from DIRAC import S_ERROR, S_OK
 from DIRAC.ConfigurationSystem.Client.Helpers import Registry
-from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
 from DIRAC.Core.DISET.RequestHandler import RequestHandler
 from DIRAC.Core.Utilities.Decorators import deprecated
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
@@ -151,86 +150,24 @@ class WMSAdministratorHandlerMixin:
         :param str jobID: job ID
         :return: S_OK(dict)/S_ERROR()
         """
-        pilotReference = ""
-        # Get the pilot grid reference first from the job parameters
-
-        credDict = self.getRemoteCredentials()
-        vo = credDict.get("VO", Registry.getVOForGroup(credDict["group"]))
-        res = self.elasticJobParametersDB.getJobParameters(int(jobID), vo=vo, paramList=["Pilot_Reference"])
-        if not res["OK"]:
-            return res
-        if res["Value"].get(int(jobID)):
-            pilotReference = res["Value"][int(jobID)]["Pilot_Reference"]
-
-        if not pilotReference:
-            res = self.jobDB.getJobParameter(int(jobID), "Pilot_Reference")
-            if not res["OK"]:
-                return res
-            pilotReference = res["Value"]
-
-        if not pilotReference:
-            # Failed to get the pilot reference, try to look in the attic parameters
-            res = self.jobDB.getAtticJobParameters(int(jobID), ["Pilot_Reference"])
-            if res["OK"]:
-                c = -1
-                # Get the pilot reference for the last rescheduling cycle
-                for cycle in res["Value"]:
-                    if cycle > c:
-                        pilotReference = res["Value"][cycle]["Pilot_Reference"]
-                        c = cycle
-
-        if pilotReference:
-            return self.pilotManager.getPilotOutput(pilotReference)
-        return S_ERROR("No pilot job reference found")
+        result = self.pilotManager.getPilots(jobID)
 
-    ##############################################################################
-    types_getSiteSummaryWeb = [dict, list, int, int]
-
-    @classmethod
-    def export_getSiteSummaryWeb(cls, selectDict, sortList, startItem, maxItems):
-        """Get the summary of the jobs running on sites in a generic format
-
-        :param dict selectDict: selectors
-        :param list sortList: sorting list
-        :param int startItem: start item number
-        :param int maxItems: maximum of items
-
-        :return: S_OK(dict)/S_ERROR()
-        """
-        return cls.jobDB.getSiteSummaryWeb(selectDict, sortList, startItem, maxItems)
-
-    ##############################################################################
-    types_getSiteSummarySelectors = []
-
-    @classmethod
-    def export_getSiteSummarySelectors(cls):
-        """Get all the distinct selector values for the site summary web portal page
+        if not result["OK"]:
+            return result
+        pilotJobReferences = result["Value"].keys()
 
-        :return: S_OK(dict)/S_ERROR()
-        """
-        resultDict = {}
-        statusList = ["Good", "Fair", "Poor", "Bad", "Idle"]
-        resultDict["Status"] = statusList
-        maskStatus = ["Active", "Banned", "NoMask", "Reduced"]
-        resultDict["MaskStatus"] = maskStatus
-
-        res = getSites()
-        if not res["OK"]:
-            return res
-        siteList = res["Value"]
-
-        countryList = []
-        for site in siteList:
-            if site.find(".") != -1:
-                country = site.split(".")[2].lower()
-                if country not in countryList:
-                    countryList.append(country)
-        countryList.sort()
-        resultDict["Country"] = countryList
-        siteList.sort()
-        resultDict["Site"] = siteList
-
-        return S_OK(resultDict)
+        outputs = {"StdOut": "", "StdErr": ""}
+        for pilotRef in pilotJobReferences:
+            result = self.pilotManager.getPilotOutput(pilotRef)
+            if not result["OK"]:
+                stdout = f"Could not retrieve output: {result['Message']}"
+                error = f"Could not retrieve error: {result['Message']}"
+            else:
+                stdout, error = result["Value"]["StdOut"], result["Value"]["StdErr"]
+            outputs["StdOut"] += f"# PilotJobReference: {pilotRef}\n\n{stdout}\n"
+            outputs["StdErr"] += f"# PilotJobReference: {pilotRef}\n\n{error}\n"
+
+        return S_OK(outputs)
 
 
 class WMSAdministratorHandler(WMSAdministratorHandlerMixin, RequestHandler):

DIRAC/WorkloadManagementSystem/Service/WMSUtilities.py

@@ -121,24 +121,10 @@ def killPilotsInQueues(pilotRefDict):
             return result
         ce = result["Value"]
 
-        opsH = Operations(vo=vo)
-
-        pilotDN = opsH.getValue("Pilot/GenericPilotDN")
-        if not pilotDN:
-            owner = opsH.getValue("Pilot/GenericPilotUser")
-            res = getDNForUsername(owner)
-            if not res["OK"]:
-                return S_ERROR(f"Cannot get the generic pilot DN: {res['Message']}")
-            pilotDN = res["Value"][0]
-
-        pilotGroup = opsH.getValue("Pilot/GenericPilotGroup")
-        group = getGroupOption(pilotGroup, "VOMSRole")
-        ret = gProxyManager.getPilotProxyFromVOMSGroup(pilotDN, group)
-        if not ret["OK"]:
-            gLogger.error("Could not get proxy:", f"User '{pilotDN}' Group '{group}' : {ret['Message']}")
-            return S_ERROR("Failed to get the pilot's owner proxy")
-        proxy = ret["Value"]
-        ce.setProxy(proxy)
+        pilotDict["VO"] = vo
+        result = setPilotCredentials(ce, pilotDict)
+        if not result["OK"]:
+            return result
 
         pilotList = pilotDict["PilotList"]
         result = ce.killJob(pilotList)

DIRAC/WorkloadManagementSystem/Utilities/JobModel.py

@@ -1,219 +1,38 @@
-""" This module contains the JobModel class, which is used to validate the job description """
+from __future__ import annotations
 
-# pylint: disable=no-self-argument, no-self-use, invalid-name, missing-function-docstring
-
-from collections.abc import Iterable
-from typing import Any, Annotated, TypeAlias, Self
-
-from pydantic import BaseModel, BeforeValidator, model_validator, field_validator, ConfigDict
+from typing import ClassVar
+from pydantic import PrivateAttr
+from DIRACCommon.WorkloadManagementSystem.Utilities.JobModel import *  # noqa: F401, F403
 
 from DIRAC import gLogger
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
-from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getDIRACPlatforms, getSites
-
-
-# HACK: Convert appropriate iterables into sets
-def default_set_validator(value):
-    if value is None:
-        return set()
-    elif not isinstance(value, Iterable):
-        return value
-    elif isinstance(value, (str, bytes, bytearray)):
-        return value
-    else:
-        return set(value)
-
-
-CoercibleSetStr: TypeAlias = Annotated[set[str], BeforeValidator(default_set_validator)]
-
-
-class BaseJobDescriptionModel(BaseModel):
-    """Base model for the job description (not parametric)"""
-
-    model_config = ConfigDict(validate_assignment=True)
-
-    arguments: str = ""
-    bannedSites: CoercibleSetStr = set()
-    # TODO: This should use a field factory
-    cpuTime: int = Operations().getValue("JobDescription/DefaultCPUTime", 86400)
-    executable: str
-    executionEnvironment: dict = None
-    gridCE: str = ""
-    inputSandbox: CoercibleSetStr = set()
-    inputData: CoercibleSetStr = set()
-    inputDataPolicy: str = ""
-    jobConfigArgs: str = ""
-    jobGroup: str = ""
-    jobType: str = "User"
-    jobName: str = "Name"
-    # TODO: This should be an StrEnum
-    logLevel: str = "INFO"
-    # TODO: This can't be None with this type hint
-    maxNumberOfProcessors: int = None
-    minNumberOfProcessors: int = 1
-    outputData: CoercibleSetStr = set()
-    outputPath: str = ""
-    outputSandbox: CoercibleSetStr = set()
-    outputSE: str = ""
-    platform: str = ""
-    # TODO: This should use a field factory
-    priority: int = Operations().getValue("JobDescription/DefaultPriority", 1)
-    sites: CoercibleSetStr = set()
-    stderr: str = "std.err"
-    stdout: str = "std.out"
-    tags: CoercibleSetStr = set()
-    extraFields: dict[str, Any] = {}
-
-    @field_validator("cpuTime")
-    def checkCPUTimeBounds(cls, v):
-        minCPUTime = Operations().getValue("JobDescription/MinCPUTime", 100)
-        maxCPUTime = Operations().getValue("JobDescription/MaxCPUTime", 500000)
-        if not minCPUTime <= v <= maxCPUTime:
-            raise ValueError(f"cpuTime out of bounds (must be between {minCPUTime} and {maxCPUTime})")
-        return v
-
-    @field_validator("executable")
-    def checkExecutableIsNotAnEmptyString(cls, v: str):
-        if not v:
-            raise ValueError("executable must not be an empty string")
-        return v
-
-    @field_validator("jobType")
-    def checkJobTypeIsAllowed(cls, v: str):
-        jobTypes = Operations().getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
-        transformationTypes = Operations().getValue("Transformations/DataProcessing", [])
-        allowedTypes = jobTypes + transformationTypes
-        if v not in allowedTypes:
-            raise ValueError(f"jobType '{v}' is not allowed for this kind of user (must be in {allowedTypes})")
-        return v
-
-    @field_validator("inputData")
-    def checkInputDataDoesntContainDoubleSlashes(cls, v):
-        if v:
-            for lfn in v:
-                if lfn.find("//") > -1:
-                    raise ValueError("Input data contains //")
-        return v
-
-    @field_validator("inputData")
-    def addLFNPrefixIfStringStartsWithASlash(cls, v: set[str]):
-        if v:
-            v = {lfn.strip() for lfn in v if lfn.strip()}
-            v = {f"LFN:{lfn}" if lfn.startswith("/") else lfn for lfn in v}
-
-            for lfn in v:
-                if not lfn.startswith("LFN:/"):
-                    raise ValueError("Input data files must start with LFN:/")
-        return v
-
-    @model_validator(mode="after")
-    def checkNumberOfInputDataFiles(self) -> Self:
-        if self.inputData:
-            maxInputDataFiles = Operations().getValue("JobDescription/MaxInputData", 500)
-            if self.jobType == "User" and len(self.inputData) >= maxInputDataFiles:
-                raise ValueError(f"inputData contains too many files (must contain at most {maxInputDataFiles})")
-        return self
-
-    @field_validator("inputSandbox")
-    def checkLFNSandboxesAreWellFormated(cls, v: set[str]):
-        for inputSandbox in v:
-            if inputSandbox.startswith("LFN:") and not inputSandbox.startswith("LFN:/"):
-                raise ValueError("LFN files must start by LFN:/")
-        return v
-
-    @field_validator("logLevel")
-    def checkLogLevelIsValid(cls, v: str):
-        v = v.upper()
-        possibleLogLevels = gLogger.getAllPossibleLevels()
-        if v not in possibleLogLevels:
-            raise ValueError(f"Log level {v} not in {possibleLogLevels}")
-        return v
-
-    @field_validator("minNumberOfProcessors")
-    def checkMinNumberOfProcessorsBounds(cls, v):
-        minNumberOfProcessors = Operations().getValue("JobDescription/MinNumberOfProcessors", 1)
-        maxNumberOfProcessors = Operations().getValue("JobDescription/MaxNumberOfProcessors", 1024)
-        if not minNumberOfProcessors <= v <= maxNumberOfProcessors:
-            raise ValueError(
-                f"minNumberOfProcessors out of bounds (must be between {minNumberOfProcessors} and {maxNumberOfProcessors})"
-            )
-        return v
-
-    @field_validator("maxNumberOfProcessors")
-    def checkMaxNumberOfProcessorsBounds(cls, v):
-        minNumberOfProcessors = Operations().getValue("JobDescription/MinNumberOfProcessors", 1)
-        maxNumberOfProcessors = Operations().getValue("JobDescription/MaxNumberOfProcessors", 1024)
-        if not minNumberOfProcessors <= v <= maxNumberOfProcessors:
-            raise ValueError(
-                f"minNumberOfProcessors out of bounds (must be between {minNumberOfProcessors} and {maxNumberOfProcessors})"
-            )
-        return v
-
-    @model_validator(mode="after")
-    def checkThatMaxNumberOfProcessorsIsGreaterThanMinNumberOfProcessors(self) -> Self:
-        if self.maxNumberOfProcessors:
-            if self.maxNumberOfProcessors < self.minNumberOfProcessors:
-                raise ValueError("maxNumberOfProcessors must be greater than minNumberOfProcessors")
-        return self
-
-    @model_validator(mode="after")
-    def addTagsDependingOnNumberOfProcessors(self) -> Self:
-        if self.minNumberOfProcessors == self.maxNumberOfProcessors:
-            self.tags.add(f"{self.minNumberOfProcessors}Processors")
-        if self.minNumberOfProcessors > 1:
-            self.tags.add("MultiProcessor")
-        return self
-
-    @field_validator("sites")
-    def checkSites(cls, v: set[str]):
-        if v:
-            res = getSites()
-            if not res["OK"]:
-                raise ValueError(res["Message"])
-            invalidSites = v - set(res["Value"]).union({"ANY"})
-            if invalidSites:
-                raise ValueError(f"Invalid sites: {' '.join(invalidSites)}")
-        return v
+from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
 
-    @model_validator(mode="after")
-    def checkThatSitesAndBannedSitesAreNotMutuallyExclusive(self) -> Self:
-        if self.sites and self.bannedSites:
-            while self.bannedSites:
-                self.sites.discard(self.bannedSites.pop())
-            if not self.sites:
-                raise ValueError("sites and bannedSites are mutually exclusive")
-        return self
 
-    @field_validator("platform")
-    def checkPlatform(cls, v: str):
-        if v:
-            res = getDIRACPlatforms()
-            if not res["OK"]:
-                raise ValueError(res["Message"])
-            if v not in res["Value"]:
-                raise ValueError("Invalid platform")
-        return v
+def _make_model_config(cls=None) -> BaseJobDescriptionModelConfg:
+    from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 
-    @field_validator("priority")
-    def checkPriorityBounds(cls, v):
-        minPriority = Operations().getValue("JobDescription/MinPriority", 0)
-        maxPriority = Operations().getValue("JobDescription/MaxPriority", 10)
-        if not minPriority <= v <= maxPriority:
-            raise ValueError(f"priority out of bounds (must be between {minPriority} and {maxPriority})")
-        return v
+    ops = Operations()
+    allowedJobTypes = ops.getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
+    allowedJobTypes += ops.getValue("Transformations/DataProcessing", [])
+    return {
+        "cpuTime": ops.getValue("JobDescription/DefaultCPUTime", 86400),
+        "priority": ops.getValue("JobDescription/DefaultPriority", 1),
+        "minCPUTime": ops.getValue("JobDescription/MinCPUTime", 100),
+        "maxCPUTime": ops.getValue("JobDescription/MaxCPUTime", 500000),
+        "allowedJobTypes": allowedJobTypes,
+        "maxInputDataFiles": ops.getValue("JobDescription/MaxInputData", 500),
+        "minNumberOfProcessors": ops.getValue("JobDescription/MinNumberOfProcessors", 1),
+        "maxNumberOfProcessors": ops.getValue("JobDescription/MaxNumberOfProcessors", 1024),
+        "minPriority": ops.getValue("JobDescription/MinPriority", 0),
+        "maxPriority": ops.getValue("JobDescription/MaxPriority", 10),
+        "possibleLogLevels": gLogger.getAllPossibleLevels(),
+        "sites": getSites(),
+    }
 
 
-class JobDescriptionModel(BaseJobDescriptionModel):
-    """Model for the job description (non parametric job with user credentials, i.e server side)"""
+class BaseJobDescriptionModel(BaseJobDescriptionModel):  # noqa: F405 pylint: disable=function-redefined
+    _config_builder: ClassVar = _make_model_config
 
-    owner: str
-    ownerGroup: str
-    vo: str
 
-    @model_validator(mode="after")
-    def checkLFNMatchesREGEX(self) -> Self:
-        if self.inputData:
-            for lfn in self.inputData:
-                if not lfn.startswith(f"LFN:/{self.vo}/"):
-                    raise ValueError(f"Input data not correctly specified (must start with LFN:/{self.vo}/)")
-        return self
+class JobDescriptionModel(JobDescriptionModel):  # noqa: F405 pylint: disable=function-redefined
+    _config_builder: ClassVar = _make_model_config

DIRAC/WorkloadManagementSystem/Utilities/JobParameters.py

@@ -1,8 +1,8 @@
-""" DIRAC Workload Management System utility module to get available memory and processors
-"""
+"""DIRAC Workload Management System utility module to get available memory and processors"""
+
 import multiprocessing
 
-from DIRAC import gConfig, gLogger
+from DIRAC import S_OK, gConfig, gLogger
 from DIRAC.Core.Utilities.List import fromChar
 
 
@@ -139,3 +139,65 @@ def getNumberOfGPUs(siteName=None, gridCE=None, queue=None):
     # 3) return 0
     gLogger.info("NumberOfGPUs could not be found in CS")
     return 0
+
+
+def getJobParameters(jobIDs: list[int], parName: str | None, vo: str = "") -> dict:
+    """Utility to get a job parameter for a list of jobIDs pertaining to a VO.
+    If the jobID is not in the JobParametersDB, it will be looked up in the JobDB.
+
+    Requires direct access to the JobParametersDB and JobDB.
+
+    :param jobIDs: list of jobIDs
+    :param parName: name of the parameter to be retrieved
+    :param vo: VO of the jobIDs
+    :return: dictionary with jobID as key and the parameter as value
+    :rtype: dict
+    """
+    from DIRAC.WorkloadManagementSystem.DB.JobParametersDB import JobParametersDB
+    from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
+
+    elasticJobParametersDB = JobParametersDB()
+    jobDB = JobDB()
+
+    if vo:  # a user is connecting, with a proxy
+        res = elasticJobParametersDB.getJobParameters(jobIDs, vo, parName)
+        if not res["OK"]:
+            return res
+        parameters = res["Value"]
+    else:  # a service is connecting, no proxy, e.g. StalledJobAgent
+        q = f"SELECT JobID, VO FROM Jobs WHERE JobID IN ({','.join([str(jobID) for jobID in jobIDs])})"
+        res = jobDB._query(q)
+        if not res["OK"]:
+            return res
+        if not res["Value"]:
+            return S_OK({})
+        # get the VO for each jobID
+        voDict = {}
+        for jobID, vo in res["Value"]:
+            if vo not in voDict:
+                voDict[vo] = []
+            voDict[vo].append(jobID)
+        # get the parameters for each VO
+        parameters = {}
+        for vo, jobIDs in voDict.items():
+            res = elasticJobParametersDB.getJobParameters(jobIDs, vo, parName)
+            if not res["OK"]:
+                return res
+            parameters.update(res["Value"])
+
+    # Need anyway to get also from JobDB, for those jobs with parameters registered in MySQL or in both backends
+    res = jobDB.getJobParameters(jobIDs, parName)
+    if not res["OK"]:
+        return res
+    parametersM = res["Value"]
+
+    # and now combine
+    final = dict(parametersM)
+    # if job in JobDB, update with parameters from ES if any
+    for jobID in final:
+        final[jobID].update(parameters.get(jobID, {}))
+    # if job in ES and not in JobDB, take ES
+    for jobID in parameters:
+        if jobID not in final:
+            final[jobID] = parameters[jobID]
+    return S_OK(final)

DIRAC/WorkloadManagementSystem/Utilities/JobStatusUtility.py

@@ -9,10 +9,11 @@ from DIRAC import S_ERROR, S_OK, gLogger
 from DIRAC.Core.Utilities import TimeUtilities
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
 from DIRAC.WorkloadManagementSystem.Client import JobStatus
+from DIRACCommon.WorkloadManagementSystem.Utilities.JobStatusUtility import getStartAndEndTime, getNewStatus
 
 if TYPE_CHECKING:
-    from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
     from DIRAC.WorkloadManagementSystem.DB.JobLoggingDB import JobLoggingDB
+    from DIRAC.WorkloadManagementSystem.DB.JobDB import JobDB
 
 
 class JobStatusUtility:
@@ -180,66 +181,3 @@ class JobStatusUtility:
                 return result
 
         return S_OK((attrNames, attrValues))
-
-
-def getStartAndEndTime(startTime, endTime, updateTimes, timeStamps, statusDict):
-    newStat = ""
-    firstUpdate = TimeUtilities.toEpoch(TimeUtilities.fromString(updateTimes[0]))
-    for ts, st in timeStamps:
-        if firstUpdate >= ts:
-            newStat = st
-    # Pick up start and end times from all updates
-    for updTime in updateTimes:
-        sDict = statusDict[updTime]
-        newStat = sDict.get("Status", newStat)
-
-        if not startTime and newStat == JobStatus.RUNNING:
-            # Pick up the start date when the job starts running if not existing
-            startTime = updTime
-        elif not endTime and newStat in JobStatus.JOB_FINAL_STATES:
-            # Pick up the end time when the job is in a final status
-            endTime = updTime
-
-    return startTime, endTime
-
-
-def getNewStatus(
-    jobID: int,
-    updateTimes: list[datetime],
-    lastTime: datetime,
-    statusDict: dict[datetime, Any],
-    currentStatus,
-    force: bool,
-    log,
-):
-    status = ""
-    minor = ""
-    application = ""
-    # Get the last status values looping on the most recent upupdateTimes in chronological order
-    for updTime in [dt for dt in updateTimes if dt >= lastTime]:
-        sDict = statusDict[updTime]
-        log.debug(f"\tTime {updTime} - Statuses {str(sDict)}")
-        status = sDict.get("Status", currentStatus)
-        # evaluate the state machine if the status is changing
-        if not force and status != currentStatus:
-            res = JobStatus.JobsStateMachine(currentStatus).getNextState(status)
-            if not res["OK"]:
-                return res
-            newStat = res["Value"]
-            # If the JobsStateMachine does not accept the candidate, don't update
-            if newStat != status:
-                # keeping the same status
-                log.error(
-                    f"Job Status Error: {jobID} can't move from {currentStatus} to {status}: using {newStat}",
-                )
-                status = newStat
-                sDict["Status"] = newStat
-                # Change the source to indicate this is not what was requested
-                source = sDict.get("Source", "")
-                sDict["Source"] = source + "(SM)"
-            # at this stage status == newStat. Set currentStatus to this new status
-            currentStatus = newStat
-
-        minor = sDict.get("MinorStatus", minor)
-        application = sDict.get("ApplicationStatus", application)
-    return S_OK((status, minor, application))