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

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/JobWrapper/JobWrapper.py

@@ -55,6 +55,8 @@ from DIRAC.WorkloadManagementSystem.Client.JobStateUpdateClient import JobStateU
 from DIRAC.WorkloadManagementSystem.Client.SandboxStoreClient import SandboxStoreClient
 from DIRAC.WorkloadManagementSystem.JobWrapper.Watchdog import Watchdog
 
+CHILD_PID_POLL_INTERVALS = list(range(5, 40, 5))
+
 
 class JobWrapper:
     """The only user of the JobWrapper is the JobWrapperTemplate"""
@@ -430,14 +432,14 @@ class JobWrapper:
             )
             exeThread.start()
             payloadPID = None
-            for seconds in range(5, 40, 5):
+            for seconds in CHILD_PID_POLL_INTERVALS:
                 time.sleep(seconds)
                 payloadPID = spObject.getChildPID()
                 if payloadPID:
                     self.__setJobParam("PayloadPID", payloadPID)
                     break
             if not payloadPID:
-                return S_ERROR("Payload process could not start after 140 seconds")
+                return S_ERROR(f"Payload process could not start after {sum(CHILD_PID_POLL_INTERVALS)} seconds")
 
             watchdog = Watchdog(
                 pid=self.currentPID,

DIRAC/WorkloadManagementSystem/JobWrapper/test/Test_JobWrapper.py

@@ -344,24 +344,40 @@ def test_processQuickExecutionNoWatchdog(mocker):
 
 
 @pytest.mark.slow
-def test_processSubprocessFailureNoPid(mocker):
-    """Test the process method of the JobWrapper class: the subprocess fails and no PID is returned."""
+@pytest.mark.parametrize("expect_failure", [True, False])
+def test_processSubprocessFailureNoPid(mocker, monkeypatch, expect_failure):
+    """Test the process method of the JobWrapper class: the subprocess fails and no PID is returned.
+
+    expect_failure is used to ensure that the JobWrapper is functioning correctly even with the other patching
+    that is applied in the test (e.g. CHILD_PID_POLL_INTERVALS).
+    """
     # Test failure in starting the payload process
     jw = JobWrapper()
     jw.jobArgs = {}
 
     mocker.patch.object(jw, "_JobWrapper__report")
     mocker.patch.object(jw, "_JobWrapper__setJobParam")
+    monkeypatch.setattr(
+        "DIRAC.WorkloadManagementSystem.JobWrapper.JobWrapper.CHILD_PID_POLL_INTERVALS", [0.1, 0.2, 0.3, 0.4, 0.5]
+    )
+
     mock_exeThread = mocker.Mock()
     mock_exeThread.start.side_effect = lambda: time.sleep(0.1)
-    mocker.patch("DIRAC.WorkloadManagementSystem.JobWrapper.JobWrapper.ExecutionThread", return_value=mock_exeThread)
+    if expect_failure:
+        mocker.patch(
+            "DIRAC.WorkloadManagementSystem.JobWrapper.JobWrapper.ExecutionThread", return_value=mock_exeThread
+        )
 
     with tempfile.NamedTemporaryFile(delete=True) as std_out, tempfile.NamedTemporaryFile(delete=True) as std_err:
         jw.outputFile = std_out.name
         jw.errorFile = std_err.name
         result = jw.process(command="mock_command", env={})
-    assert not result["OK"]
-    assert "Payload process could not start after 140 seconds" in result["Message"]
+
+    if expect_failure:
+        assert not result["OK"]
+        assert "Payload process could not start after 1.5 seconds" in result["Message"]
+    else:
+        assert result["OK"]
 
 
 # -------------------------------------------------------------------------------------------------

DIRAC/WorkloadManagementSystem/JobWrapper/test/Test_JobWrapperTemplate.py

@@ -72,6 +72,7 @@ def extraOptions():
     os.remove(extraOptions)
 
 
+@pytest.mark.slow
 def test_createAndExecuteJobWrapperTemplate_success(extraOptions):
     """Test the creation of a classical job wrapper and its execution:
     There is an extra option cfg file to be passed to the job wrapper.
@@ -144,6 +145,7 @@ def test_createAndExecuteJobWrapperTemplate_success(extraOptions):
     shutil.rmtree(os.path.join(os.getcwd(), "job"))
 
 
+@pytest.mark.slow
 def test_createAndExecuteJobWrapperTemplate_missingExtraOptions():
     """Test the creation of a classical job wrapper and its execution:
     There is no extra options to be passed to the job wrapper.
@@ -205,6 +207,7 @@ def test_createAndExecuteJobWrapperTemplate_missingExtraOptions():
     shutil.rmtree(os.path.join(os.getcwd(), "job"))
 
 
+@pytest.mark.slow
 def test_createAndExecuteRelocatedJobWrapperTemplate_success(extraOptions):
     """Test the creation of a relocated job wrapper and its execution:
     This is generally used when containers are involved (SingularityCE).
@@ -325,6 +328,7 @@ def test_createAndExecuteRelocatedJobWrapperTemplate_success(extraOptions):
     shutil.rmtree(wrapperPath)
 
 
+@pytest.mark.slow
 def test_createAndExecuteJobWrapperOfflineTemplate_success(extraOptions):
     """Test the creation of an offline job wrapper and its execution:
     This is generally used when pre/post processing operations are executed locally,

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/JobModel.py

@@ -1,209 +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
+from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
 
-    @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
 
-    @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
+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/JobStatusUtility.py

@@ -9,6 +9,7 @@ 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.JobLoggingDB import JobLoggingDB
@@ -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))