lsst-ctrl-bps-htcondor 29.2025.4100__tar.gz → 29.2025.4300__tar.gz

{lsst_ctrl_bps_htcondor-29.2025.4100/python/lsst_ctrl_bps_htcondor.egg-info → lsst_ctrl_bps_htcondor-29.2025.4300}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps-htcondor
-Version: 29.2025.4100
+Version: 29.2025.4300
 Summary: HTCondor plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/python/lsst/ctrl/bps/htcondor/common_utils.py

@@ -115,7 +115,10 @@ def _htc_job_status_to_wms_state(job):
         elif job_status == htcondor.JobStatus.RUNNING:
             wms_state = WmsStates.RUNNING
         elif job_status == htcondor.JobStatus.REMOVED:
-            wms_state = WmsStates.DELETED
+            if (job.get("ExitBySignal", False) and job.get("ExitSignal", 0)) or job.get("ExitCode", 0):
+                wms_state = WmsStates.FAILED
+            else:
+                wms_state = WmsStates.DELETED
         elif job_status == htcondor.JobStatus.COMPLETED:
             if (
                 (job.get("ExitBySignal", False) and job.get("ExitSignal", 0))

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/python/lsst/ctrl/bps/htcondor/handlers.py

@@ -31,6 +31,8 @@ __all__ = [
     "HTC_JOB_AD_HANDLERS",
     "Chain",
     "Handler",
+    "JobAbortedByPeriodicRemoveHandler",
+    "JobAbortedByUserHandler",
     "JobCompletedWithExecTicketHandler",
     "JobCompletedWithoutExecTicketHandler",
     "JobHeldByOtherHandler",
@@ -43,7 +45,7 @@ import abc
 import logging
 import re
 from collections.abc import Sequence
-from typing import Any
+from typing import Any, overload
 
 _LOG = logging.getLogger(__name__)
 
@@ -84,13 +86,17 @@ class Chain(Sequence):
         List of handlers that will be used to initialize the chain.
     """
 
-    def __init__(self, handlers: Sequence[Handler] = None) -> None:
-        self._handlers = []
+    def __init__(self, handlers: Sequence[Handler] | None = None) -> None:
+        self._handlers: list[Handler] = []
         if handlers is not None:
             for handler in handlers:
                 self.append(handler)
 
-    def __getitem__(self, index: int) -> Handler:
+    @overload
+    def __getitem__(self, index: int) -> Handler: ...
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[Handler]: ...
+    def __getitem__(self, index):
         return self._handlers[index]
 
     def __len__(self) -> int:
@@ -207,7 +213,7 @@ class JobCompletedWithoutExecTicketHandler(Handler):
                 ad["ExitCode"] = ad["ReturnValue"]
         else:
             _LOG.debug(
-                "%s: refusing to process the ad for the job '%s.%s': ticket of execution found",
+                "Handler %s: refusing to process the ad for the job '%s.%s': ticket of execution found",
                 self.__class__.__name__,
                 ad["ClusterId"],
                 ad["ProcId"],
@@ -314,7 +320,98 @@ class JobHeldByUserHandler(Handler):
         return ad
 
 
+class JobAbortedByPeriodicRemoveHandler(Handler):
+    """Handler of ClassAds for jobs deleted by periodic remove policy."""
+
+    def handle(self, ad: dict[str, Any]) -> dict[str, Any] | None:
+        if not ad["MyType"].endswith("AbortedEvent"):
+            _LOG.debug(
+                "Handler '%s': refusing to process the ad for the job '%s.%s': job not removed",
+                self.__class__.__name__,
+                ad["ClusterId"],
+                ad["ProcId"],
+            )
+            return None
+        if "Reason" in ad:
+            if "PeriodicRemove" in ad["Reason"]:
+                ad["ExitBySignal"] = True
+
+                ad["ExitSignal"] = -1
+                if "HoldReason" in ad:
+                    match = re.search(r"signal (\d+)", ad["HoldReason"])
+                    if match is not None:
+                        ad["ExitSignal"] = int(match.group(1))
+
+            else:
+                _LOG.debug(
+                    "Handler '%s': refusing to process the ad for the job '%s.%s': "
+                    "job was not removed by the periodic removal policy: Reason = %s",
+                    self.__class__.__name__,
+                    ad["ClusterId"],
+                    ad["ProcId"],
+                    ad["Reason"],
+                )
+                return None
+        else:
+            _LOG.debug(
+                "Handler '%s': refusing to process the ad for the job '%s.%s': "
+                "unable to determine the reason for the removal.",
+                self.__class__.__name__,
+                ad["ClusterId"],
+                ad["ProcId"],
+            )
+            return None
+        return ad
+
+
+class JobAbortedByUserHandler(Handler):
+    """Handler of ClassAds for jobs deleted by the user."""
+
+    def handle(self, ad: dict[str, Any]) -> dict[str, Any] | None:
+        if not ad["MyType"].endswith("AbortedEvent"):
+            _LOG.debug(
+                "Handler '%s': refusing to process the ad for the job '%s.%s': job not removed",
+                self.__class__.__name__,
+                ad["ClusterId"],
+                ad["ProcId"],
+            )
+            return None
+        if "Reason" in ad:
+            patterns = (
+                "Python-initiated action",  # DAGMan job removed by the user
+                "DAG Removed",  # payload job removed by the user
+                "OtherJobRemoveRequirements",  # a subdag job removed by the user
+            )
+            for patt in patterns:
+                if patt in ad["Reason"]:
+                    ad["ExitBySignal"] = False
+                    ad["ExitCode"] = 0
+                    break
+            else:
+                _LOG.debug(
+                    "Handler '%s': refusing to process the ad for the job '%s.%s': "
+                    "job not removed by the user: Reason = %s",
+                    self.__class__.__name__,
+                    ad["ClusterId"],
+                    ad["ProcId"],
+                    ad["Reason"],
+                )
+                return None
+        else:
+            _LOG.debug(
+                "Handler '%s': refusing to process the ad for the job '%s.%s': "
+                "unable to determine the reason for the removal.",
+                self.__class__.__name__,
+                ad["ClusterId"],
+                ad["ProcId"],
+            )
+            return None
+        return ad
+
+
 _handlers = [
+    JobAbortedByPeriodicRemoveHandler(),
+    JobAbortedByUserHandler(),
     JobHeldByUserHandler(),
     JobHeldBySignalHandler(),
     JobHeldByOtherHandler(),

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/python/lsst/ctrl/bps/htcondor/lssthtc.py

@@ -54,6 +54,7 @@ __all__ = [
     "htc_query_history",
     "htc_query_present",
     "htc_submit_dag",
+    "htc_tweak_log_info",
     "htc_version",
     "htc_write_attribs",
     "htc_write_condor_file",
@@ -1890,8 +1891,6 @@ def read_single_dag_log(log_filename: str | os.PathLike) -> tuple[str, dict[str,
 
         # only save latest DAG job
         dag_info = {wms_workflow_id: info[wms_workflow_id]}
-        for job in dag_info.values():
-            _tweak_log_info(filename, job)
 
     return wms_workflow_id, dag_info
 
@@ -1992,10 +1991,6 @@ def read_single_dag_nodes_log(filename: str | os.PathLike) -> dict[str, dict[str
                 _update_dicts(info[id_], event)
                 info[id_][f"{event.type.name.lower()}_time"] = event["EventTime"]
 
-    # Add more condor_q-like info to info parsed from log file.
-    for job in info.values():
-        _tweak_log_info(filename, job)
-
     return info
 
 
@@ -2091,60 +2086,69 @@ def write_dag_info(filename, dag_info):
         _LOG.debug("Persisting DAGMan job information failed: %s", exc)
 
 
-def _tweak_log_info(filename, job):
+def htc_tweak_log_info(wms_path: str | Path, job: dict[str, Any]) -> None:
     """Massage the given job info has same structure as if came from condor_q.
 
     Parameters
     ----------
-    filename : `pathlib.Path`
-        Name of the DAGMan log.
+    wms_path : `str` | `os.PathLike`
+        Path containing an HTCondor event log file.
     job : `dict` [ `str`, `~typing.Any` ]
         A mapping between HTCondor job id and job information read from
         the log.
     """
-    _LOG.debug("_tweak_log_info: %s %s", filename, job)
+    _LOG.debug("htc_tweak_log_info: %s %s", wms_path, job)
+
+    # Use the presence of 'MyType' key as a proxy to determine if the job ad
+    # contains the info extracted from the event log. Exit early if it doesn't
+    # (e.g. it is a job ad for a pruned job).
+    if "MyType" not in job:
+        return
 
     try:
         job["ClusterId"] = job["Cluster"]
         job["ProcId"] = job["Proc"]
-        job["Iwd"] = str(filename.parent)
-        job["Owner"] = filename.owner()
-
-        match job["MyType"]:
-            case "ExecuteEvent":
-                job["JobStatus"] = htcondor.JobStatus.RUNNING
-            case "JobTerminatedEvent" | "PostScriptTerminatedEvent":
-                job["JobStatus"] = htcondor.JobStatus.COMPLETED
-            case "SubmitEvent":
-                job["JobStatus"] = htcondor.JobStatus.IDLE
-            case "JobAbortedEvent":
-                job["JobStatus"] = htcondor.JobStatus.REMOVED
-            case "JobHeldEvent":
-                job["JobStatus"] = htcondor.JobStatus.HELD
-            case "JobReleaseEvent":
-                # Shows up as last event if a DAG job was held and released
-                # so assume job is running.  If regular job is released, there
-                # will be other events so JobReleaseEvent won't be the last
-                job["JobStatus"] = htcondor.JobStatus.RUNNING
-            case _:
-                _LOG.debug("Unknown log event type: %s", job["MyType"])
-                job["JobStatus"] = None
-
-        if job["JobStatus"] in {htcondor.JobStatus.COMPLETED, htcondor.JobStatus.HELD}:
-            new_job = HTC_JOB_AD_HANDLERS.handle(job)
-            if new_job is not None:
-                job = new_job
-            else:
-                _LOG.error("Could not determine exit status for job '%s.%s'", job["ClusterId"], job["ProcId"])
-
-        if "LogNotes" in job:
-            m = re.match(r"DAG Node: (\S+)", job["LogNotes"])
-            if m:
-                job["DAGNodeName"] = m.group(1)
-
     except KeyError as e:
         _LOG.error("Missing key %s in job: %s", str(e), job)
         raise
+    job["Iwd"] = str(wms_path)
+    job["Owner"] = Path(wms_path).owner()
+
+    match job["MyType"]:
+        case "ExecuteEvent":
+            job["JobStatus"] = htcondor.JobStatus.RUNNING
+        case "JobTerminatedEvent" | "PostScriptTerminatedEvent":
+            job["JobStatus"] = htcondor.JobStatus.COMPLETED
+        case "SubmitEvent":
+            job["JobStatus"] = htcondor.JobStatus.IDLE
+        case "JobAbortedEvent":
+            job["JobStatus"] = htcondor.JobStatus.REMOVED
+        case "JobHeldEvent":
+            job["JobStatus"] = htcondor.JobStatus.HELD
+        case "JobReleaseEvent":
+            # Shows up as the last event if a DAG job was held and released,
+            # so assume the job is running.  If a regular job is released,
+            # there will be other events, so JobReleaseEvent won't be the last.
+            job["JobStatus"] = htcondor.JobStatus.RUNNING
+        case _:
+            _LOG.debug("Unknown log event type: %s", job["MyType"])
+            job["JobStatus"] = None
+
+    if job["JobStatus"] in {
+        htcondor.JobStatus.COMPLETED,
+        htcondor.JobStatus.HELD,
+        htcondor.JobStatus.REMOVED,
+    }:
+        new_job = HTC_JOB_AD_HANDLERS.handle(job)
+        if new_job is not None:
+            job = new_job
+        else:
+            _LOG.error("Could not determine exit status for job '%s.%s'", job["ClusterId"], job["ProcId"])
+
+    if "LogNotes" in job:
+        m = re.match(r"DAG Node: (\S+)", job["LogNotes"])
+        if m:
+            job["DAGNodeName"] = m.group(1)
 
 
 def htc_check_dagman_output(wms_path: str | os.PathLike) -> str:

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/python/lsst/ctrl/bps/htcondor/report_utils.py

@@ -48,6 +48,7 @@ from .lssthtc import (
     WmsNodeType,
     condor_search,
     htc_check_dagman_output,
+    htc_tweak_log_info,
     pegasus_name_to_label,
     read_dag_info,
     read_dag_log,
@@ -125,6 +126,7 @@ def _get_status_from_path(wms_path: str | os.PathLike) -> tuple[WmsStates, str]:
     if wms_workflow_id == MISSING_ID:
         state = WmsStates.UNKNOWN
     else:
+        htc_tweak_log_info(wms_path, dag_ad[wms_workflow_id])
         state = _htc_status_to_wms_state(dag_ad[wms_workflow_id])
 
     return state, message
@@ -363,6 +365,10 @@ def _get_info_from_path(wms_path: str | os.PathLike) -> tuple[str, dict[str, dic
         wms_workflow_id = MISSING_ID
         jobs = {}
 
+    # Add more condor_q-like info.
+    for job in jobs.values():
+        htc_tweak_log_info(wms_path, job)
+
     message = "\n".join([msg for msg in messages if msg])
     _LOG.debug("wms_workflow_id = %s, jobs = %s", wms_workflow_id, jobs.keys())
     _LOG.debug("message = %s", message)
@@ -692,12 +698,11 @@ def _get_exit_code_summary(jobs):
             exit_code = 0
             job_status = job_ad["JobStatus"]
             match job_status:
-                case htcondor.JobStatus.COMPLETED | htcondor.JobStatus.HELD:
+                case htcondor.JobStatus.COMPLETED | htcondor.JobStatus.HELD | htcondor.JobStatus.REMOVED:
                     exit_code = job_ad["ExitSignal"] if job_ad["ExitBySignal"] else job_ad["ExitCode"]
                 case (
                     htcondor.JobStatus.IDLE
                     | htcondor.JobStatus.RUNNING
-                    | htcondor.JobStatus.REMOVED
                     | htcondor.JobStatus.TRANSFERRING_OUTPUT
                     | htcondor.JobStatus.SUSPENDED
                 ):

lsst_ctrl_bps_htcondor-29.2025.4300/python/lsst/ctrl/bps/htcondor/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.4300"

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300/python/lsst_ctrl_bps_htcondor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps-htcondor
-Version: 29.2025.4100
+Version: 29.2025.4300
 Summary: HTCondor plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/tests/test_handlers.py

@@ -34,6 +34,8 @@ from typing import Any
 from lsst.ctrl.bps.htcondor.handlers import (
     Chain,
     Handler,
+    JobAbortedByPeriodicRemoveHandler,
+    JobAbortedByUserHandler,
     JobCompletedWithExecTicketHandler,
     JobCompletedWithoutExecTicketHandler,
     JobHeldByOtherHandler,
@@ -296,3 +298,122 @@ class JobHeldByUserHandlerTestCase(unittest.TestCase):
             result = self.handler.handle(ad)
         self.assertIsNone(result)
         self.assertIn("job not held", cm.output[0])
+
+
+class JobAbortedByPeriodicRemoveHandlerTestCase(unittest.TestCase):
+    """Test the handler for jobs deleted by periodic removal policy."""
+
+    def setUp(self):
+        self.ad = {
+            "ClusterId": 1,
+            "ProcId": 0,
+            "MyType": "JobAbortedEvent",
+            "Reason": "The job attribute PeriodicRemove expression 'foo' evaluated to TRUE",
+        }
+        self.handler = JobAbortedByPeriodicRemoveHandler()
+
+    def tearDown(self):
+        pass
+
+    def testHandling(self):
+        self.ad |= {"HoldReason": "Job raised a signal 9."}
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertTrue(result["ExitBySignal"])
+        self.assertIn("ExitSignal", result)
+        self.assertEqual(result["ExitSignal"], 9)
+
+    def testHandlingWithHoldReasonNoExitSignal(self):
+        self.ad |= {"HoldReason": "Job raised a signal."}
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertTrue(result["ExitBySignal"])
+        self.assertIn("ExitSignal", result)
+        self.assertEqual(result["ExitSignal"], -1)
+
+    def testHandlingWithoutHoldReason(self):
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertTrue(result["ExitBySignal"])
+        self.assertIn("ExitSignal", result)
+        self.assertEqual(result["ExitSignal"], -1)
+
+    def testNotHandlingJobNotRemoved(self):
+        self.ad["MyType"] = "foo"
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("job not removed", cm.output[0])
+
+    def testNotHandlingJobNotRemovedByPeriodicRemoval(self):
+        self.ad["Reason"] = "DAG Abort"
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("not removed by the periodic removal policy", cm.output[0])
+
+    def testNotHandlingNoReason(self):
+        del self.ad["Reason"]
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("unable to determine the reason", cm.output[0])
+
+
+class JobAbortedByUserHandlerTestCase(unittest.TestCase):
+    """Test the handler for jobs deleted by the user."""
+
+    def setUp(self):
+        self.ad = {
+            "ClusterId": 1,
+            "ProcId": 0,
+            "MyType": "JobAbortedEvent",
+        }
+        self.handler = JobAbortedByUserHandler()
+
+    def tearDown(self):
+        pass
+
+    def testHandlingAbortedDagmanJob(self):
+        self.ad |= {"Reason": "Python-initiated action"}
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertFalse(result["ExitBySignal"])
+        self.assertIn("ExitCode", result)
+        self.assertEqual(result["ExitCode"], 0)
+
+    def testHandlingAbortedPayloadJob(self):
+        self.ad |= {"Reason": "DAG Removed"}
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertFalse(result["ExitBySignal"])
+        self.assertIn("ExitCode", result)
+        self.assertEqual(result["ExitCode"], 0)
+
+    def testHandlingAbortedSubdagJob(self):
+        self.ad |= {"Reason": "OtherJobRemoveRequirements = DAGManJobId =?= 78"}
+        result = self.handler.handle(self.ad)
+        self.assertIn("ExitBySignal", result)
+        self.assertFalse(result["ExitBySignal"])
+        self.assertIn("ExitCode", result)
+        self.assertEqual(result["ExitCode"], 0)
+
+    def testNotHandlingJobNotRemoved(self):
+        self.ad["MyType"] = "foo"
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("job not removed", cm.output[0])
+
+    def testNotHandlingJobNotRemovedByUser(self):
+        self.ad |= {"Reason": "The job attribute PeriodicRemove expression 'foo' evaluated to TRUE"}
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("job not removed", cm.output[0])
+
+    def testNotHandlingNoReason(self):
+        with self.assertLogs(logger=logger, level="DEBUG") as cm:
+            result = self.handler.handle(self.ad)
+        self.assertIsNone(result)
+        self.assertIn("unable to determine the reason", cm.output[0])

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/tests/test_lssthtc.py

@@ -70,73 +70,86 @@ class TestLsstHtc(unittest.TestCase):
         self.assertRegex(ver, r"^\d+\.\d+\.\d+$")
 
 
-class TweakJobInfoTestCase(unittest.TestCase):
+class HtcTweakJobInfoTestCase(unittest.TestCase):
     """Test the function responsible for massaging job information."""
 
     def setUp(self):
-        self.log_file = tempfile.NamedTemporaryFile(prefix="test_", suffix=".log")
-        self.log_name = pathlib.Path(self.log_file.name)
+        self.log_dir = tempfile.TemporaryDirectory()
+        self.log_dirname = pathlib.Path(self.log_dir.name)
         self.job = {
             "Cluster": 1,
             "Proc": 0,
-            "Iwd": str(self.log_name.parent),
-            "Owner": self.log_name.owner(),
+            "Iwd": str(self.log_dirname),
+            "Owner": self.log_dirname.owner(),
             "MyType": None,
             "TerminatedNormally": True,
         }
 
     def tearDown(self):
-        self.log_file.close()
+        self.log_dir.cleanup()
 
     def testDirectAssignments(self):
-        lssthtc._tweak_log_info(self.log_name, self.job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, self.job)
         self.assertEqual(self.job["ClusterId"], self.job["Cluster"])
         self.assertEqual(self.job["ProcId"], self.job["Proc"])
-        self.assertEqual(self.job["Iwd"], str(self.log_name.parent))
-        self.assertEqual(self.job["Owner"], self.log_name.owner())
+        self.assertEqual(self.job["Iwd"], str(self.log_dirname))
+        self.assertEqual(self.job["Owner"], self.log_dirname.owner())
+
+    def testIncompatibleAdPassThru(self):
+        # Passing a job ad with insufficient information should be a no-op.
+        expected = {"foo": "bar"}
+        result = dict(expected)
+        lssthtc.htc_tweak_log_info(self.log_dirname, result)
+        self.assertEqual(result, expected)
 
     def testJobStatusAssignmentJobAbortedEvent(self):
         job = self.job | {"MyType": "JobAbortedEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.REMOVED)
 
     def testJobStatusAssignmentExecuteEvent(self):
         job = self.job | {"MyType": "ExecuteEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.RUNNING)
 
     def testJobStatusAssignmentSubmitEvent(self):
         job = self.job | {"MyType": "SubmitEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.IDLE)
 
     def testJobStatusAssignmentJobHeldEvent(self):
         job = self.job | {"MyType": "JobHeldEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.HELD)
 
     def testJobStatusAssignmentJobTerminatedEvent(self):
         job = self.job | {"MyType": "JobTerminatedEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.COMPLETED)
 
     def testJobStatusAssignmentPostScriptTerminatedEvent(self):
         job = self.job | {"MyType": "PostScriptTerminatedEvent"}
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertTrue("JobStatus" in job)
         self.assertEqual(job["JobStatus"], htcondor.JobStatus.COMPLETED)
 
+    def testJobStatusAssignmentReleaseEvent(self):
+        job = self.job | {"MyType": "JobReleaseEvent"}
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
+        self.assertTrue("JobStatus" in job)
+        self.assertEqual(job["JobStatus"], htcondor.JobStatus.RUNNING)
+
     def testAddingExitStatusSuccess(self):
         job = self.job | {
             "MyType": "JobTerminatedEvent",
             "ToE": {"ExitBySignal": False, "ExitCode": 1},
         }
-        lssthtc._tweak_log_info(self.log_name, job)
+        lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertIn("ExitBySignal", job)
         self.assertIs(job["ExitBySignal"], False)
         self.assertIn("ExitCode", job)
@@ -147,20 +160,20 @@ class TweakJobInfoTestCase(unittest.TestCase):
             "MyType": "JobHeldEvent",
         }
         with self.assertLogs(logger=logger, level="ERROR") as cm:
-            lssthtc._tweak_log_info(self.log_name, job)
+            lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertIn("Could not determine exit status", cm.output[0])
 
     def testLoggingUnknownLogEvent(self):
         job = self.job | {"MyType": "Foo"}
         with self.assertLogs(logger=logger, level="DEBUG") as cm:
-            lssthtc._tweak_log_info(self.log_name, job)
+            lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertIn("Unknown log event", cm.output[1])
 
     def testMissingKey(self):
         job = self.job
         del job["Cluster"]
         with self.assertRaises(KeyError) as cm:
-            lssthtc._tweak_log_info(self.log_name, job)
+            lssthtc.htc_tweak_log_info(self.log_dirname, job)
         self.assertEqual(str(cm.exception), "'Cluster'")
 
 
@@ -467,22 +480,14 @@ class ReadDagNodesLogTestCase(unittest.TestCase):
         with self.assertRaisesRegex(FileNotFoundError, "DAGMan node log not found in"):
             _ = lssthtc.read_dag_nodes_log(self.tmpdir)
 
-    def testBadFile(self):
-        with temporaryDirectory() as tmp_dir:
-            submit_dir = os.path.join(tmp_dir, "tiny_problems")
-            copytree(f"{TESTDIR}/data/tiny_problems", submit_dir, ignore=ignore_patterns("*~", ".???*"))
-            results = lssthtc.read_dag_nodes_log(submit_dir)
-            self.assertEqual(results["9231.0"]["JobStatus"], lssthtc.JobStatus.COMPLETED)
-            self.assertEqual(results["9231.0"]["ExitCode"], 1)
-            self.assertEqual(len(results), 6)
-
     def testRegular(self):
         with temporaryDirectory() as tmp_dir:
             submit_dir = os.path.join(tmp_dir, "tiny_problems")
             copytree(f"{TESTDIR}/data/tiny_problems", submit_dir, ignore=ignore_patterns("*~", ".???*"))
             results = lssthtc.read_dag_nodes_log(submit_dir)
-            self.assertEqual(results["9231.0"]["JobStatus"], lssthtc.JobStatus.COMPLETED)
-            self.assertEqual(results["9231.0"]["ExitCode"], 1)
+            self.assertEqual(results["9231.0"]["Cluster"], 9231)
+            self.assertEqual(results["9231.0"]["Proc"], 0)
+            self.assertEqual(results["9231.0"]["ToE"]["ExitCode"], 1)
             self.assertEqual(len(results), 6)
 
     def testSubdags(self):
@@ -494,10 +499,10 @@ class ReadDagNodesLogTestCase(unittest.TestCase):
             copytree(f"{TESTDIR}/data/group_running_1", submit_dir, ignore=ignore_patterns("*~", ".???*"))
             results = lssthtc.read_dag_nodes_log(submit_dir)
             # main dag
-            self.assertEqual(results["10094.0"]["JobStatus"], lssthtc.JobStatus.RUNNING)
+            self.assertEqual(results["10094.0"]["Cluster"], 10094)
             # subdag
-            self.assertEqual(results["10112.0"]["JobStatus"], lssthtc.JobStatus.COMPLETED)
-            self.assertEqual(results["10116.0"]["JobStatus"], lssthtc.JobStatus.RUNNING)
+            self.assertEqual(results["10112.0"]["Cluster"], 10112)
+            self.assertEqual(results["10116.0"]["Cluster"], 10116)
 
 
 class ReadNodeStatusTestCase(unittest.TestCase):
@@ -536,7 +541,6 @@ class ReadNodeStatusTestCase(unittest.TestCase):
         self.assertEqual(len(jobs), 7)
         self.assertEqual(jobs["9230.0"]["DAGNodeName"], "pipetaskInit")
         self.assertEqual(jobs["9230.0"]["wms_node_type"], lssthtc.WmsNodeType.PAYLOAD)
-        self.assertEqual(jobs["9230.0"]["JobStatus"], lssthtc.JobStatus.COMPLETED)
         found = [
             id_
             for id_ in jobs

{lsst_ctrl_bps_htcondor-29.2025.4100 → lsst_ctrl_bps_htcondor-29.2025.4300}/tests/test_report_utils.py

@@ -842,21 +842,23 @@ class GetStatusFromPathTestCase(unittest.TestCase):
         self.assertEqual(state, WmsStates.UNKNOWN)
         self.assertEqual(message, f"DAGMan log not found in {fake_path}.  Check path.")
 
-    @unittest.mock.patch("lsst.ctrl.bps.htcondor.report_utils._htc_status_to_wms_state")
-    @unittest.mock.patch("lsst.ctrl.bps.htcondor.report_utils.read_dag_log")
-    def testSuccess(self, mock_read, mock_conversion):
-        dag_ads = {"100.0": {"JobStatus": lssthtc.JobStatus.COMPLETED, "ExitBySignal": False, "ExitCode": 0}}
-        mock_read.return_value = ("100.0", dag_ads)
-        mock_conversion.return_value = WmsStates.SUCCEEDED
+    def testSuccess(self):
+        with temporaryDirectory() as tmp_dir:
+            test_submit_dir = os.path.join(tmp_dir, "tiny_success")
+            copytree(f"{TESTDIR}/data/tiny_success", test_submit_dir)
+            state, message = report_utils._get_status_from_path(test_submit_dir)
 
-        fake_path = "/fake/path"
-        state, message = report_utils._get_status_from_path(fake_path)
+            self.assertEqual(state, WmsStates.SUCCEEDED)
+            self.assertEqual(message, "")
 
-        mock_read.assert_called_once_with(Path(fake_path))
-        mock_conversion.assert_called_once_with(dag_ads["100.0"])
+    def testFailure(self):
+        with temporaryDirectory() as tmp_dir:
+            test_submit_dir = os.path.join(tmp_dir, "tiny_problems")
+            copytree(f"{TESTDIR}/data/tiny_problems", test_submit_dir)
+            state, message = report_utils._get_status_from_path(test_submit_dir)
 
-        self.assertEqual(state, WmsStates.SUCCEEDED)
-        self.assertEqual(message, "")
+            self.assertEqual(state, WmsStates.FAILED)
+            self.assertEqual(message, "")
 
 
 if __name__ == "__main__":

lsst_ctrl_bps_htcondor-29.2025.4100/python/lsst/ctrl/bps/htcondor/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.4100"