parsl 2025.3.17__py3-none-any.whl → 2025.3.24__py3-none-any.whl

parsl/dataflow/dflow.py

@@ -1128,9 +1128,7 @@ class DataFlowKernel:
             executor.run_id = self.run_id
             executor.run_dir = self.run_dir
             if self.monitoring:
-                executor.hub_address = self.monitoring.hub_address
-                executor.hub_zmq_port = self.monitoring.hub_zmq_port
-                executor.submit_monitoring_radio = self.monitoring.radio
+                executor.monitoring_messages = self.monitoring.resource_msgs
             if hasattr(executor, 'provider'):
                 if hasattr(executor.provider, 'script_dir'):
                     executor.provider.script_dir = os.path.join(self.run_dir, 'submit_scripts')

parsl/executors/base.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import os
 from abc import ABCMeta, abstractmethod
 from concurrent.futures import Future
+from multiprocessing.queues import Queue
 from typing import Any, Callable, Dict, Optional
 
 from typing_extensions import Literal, Self
 
-from parsl.monitoring.radios.base import MonitoringRadioSender
+from parsl.monitoring.types import TaggedMonitoringMessage
 
 
 class ParslExecutor(metaclass=ABCMeta):
@@ -42,6 +45,13 @@ class ParslExecutor(metaclass=ABCMeta):
               invariant, not co-variant, and it looks like @typeguard cannot be
               persuaded otherwise. So if you're implementing an executor and want to
               @typeguard the constructor, you'll have to use List[Any] here.
+
+    The DataFlowKernel will set this attribute before calling .start(),
+    if monitoring is enabled:
+
+        monitoring_messages: Optional[Queue[TaggedMonitoringMessage]] - an executor
+            can send messages to the monitoring hub by putting them into
+            this queue.
     """
 
     label: str = "undefined"
@@ -50,15 +60,11 @@ class ParslExecutor(metaclass=ABCMeta):
     def __init__(
         self,
         *,
-        hub_address: Optional[str] = None,
-        hub_zmq_port: Optional[int] = None,
-        submit_monitoring_radio: Optional[MonitoringRadioSender] = None,
+        monitoring_messages: Optional[Queue[TaggedMonitoringMessage]] = None,
         run_dir: str = ".",
         run_id: Optional[str] = None,
     ):
-        self.hub_address = hub_address
-        self.hub_zmq_port = hub_zmq_port
-        self.submit_monitoring_radio = submit_monitoring_radio
+        self.monitoring_messages = monitoring_messages
         self.run_dir = os.path.abspath(run_dir)
         self.run_id = run_id
 
@@ -125,33 +131,3 @@ class ParslExecutor(metaclass=ABCMeta):
     @run_id.setter
     def run_id(self, value: Optional[str]) -> None:
         self._run_id = value
-
-    @property
-    def hub_address(self) -> Optional[str]:
-        """Address to the Hub for monitoring.
-        """
-        return self._hub_address
-
-    @hub_address.setter
-    def hub_address(self, value: Optional[str]) -> None:
-        self._hub_address = value
-
-    @property
-    def hub_zmq_port(self) -> Optional[int]:
-        """Port to the Hub for monitoring.
-        """
-        return self._hub_zmq_port
-
-    @hub_zmq_port.setter
-    def hub_zmq_port(self, value: Optional[int]) -> None:
-        self._hub_zmq_port = value
-
-    @property
-    def submit_monitoring_radio(self) -> Optional[MonitoringRadioSender]:
-        """Local radio for sending monitoring messages
-        """
-        return self._submit_monitoring_radio
-
-    @submit_monitoring_radio.setter
-    def submit_monitoring_radio(self, value: Optional[MonitoringRadioSender]) -> None:
-        self._submit_monitoring_radio = value

parsl/executors/flux/executor.py

@@ -231,6 +231,7 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
 
     def start(self):
         """Called when DFK starts the executor when the config is loaded."""
+        super().start()
         os.makedirs(self.working_dir, exist_ok=True)
         self._submission_thread.start()
 

parsl/executors/globus_compute.py

@@ -67,7 +67,7 @@ class GlobusComputeExecutor(ParslExecutor, RepresentationMixin):
 
     def start(self) -> None:
         """ Start the Globus Compute Executor """
-        pass
+        super().start()
 
     def submit(self, func: Callable, resource_specification: Dict[str, Any], *args: Any, **kwargs: Any) -> Future:
         """ Submit func to globus-compute

parsl/executors/high_throughput/executor.py

@@ -29,6 +29,7 @@ from parsl.executors.high_throughput.manager_selector import (
 )
 from parsl.executors.status_handling import BlockProviderExecutor
 from parsl.jobs.states import TERMINAL_STATES, JobState, JobStatus
+from parsl.monitoring.radios.zmq_router import ZMQRadioReceiver, start_zmq_receiver
 from parsl.process_loggers import wrap_with_logs
 from parsl.providers import LocalProvider
 from parsl.providers.base import ExecutionProvider
@@ -334,6 +335,10 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         self._result_queue_thread_exit = threading.Event()
         self._result_queue_thread: Optional[threading.Thread] = None
 
+        self.zmq_monitoring: Optional[ZMQRadioReceiver]
+        self.zmq_monitoring = None
+        self.hub_zmq_port = None
+
     radio_mode = "htex"
     enable_mpi_mode: bool = False
     mpi_launcher: str = "mpiexec"
@@ -407,6 +412,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
     def start(self):
         """Create the Interchange process and connect to it.
         """
+        super().start()
         if self.encrypted and self.cert_dir is None:
             logger.debug("Creating CurveZMQ certificates")
             self.cert_dir = curvezmq.create_certificates(self.logdir)
@@ -427,6 +433,15 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
             self.loopback_address, self.interchange_port_range, self.cert_dir
         )
 
+        if self.monitoring_messages is not None:
+            self.zmq_monitoring = start_zmq_receiver(monitoring_messages=self.monitoring_messages,
+                                                     loopback_address=self.loopback_address,
+                                                     port_range=self.interchange_port_range,
+                                                     logdir=self.logdir,
+                                                     worker_debug=self.worker_debug,
+                                                     )
+            self.hub_zmq_port = self.zmq_monitoring.port
+
         self._result_queue_thread = None
         self._start_result_queue_thread()
         self._start_local_interchange_process()
@@ -861,6 +876,9 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         if self._result_queue_thread:
             self._result_queue_thread.join()
 
+        if self.zmq_monitoring:
+            self.zmq_monitoring.close()
+
         logger.info("Finished HighThroughputExecutor shutdown attempt")
 
     def get_usage_information(self):

parsl/executors/radical/executor.py

@@ -215,6 +215,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
         """Create the Pilot component and pass it.
         """
         logger.info("starting RadicalPilotExecutor")
+        super().start()
         logger.info('Parsl: {0}'.format(parsl.__version__))
         logger.info('RADICAL pilot: {0}'.format(rp.version))
         self.session = rp.Session(cfg={'base': self.run_dir},

parsl/executors/status_handling.py

@@ -14,6 +14,7 @@ from parsl.executors.errors import BadStateException, ScalingFailed
 from parsl.jobs.error_handlers import noop_error_handler, simple_error_handler
 from parsl.jobs.states import TERMINAL_STATES, JobState, JobStatus
 from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.providers.base import ExecutionProvider
 from parsl.utils import AtomicIDCounter
 
@@ -83,6 +84,13 @@ class BlockProviderExecutor(ParslExecutor):
         # of pending, active and recently terminated blocks
         self._status = {}  # type: Dict[str, JobStatus]
 
+        self.submit_monitoring_radio: Optional[MultiprocessingQueueRadioSender] = None
+
+    def start(self):
+        super().start()
+        if self.monitoring_messages:
+            self.submit_monitoring_radio = MultiprocessingQueueRadioSender(self.monitoring_messages)
+
     def _make_status_dict(self, block_ids: List[str], status_list: List[JobStatus]) -> Dict[str, JobStatus]:
         """Given a list of block ids and a list of corresponding status strings,
         returns a dictionary mapping each block id to the corresponding status

parsl/executors/taskvine/executor.py

@@ -239,6 +239,7 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         retrieve Parsl tasks within the TaskVine system.
         """
 
+        super().start()
         # Synchronize connection and communication settings between the manager and factory
         self.__synchronize_manager_factory_comm_settings()
 

parsl/executors/workqueue/executor.py

@@ -314,6 +314,7 @@ class WorkQueueExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         """Create submit process and collector thread to create, send, and
         retrieve Parsl tasks within the Work Queue system.
         """
+        super().start()
         self.tasks_lock = threading.Lock()
 
         # Create directories for data and results

parsl/monitoring/errors.py

@@ -4,3 +4,8 @@ from parsl.errors import ParslError
 class MonitoringHubStartError(ParslError):
     def __str__(self) -> str:
         return "Hub failed to start"
+
+
+class MonitoringRouterStartError(ParslError):
+    def __str__(self) -> str:
+        return "Monitoring router failed to start"

parsl/monitoring/monitoring.py

@@ -4,10 +4,9 @@ import logging
 import multiprocessing.synchronize as ms
 import os
 import queue
-from multiprocessing import Event
-from multiprocessing.context import ForkProcess as ForkProcessType
+import warnings
 from multiprocessing.queues import Queue
-from typing import TYPE_CHECKING, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import typeguard
 
@@ -15,9 +14,13 @@ from parsl.monitoring.errors import MonitoringHubStartError
 from parsl.monitoring.radios.filesystem_router import filesystem_router_starter
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.radios.udp_router import udp_router_starter
-from parsl.monitoring.radios.zmq_router import zmq_router_starter
 from parsl.monitoring.types import TaggedMonitoringMessage
-from parsl.multiprocessing import ForkProcess, SizedQueue
+from parsl.multiprocessing import (
+    SizedQueue,
+    SpawnEvent,
+    SpawnProcess,
+    join_terminate_close_proc,
+)
 from parsl.utils import RepresentationMixin
 
 _db_manager_excepts: Optional[Exception]
@@ -38,7 +41,7 @@ class MonitoringHub(RepresentationMixin):
     def __init__(self,
                  hub_address: str,
                  hub_port: Optional[int] = None,
-                 hub_port_range: Tuple[int, int] = (55050, 56000),
+                 hub_port_range: Any = None,
 
                  workflow_name: Optional[str] = None,
                  workflow_version: Optional[str] = None,
@@ -57,12 +60,11 @@ class MonitoringHub(RepresentationMixin):
              Note that despite the similar name, this is not related to
              hub_port_range.
              Default: None
-        hub_port_range : tuple(int, int)
-             The port range for a ZMQ channel from an executor process
-             (for example, the interchange in the High Throughput Executor)
-             to deliver monitoring messages to the monitoring router.
-             Note that despite the similar name, this is not related to hub_port.
-             Default: (55050, 56000)
+        hub_port_range : unused
+             Unused, but retained until 2025-09-14 to avoid configuration errors.
+             This value previously configured one ZMQ channel inside the
+             HighThroughputExecutor. That ZMQ channel is now configured by the
+             interchange_port_range parameter of HighThroughputExecutor.
         workflow_name : str
              The name for the workflow. Default to the name of the parsl script
         workflow_version : str
@@ -89,6 +91,13 @@ class MonitoringHub(RepresentationMixin):
 
         self.hub_address = hub_address
         self.hub_port = hub_port
+
+        if hub_port_range is not None:
+            message = "Instead of MonitoringHub.hub_port_range, Use HighThroughputExecutor.interchange_port_range"
+            warnings.warn(message, DeprecationWarning)
+            logger.warning(message)
+        # This is used by RepresentationMixin so needs to exist as an attribute
+        # even though now it is otherwise unused.
         self.hub_port_range = hub_port_range
 
         self.logging_endpoint = logging_endpoint
@@ -120,90 +129,59 @@ class MonitoringHub(RepresentationMixin):
         # in the future, Queue will allow runtime subscripts.
 
         if TYPE_CHECKING:
-            zmq_comm_q: Queue[Union[int, str]]
             udp_comm_q: Queue[Union[int, str]]
         else:
-            zmq_comm_q: Queue
             udp_comm_q: Queue
 
-        zmq_comm_q = SizedQueue(maxsize=10)
         udp_comm_q = SizedQueue(maxsize=10)
 
         self.resource_msgs: Queue[TaggedMonitoringMessage]
         self.resource_msgs = SizedQueue()
 
         self.router_exit_event: ms.Event
-        self.router_exit_event = Event()
-
-        self.zmq_router_proc = ForkProcess(target=zmq_router_starter,
-                                           kwargs={"comm_q": zmq_comm_q,
-                                                   "resource_msgs": self.resource_msgs,
-                                                   "exit_event": self.router_exit_event,
-                                                   "hub_address": self.hub_address,
-                                                   "zmq_port_range": self.hub_port_range,
-                                                   "run_dir": dfk_run_dir,
-                                                   "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
-                                                   },
-                                           name="Monitoring-ZMQ-Router-Process",
-                                           daemon=True,
-                                           )
-        self.zmq_router_proc.start()
-
-        self.udp_router_proc = ForkProcess(target=udp_router_starter,
-                                           kwargs={"comm_q": udp_comm_q,
-                                                   "resource_msgs": self.resource_msgs,
-                                                   "exit_event": self.router_exit_event,
-                                                   "hub_address": self.hub_address,
-                                                   "udp_port": self.hub_port,
-                                                   "run_dir": dfk_run_dir,
-                                                   "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
-                                                   },
-                                           name="Monitoring-UDP-Router-Process",
-                                           daemon=True,
-                                           )
+        self.router_exit_event = SpawnEvent()
+
+        self.udp_router_proc = SpawnProcess(target=udp_router_starter,
+                                            kwargs={"comm_q": udp_comm_q,
+                                                    "resource_msgs": self.resource_msgs,
+                                                    "exit_event": self.router_exit_event,
+                                                    "hub_address": self.hub_address,
+                                                    "udp_port": self.hub_port,
+                                                    "run_dir": dfk_run_dir,
+                                                    "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
+                                                    },
+                                            name="Monitoring-UDP-Router-Process",
+                                            daemon=True,
+                                            )
         self.udp_router_proc.start()
 
         self.dbm_exit_event: ms.Event
-        self.dbm_exit_event = Event()
-
-        self.dbm_proc = ForkProcess(target=dbm_starter,
-                                    args=(self.resource_msgs,),
-                                    kwargs={"run_dir": dfk_run_dir,
-                                            "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
-                                            "db_url": self.logging_endpoint,
-                                            "exit_event": self.dbm_exit_event,
-                                            },
-                                    name="Monitoring-DBM-Process",
-                                    daemon=True,
-                                    )
+        self.dbm_exit_event = SpawnEvent()
+
+        self.dbm_proc = SpawnProcess(target=dbm_starter,
+                                     args=(self.resource_msgs,),
+                                     kwargs={"run_dir": dfk_run_dir,
+                                             "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
+                                             "db_url": self.logging_endpoint,
+                                             "exit_event": self.dbm_exit_event,
+                                             },
+                                     name="Monitoring-DBM-Process",
+                                     daemon=True,
+                                     )
         self.dbm_proc.start()
-        logger.info("Started ZMQ router process %s, UDP router process %s and DBM process %s",
-                    self.zmq_router_proc.pid, self.udp_router_proc.pid, self.dbm_proc.pid)
-
-        self.filesystem_proc = ForkProcess(target=filesystem_router_starter,
-                                           args=(self.resource_msgs, dfk_run_dir, self.router_exit_event),
-                                           name="Monitoring-Filesystem-Process",
-                                           daemon=True
-                                           )
+        logger.info("Started UDP router process %s and DBM process %s",
+                    self.udp_router_proc.pid, self.dbm_proc.pid)
+
+        self.filesystem_proc = SpawnProcess(target=filesystem_router_starter,
+                                            args=(self.resource_msgs, dfk_run_dir, self.router_exit_event),
+                                            name="Monitoring-Filesystem-Process",
+                                            daemon=True
+                                            )
         self.filesystem_proc.start()
         logger.info("Started filesystem radio receiver process %s", self.filesystem_proc.pid)
 
         self.radio = MultiprocessingQueueRadioSender(self.resource_msgs)
 
-        try:
-            zmq_comm_q_result = zmq_comm_q.get(block=True, timeout=120)
-            zmq_comm_q.close()
-            zmq_comm_q.join_thread()
-        except queue.Empty:
-            logger.error("Monitoring ZMQ Router has not reported port in 120s. Aborting")
-            raise MonitoringHubStartError()
-
-        if isinstance(zmq_comm_q_result, str):
-            logger.error("MonitoringRouter sent an error message: %s", zmq_comm_q_result)
-            raise RuntimeError(f"MonitoringRouter failed to start: {zmq_comm_q_result}")
-
-        self.hub_zmq_port = zmq_comm_q_result
-
         try:
             udp_comm_q_result = udp_comm_q.get(block=True, timeout=120)
             udp_comm_q.close()
@@ -232,9 +210,6 @@ class MonitoringHub(RepresentationMixin):
             logger.info("Setting router termination event")
             self.router_exit_event.set()
 
-            logger.info("Waiting for ZMQ router to terminate")
-            join_terminate_close_proc(self.zmq_router_proc)
-
             logger.info("Waiting for UDP router to terminate")
             join_terminate_close_proc(self.udp_router_proc)
 
@@ -251,38 +226,3 @@ class MonitoringHub(RepresentationMixin):
             self.resource_msgs.close()
             self.resource_msgs.join_thread()
             logger.info("Closed monitoring multiprocessing queues")
-
-
-def join_terminate_close_proc(process: ForkProcessType, *, timeout: int = 30) -> None:
-    """Increasingly aggressively terminate a process.
-
-    This function assumes that the process is likely to exit before
-    the join timeout, driven by some other means, such as the
-    MonitoringHub router_exit_event. If the process does not exit, then
-    first terminate() and then kill() will be used to end the process.
-
-    In the case of a very mis-behaving process, this function might take
-    up to 3*timeout to exhaust all termination methods and return.
-    """
-    logger.debug("Joining process")
-    process.join(timeout)
-
-    # run a sequence of increasingly aggressive steps to shut down the process.
-    if process.is_alive():
-        logger.error("Process did not join. Terminating.")
-        process.terminate()
-        process.join(timeout)
-        if process.is_alive():
-            logger.error("Process did not join after terminate. Killing.")
-            process.kill()
-            process.join(timeout)
-            # This kill should not be caught by any signal handlers so it is
-            # unlikely that this join will timeout. If it does, there isn't
-            # anything further to do except log an error in the next if-block.
-
-    if process.is_alive():
-        logger.error("Process failed to end")
-        # don't call close if the process hasn't ended:
-        # process.close() doesn't work on a running process.
-    else:
-        process.close()

parsl/monitoring/radios/zmq_router.py

@@ -3,16 +3,27 @@ from __future__ import annotations
 import logging
 import multiprocessing.queues as mpq
 import os
+import queue
 import time
-from multiprocessing.synchronize import Event
+from multiprocessing.context import SpawnProcess as SpawnProcessType
+from multiprocessing.queues import Queue as QueueType
+from multiprocessing.synchronize import Event as EventType
 from typing import Tuple
 
 import typeguard
 import zmq
 
+from parsl.addresses import tcp_url
 from parsl.log_utils import set_file_logger
+from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.types import TaggedMonitoringMessage
+from parsl.multiprocessing import (
+    SizedQueue,
+    SpawnEvent,
+    SpawnProcess,
+    join_terminate_close_proc,
+)
 from parsl.process_loggers import wrap_with_logs
 from parsl.utils import setproctitle
 
@@ -23,21 +34,21 @@ class MonitoringRouter:
 
     def __init__(self,
                  *,
-                 hub_address: str,
-                 zmq_port_range: Tuple[int, int] = (55050, 56000),
+                 address: str,
+                 port_range: Tuple[int, int] = (55050, 56000),
 
                  run_dir: str = ".",
                  logging_level: int = logging.INFO,
                  resource_msgs: mpq.Queue,
-                 exit_event: Event,
+                 exit_event: EventType,
                  ):
         """ Initializes a monitoring configuration class.
 
         Parameters
         ----------
-        hub_address : str
+        address : str
              The ip address at which the workers will be able to reach the Hub.
-        zmq_port_range : tuple(int, int)
+        port_range : tuple(int, int)
              The MonitoringHub picks ports at random from the range which will be used by Hub.
              Default: (55050, 56000)
         run_dir : str
@@ -51,11 +62,11 @@ class MonitoringRouter:
         """
         os.makedirs(run_dir, exist_ok=True)
         self.logger = set_file_logger(f"{run_dir}/monitoring_zmq_router.log",
-                                      name="monitoring_router",
+                                      name="zmq_monitoring_router",
                                       level=logging_level)
         self.logger.debug("Monitoring router starting")
 
-        self.hub_address = hub_address
+        self.address = address
 
         self.loop_freq = 10.0  # milliseconds
 
@@ -64,15 +75,15 @@ class MonitoringRouter:
         self.zmq_receiver_channel.setsockopt(zmq.LINGER, 0)
         self.zmq_receiver_channel.set_hwm(0)
         self.zmq_receiver_channel.RCVTIMEO = int(self.loop_freq)  # in milliseconds
-        self.logger.debug("hub_address: {}. zmq_port_range {}".format(hub_address, zmq_port_range))
-        self.zmq_receiver_port = self.zmq_receiver_channel.bind_to_random_port("tcp://*",
-                                                                               min_port=zmq_port_range[0],
-                                                                               max_port=zmq_port_range[1])
+        self.logger.debug("address: {}. port_range {}".format(address, port_range))
+        self.zmq_receiver_port = self.zmq_receiver_channel.bind_to_random_port(tcp_url(address),
+                                                                               min_port=port_range[0],
+                                                                               max_port=port_range[1])
 
         self.target_radio = MultiprocessingQueueRadioSender(resource_msgs)
         self.exit_event = exit_event
 
-    @wrap_with_logs(target="monitoring_router")
+    @wrap_with_logs(target="zmq_monitoring_router")
     def start(self) -> None:
         self.logger.info("Starting ZMQ listener")
         try:
@@ -108,17 +119,17 @@ class MonitoringRouter:
 def zmq_router_starter(*,
                        comm_q: mpq.Queue,
                        resource_msgs: mpq.Queue,
-                       exit_event: Event,
+                       exit_event: EventType,
 
-                       hub_address: str,
-                       zmq_port_range: Tuple[int, int],
+                       address: str,
+                       port_range: Tuple[int, int],
 
                        run_dir: str,
                        logging_level: int) -> None:
     setproctitle("parsl: monitoring zmq router")
     try:
-        router = MonitoringRouter(hub_address=hub_address,
-                                  zmq_port_range=zmq_port_range,
+        router = MonitoringRouter(address=address,
+                                  port_range=port_range,
                                   run_dir=run_dir,
                                   logging_level=logging_level,
                                   resource_msgs=resource_msgs,
@@ -129,3 +140,54 @@ def zmq_router_starter(*,
     else:
         comm_q.put(router.zmq_receiver_port)
         router.start()
+
+
+class ZMQRadioReceiver():
+    def __init__(self, *, process: SpawnProcessType, exit_event: EventType, port: int) -> None:
+        self.process = process
+        self.exit_event = exit_event
+        self.port = port
+
+    def close(self) -> None:
+        self.exit_event.set()
+        join_terminate_close_proc(self.process)
+
+
+def start_zmq_receiver(*,
+                       monitoring_messages: QueueType,
+                       loopback_address: str,
+                       port_range: Tuple[int, int],
+                       logdir: str,
+                       worker_debug: bool) -> ZMQRadioReceiver:
+    comm_q = SizedQueue(maxsize=10)
+
+    router_exit_event = SpawnEvent()
+
+    router_proc = SpawnProcess(target=zmq_router_starter,
+                               kwargs={"comm_q": comm_q,
+                                       "resource_msgs": monitoring_messages,
+                                       "exit_event": router_exit_event,
+                                       "address": loopback_address,
+                                       "port_range": port_range,
+                                       "run_dir": logdir,
+                                       "logging_level": logging.DEBUG if worker_debug else logging.INFO,
+                                       },
+                               name="Monitoring-ZMQ-Router-Process",
+                               daemon=True,
+                               )
+    router_proc.start()
+
+    try:
+        logger.debug("Waiting for router process to report port")
+        comm_q_result = comm_q.get(block=True, timeout=120)
+        comm_q.close()
+        comm_q.join_thread()
+    except queue.Empty:
+        logger.error("Monitoring ZMQ Router has not reported port in 120s")
+        raise MonitoringRouterStartError()
+
+    if isinstance(comm_q_result, str):
+        logger.error("MonitoringRouter sent an error message: %s", comm_q_result)
+        raise RuntimeError(f"MonitoringRouter failed to start: {comm_q_result}")
+
+    return ZMQRadioReceiver(process=router_proc, exit_event=router_exit_event, port=comm_q_result)

parsl/multiprocessing.py

@@ -6,6 +6,7 @@ import multiprocessing
 import multiprocessing.queues
 import platform
 from multiprocessing.context import ForkProcess as ForkProcessType
+from multiprocessing.context import SpawnProcess as SpawnProcessType
 from typing import Callable
 
 logger = logging.getLogger(__name__)
@@ -14,6 +15,10 @@ ForkContext = multiprocessing.get_context("fork")
 SpawnContext = multiprocessing.get_context("spawn")
 
 ForkProcess: Callable[..., ForkProcessType] = ForkContext.Process
+SpawnProcess: Callable[..., SpawnProcessType] = SpawnContext.Process
+
+SpawnEvent = SpawnContext.Event
+SpawnQueue = SpawnContext.Queue
 
 
 class MacSafeQueue(multiprocessing.queues.Queue):
@@ -26,7 +31,7 @@ class MacSafeQueue(multiprocessing.queues.Queue):
 
     def __init__(self, *args, **kwargs):
         if 'ctx' not in kwargs:
-            kwargs['ctx'] = multiprocessing.get_context()
+            kwargs['ctx'] = multiprocessing.get_context('spawn')
         super().__init__(*args, **kwargs)
         self._counter = multiprocessing.Value('i', 0)
 
@@ -59,6 +64,41 @@ SizedQueue: Callable[..., multiprocessing.Queue]
 
 if platform.system() != 'Darwin':
     import multiprocessing
-    SizedQueue = multiprocessing.Queue
+    SizedQueue = SpawnQueue
 else:
     SizedQueue = MacSafeQueue
+
+
+def join_terminate_close_proc(process: SpawnProcessType, *, timeout: int = 30) -> None:
+    """Increasingly aggressively terminate a process.
+
+    This function assumes that the process is likely to exit before
+    the join timeout, driven by some other means, such as the
+    MonitoringHub router_exit_event. If the process does not exit, then
+    first terminate() and then kill() will be used to end the process.
+
+    In the case of a very mis-behaving process, this function might take
+    up to 3*timeout to exhaust all termination methods and return.
+    """
+    logger.debug("Joining process")
+    process.join(timeout)
+
+    # run a sequence of increasingly aggressive steps to shut down the process.
+    if process.is_alive():
+        logger.error("Process did not join. Terminating.")
+        process.terminate()
+        process.join(timeout)
+        if process.is_alive():
+            logger.error("Process did not join after terminate. Killing.")
+            process.kill()
+            process.join(timeout)
+            # This kill should not be caught by any signal handlers so it is
+            # unlikely that this join will timeout. If it does, there isn't
+            # anything further to do except log an error in the next if-block.
+
+    if process.is_alive():
+        logger.error("Process failed to end")
+        # don't call close if the process hasn't ended:
+        # process.close() doesn't work on a running process.
+    else:
+        process.close()

parsl/tests/test_monitoring/test_exit_helper.py

@@ -4,8 +4,7 @@ import signal
 import psutil
 import pytest
 
-from parsl.monitoring.monitoring import join_terminate_close_proc
-from parsl.multiprocessing import ForkProcess
+from parsl.multiprocessing import SpawnEvent, SpawnProcess, join_terminate_close_proc
 
 
 def noop():
@@ -14,7 +13,7 @@ def noop():
 
 @pytest.mark.local
 def test_end_process_already_exited():
-    p = ForkProcess(target=noop)
+    p = SpawnProcess(target=noop)
     p.start()
     p.join()
     join_terminate_close_proc(p)
@@ -28,7 +27,7 @@ def hang():
 @pytest.mark.local
 def test_end_hung_process():
     """Test calling against a process that will not exit itself."""
-    p = ForkProcess(target=hang)
+    p = SpawnProcess(target=hang)
     p.start()
     pid = p.pid
     join_terminate_close_proc(p, timeout=1)
@@ -46,10 +45,10 @@ def hang_no_sigint(e):
 @pytest.mark.local
 def test_end_hung_process_no_sigint():
     """Test calling against a process that will not exit itself."""
-    e = multiprocessing.Event()
-    p = ForkProcess(target=hang_no_sigint, args=(e,))
+    e = SpawnEvent()
+    p = SpawnProcess(target=hang_no_sigint, args=(e,))
     p.start()
     pid = p.pid
-    join_terminate_close_proc(p, timeout=1)
+    join_terminate_close_proc(p, timeout=2)
     assert not psutil.pid_exists(pid), "process should not exist any more"
     assert e.is_set(), "hung process should have set event on signal"

parsl/tests/test_monitoring/test_fuzz_zmq.py

@@ -45,7 +45,7 @@ def test_row_counts():
 
     # dig out the interchange port...
     hub_address = parsl.dfk().monitoring.hub_address
-    hub_zmq_port = parsl.dfk().monitoring.hub_zmq_port
+    hub_zmq_port = parsl.dfk().executors["htex_Local"].hub_zmq_port
 
     # this will send a string to a new socket connection
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:

parsl/tests/test_monitoring/test_radio_zmq.py

@@ -0,0 +1,27 @@
+import pytest
+
+from parsl.monitoring.radios.zmq import ZMQRadioSender
+from parsl.monitoring.radios.zmq_router import start_zmq_receiver
+from parsl.multiprocessing import SpawnQueue
+
+
+@pytest.mark.local
+def test_send_recv_message(tmpd_cwd, try_assert):
+    q = SpawnQueue()
+    loopback = "127.0.0.1"
+    r = start_zmq_receiver(monitoring_messages=q,
+                           loopback_address=loopback,
+                           port_range=(49152, 65535),
+                           logdir=str(tmpd_cwd),
+                           worker_debug=False)
+
+    s = ZMQRadioSender(loopback, r.port)
+
+    test_msg = ("test", {})
+    s.send(test_msg)
+
+    assert q.get() == test_msg
+
+    assert r.process.is_alive()
+    r.exit_event.set()
+    try_assert(lambda: not r.process.is_alive())

parsl/tests/test_monitoring/test_stdouterr.py

@@ -102,6 +102,9 @@ def test_stdstream_to_monitoring(stdx, expected_stdx, stream, tmpd_cwd, caplog):
         kwargs = {stream: stdx}
         stdapp(**kwargs).result()
 
+    for record in caplog.records:
+        assert record.levelno < logging.ERROR
+
     engine = sqlalchemy.create_engine(c.monitoring.logging_endpoint)
     with engine.begin() as connection:
 

parsl/tests/test_shutdown/test_kill_monitoring.py

@@ -30,7 +30,7 @@ def test_no_kills():
 
 @pytest.mark.local
 @pytest.mark.parametrize("sig", [signal.SIGINT, signal.SIGTERM, signal.SIGKILL, signal.SIGQUIT])
-@pytest.mark.parametrize("process_attr", ["zmq_router_proc", "udp_router_proc", "dbm_proc", "filesystem_proc"])
+@pytest.mark.parametrize("process_attr", ["udp_router_proc", "dbm_proc", "filesystem_proc"])
 def test_kill_monitoring_helper_process(sig, process_attr, try_assert):
     """This tests that we can kill a monitoring process and still have successful shutdown.
     SIGINT emulates some racy behaviour when ctrl-C is pressed: that

parsl/usage_tracking/usage.py

@@ -8,7 +8,7 @@ import uuid
 
 from parsl.dataflow.states import States
 from parsl.errors import ConfigurationError
-from parsl.multiprocessing import ForkProcess
+from parsl.multiprocessing import SpawnProcess
 from parsl.usage_tracking.api import get_parsl_usage
 from parsl.usage_tracking.levels import DISABLED as USAGE_TRACKING_DISABLED
 from parsl.usage_tracking.levels import LEVEL_3 as USAGE_TRACKING_LEVEL_3
@@ -35,7 +35,7 @@ def async_process(fn: Callable[P, None]) -> Callable[P, None]:
     """ Decorator function to launch a function as a separate process """
 
     def run(*args, **kwargs):
-        proc = ForkProcess(target=fn, args=args, kwargs=kwargs, name="Usage-Tracking")
+        proc = SpawnProcess(target=fn, args=args, kwargs=kwargs, name="Usage-Tracking")
         proc.start()
         return proc
 

parsl/version.py

@@ -3,4 +3,4 @@
 Year.Month.Day[alpha/beta/..]
 Alphas will be numbered like this -> 2024.12.10a0
 """
-VERSION = '2025.03.17'
+VERSION = '2025.03.24'

{parsl-2025.3.17.dist-info → parsl-2025.3.24.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2025.3.17
+Version: 2025.3.24
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2025.03.17.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2025.03.24.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0

{parsl-2025.3.17.dist-info → parsl-2025.3.24.dist-info}/RECORD

@@ -4,11 +4,11 @@ parsl/config.py,sha256=p5HQoxLj5aMagUAYfngcXG2kw0s6SJoc6u7vH2sVhPU,9635
 parsl/curvezmq.py,sha256=6Zi7RqTP_eKWi3DFgapfK2t-Jw8vJS-ZtN1bsrByPeo,7073
 parsl/errors.py,sha256=SzINzQFZDBDbj9l-DPQznD0TbGkNhHIRAPkcBCogf_A,1019
 parsl/log_utils.py,sha256=u14Fkl5eDfS4HMpl0JjseNNPdbvPaugWPRQj1_af_Zo,3273
-parsl/multiprocessing.py,sha256=MyaEcEq-Qf860u7V98u-PZrPNdtzOZL_NW6EhIJnmfQ,1937
+parsl/multiprocessing.py,sha256=JNAfgdZvQSsxVyUp229OOUqWwf_ZUhpmw8X9CdF3i6k,3614
 parsl/process_loggers.py,sha256=uQ7Gd0W72Jz7rrcYlOMfLsAEhkRltxXJL2MgdduJjEw,1136
 parsl/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/utils.py,sha256=codTX6_KLhgeTwNkRzc1lo4bgc1M93eJ-lkqOO98fvk,14331
-parsl/version.py,sha256=_yYxGBkoJMDKADe5yJ2dAkIINmdZgyRTRJnodIasABw,131
+parsl/version.py,sha256=RGffnfvs_gOc_lEWgnZpd1jy_cuz-F39xp5lsIo6OyU,131
 parsl/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/app/app.py,sha256=0gbM4AH2OtFOLsv07I5nglpElcwMSOi-FzdZZfrk7So,8532
 parsl/app/bash.py,sha256=jm2AvePlCT9DZR7H_4ANDWxatp5dN_22FUlT_gWhZ-g,5528
@@ -53,7 +53,7 @@ parsl/data_provider/staging.py,sha256=ZDZuuFg38pjUStegKPcvPsfGp3iMeReMzfU6DSwtJj
 parsl/data_provider/zip.py,sha256=S4kVuH9lxAegRURYbvIUR7EYYBOccyslaqyCrVWUBhw,4497
 parsl/dataflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/dataflow/dependency_resolvers.py,sha256=Om8Dgh7a0ZwgXAc6TlhxLSzvxXHDlNNV1aBNiD3JTNY,3325
-parsl/dataflow/dflow.py,sha256=jNxrAd2xmxesS3fR6eZyDN9f6I0BIBQbhL63zv51lkk,61752
+parsl/dataflow/dflow.py,sha256=kAEziQPm9rpGKzqhOuHSnnIXQ3KgrRaeRbYReww7Amw,61620
 parsl/dataflow/errors.py,sha256=daVfr2BWs1zRsGD6JtosEMttWHvK1df1Npiu_MUvFKg,3998
 parsl/dataflow/futures.py,sha256=08LuP-HFiHBIZmeKCjlsazw_WpQ5fwevrU2_WbidkYw,6080
 parsl/dataflow/memoization.py,sha256=QUkTduZ_gdr8i08VWNWrqhfEvoMGsPDZegWUE2_7sGQ,12579
@@ -61,19 +61,19 @@ parsl/dataflow/rundirs.py,sha256=JZdzybVGubY35jL2YiKcDo65ZmRl1WyOApc8ajYxztc,108
 parsl/dataflow/states.py,sha256=hV6mfv-y4A6xrujeQglcomnfEs7y3Xm2g6JFwC6dvgQ,2612
 parsl/dataflow/taskrecord.py,sha256=qIW7T6hn9dYTuNPdUura3HQwwUpUJACwPP5REm5COf4,3042
 parsl/executors/__init__.py,sha256=PEuXYrnVqwlaz_nt82s9D_YNaVsX7ET29DeIZRUR8hw,577
-parsl/executors/base.py,sha256=jYEa5nS1_Vn8k3A92TCSYG0n2zeHnN6KiuVWsILl4sE,5205
+parsl/executors/base.py,sha256=_X-huuXKCoQatT_TYx9ApEuXiVVvUYI0S7uKlVMHP-U,4488
 parsl/executors/errors.py,sha256=ZxL3nK5samPos8Xixo_jpRtPIiRJfZ5D397_qaXj2g0,2515
 parsl/executors/execute_task.py,sha256=PtqHxk778UQaNah1AN-TJV5emZbOcU5TGtWDxFn3_F4,1079
-parsl/executors/globus_compute.py,sha256=giyCyq5KWK_o4nhQJBX2Xm9FatdpdKrgloZuHhN0Zwg,4840
-parsl/executors/status_handling.py,sha256=nxbkiGr6f3xDc0nsUeSrMMxlj7UD32K7nOLCLzfthDs,15416
+parsl/executors/globus_compute.py,sha256=818XKRobNRCs5-h30x2NP2XSLkoWlWoNeBZtv9hF-ec,4851
+parsl/executors/status_handling.py,sha256=oiy6SQUQWwVciZd9MxF0sna9miqkMfaKv6ZTrj3h-Pc,15772
 parsl/executors/threads.py,sha256=_LA5NA3GSvtjDend-1HVpjoDoNHHW13rAD0CET99fjQ,3463
 parsl/executors/flux/__init__.py,sha256=P9grTTeRPXfqXurFhlSS7XhmE6tTbnCnyQ1f9b-oYHE,136
 parsl/executors/flux/execute_parsl_task.py,sha256=zHP5M7ILGiwnoalZ8WsfVVdZM7uP4iQo2ThVh4crxpM,1530
-parsl/executors/flux/executor.py,sha256=8_xakLUu5zNJAHL0LbeTCFEWqWzRK1eE-3ep4GIIIrY,17017
+parsl/executors/flux/executor.py,sha256=ii1i5V7uQnhf1BDq5nnMscmmpXJkCWtrFCuBbDaPyWI,17041
 parsl/executors/flux/flux_instance_manager.py,sha256=5T3Rp7ZM-mlT0Pf0Gxgs5_YmnaPrSF9ec7zvRfLfYJw,2129
 parsl/executors/high_throughput/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/executors/high_throughput/errors.py,sha256=k2XuvvFdUfNs2foHFnxmS-BToRMfdXpYEa4EF3ELKq4,1554
-parsl/executors/high_throughput/executor.py,sha256=esMYMgPHmgD0wPTb0U61vBX96DaPrWj9sQLzpKvB06k,38752
+parsl/executors/high_throughput/executor.py,sha256=VVKe3gveCqa3rERAqhVNsWifSrLqyMcUwpdyHCsYdz8,39663
 parsl/executors/high_throughput/interchange.py,sha256=7sKIvxP3a7HSzqEq25ZCpABx-1Q2f585pFDGzUvo7_4,29459
 parsl/executors/high_throughput/manager_record.py,sha256=ZMsqFxvreGLRXAw3N-JnODDa9Qfizw2tMmcBhm4lco4,490
 parsl/executors/high_throughput/manager_selector.py,sha256=UKcUE6v0tO7PDMTThpKSKxVpOpOUilxDL7UbNgpZCxo,2116
@@ -85,13 +85,13 @@ parsl/executors/high_throughput/probe.py,sha256=QOEaliO3x5cB6ltMOZMsZQ-ath9AAuFq
 parsl/executors/high_throughput/process_worker_pool.py,sha256=Q7FN0MdXIAOouxDarim6etYVHEgbXFiaMhBahC2ZtIQ,41137
 parsl/executors/high_throughput/zmq_pipes.py,sha256=NUK25IEh0UkxzdqQQyM8tMtuZmjSiTeWu1DzkkAIOhA,8980
 parsl/executors/radical/__init__.py,sha256=CKbtV2numw5QvgIBq1htMUrt9TqDCIC2zifyf2svTNU,186
-parsl/executors/radical/executor.py,sha256=en2TKzZnJYU_juojkM_aZUdWhbAgutAYn_EL6HGpfSY,22835
+parsl/executors/radical/executor.py,sha256=cRxEAPLvdYozCHT_zSj79KAOltfZySFYUbMU4rTbGng,22859
 parsl/executors/radical/rpex_resources.py,sha256=Q7-0u3K447LBCe2y7mVcdw6jqWI7SdPXxCKhkr6FoRQ,5139
 parsl/executors/radical/rpex_worker.py,sha256=z6r82ZujKb6sdKIdHsQ_5EBMDIQieeGcrlt6kGLFo4M,1830
 parsl/executors/taskvine/__init__.py,sha256=9rwp3M8B0YyEhZMLO0RHaNw7u1nc01WHbXLqnBTanu0,293
 parsl/executors/taskvine/errors.py,sha256=euIYkSslrNSI85kyi2s0xzOaO9ik4c1fYHstMIeiBJk,652
 parsl/executors/taskvine/exec_parsl_function.py,sha256=ftGdJU78lKPPkphSHlEi4rj164mhuMHJjghVqfgeXKk,7085
-parsl/executors/taskvine/executor.py,sha256=4c0mt83G-F4ZFMxhdJByvYjG05QdLrLYYHsmpPXY6YE,30906
+parsl/executors/taskvine/executor.py,sha256=PpsMPYx99mgKq_xOqnRdXo20NZOr7JFtOIKETIEK-z0,30930
 parsl/executors/taskvine/factory.py,sha256=GU5JryEAKJuYKwrSc162BN-lhcKhapvBZHT820pxwic,2772
 parsl/executors/taskvine/factory_config.py,sha256=ZQC5vyDe8cM0nuv7fbBCV2xnWGAZ87iLlT2UqmFFI1U,3695
 parsl/executors/taskvine/manager.py,sha256=SUi5mqqMm_rnkBLrZtTQe7RiHqWDn1oOejQscYzfwAU,25797
@@ -100,7 +100,7 @@ parsl/executors/taskvine/utils.py,sha256=iSrIogeiauL3UNy_9tiZp1cBSNn6fIJkMYQRVi1
 parsl/executors/workqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/executors/workqueue/errors.py,sha256=XO2naYhAsHHyiOBH6hpObg3mPNDmvMoFqErsj0-v7jc,541
 parsl/executors/workqueue/exec_parsl_function.py,sha256=YXKVVIa4zXmOtz-0Ca4E_5nQfN_3S2bh2tB75uZZB4w,7774
-parsl/executors/workqueue/executor.py,sha256=QYJ02jt0AG-83XN0-mUa9LSUezroYSbh1OkOGzGLIqo,49693
+parsl/executors/workqueue/executor.py,sha256=aRvEt_BGO2AGNaoF8P109z81XhlFqjyjJnka3yIzy-4,49717
 parsl/executors/workqueue/parsl_coprocess.py,sha256=cF1UmTgVLoey6QzBcbYgEiEsRidSaFfuO54f1HFw_EM,5737
 parsl/executors/workqueue/parsl_coprocess_stub.py,sha256=_bJmpPIgL42qM6bVzeEKt1Mn1trSP41rtJguXxPGfHI,735
 parsl/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -115,9 +115,9 @@ parsl/launchers/errors.py,sha256=8YMV_CHpBNVa4eXkGE4x5DaFQlZkDCRCHmBktYcY6TA,467
 parsl/launchers/launchers.py,sha256=cQsNsHuCOL_nQTjPXf0--YsgsDoMoJ77bO1Wt4ncLjs,15134
 parsl/monitoring/__init__.py,sha256=0ywNz6i0lM1xo_7_BIxhETDGeVd2C_0wwD7qgeaMR4c,83
 parsl/monitoring/db_manager.py,sha256=L0c5S9ockq0UIchT2bjmkSAWXS-t0G-Q_neOIBfLbm0,33444
-parsl/monitoring/errors.py,sha256=D6jpYzEzp0d6FmVKGqhvjAxr4ztZfJX2s-aXemH9bBU,148
+parsl/monitoring/errors.py,sha256=GParOWoCTp2w1Hmif0PaF5J6p5dWVOwyhO18bcvr_uo,277
 parsl/monitoring/message_type.py,sha256=Khn88afNxcOIciKiCK4GLnn90I5BlRTiOL3zK-P07yQ,401
-parsl/monitoring/monitoring.py,sha256=PspFFtf3Iaj5tl23ITRRdHrBDAocSOSvP2IVP_pmW-Y,13134
+parsl/monitoring/monitoring.py,sha256=ZA-36DYtPRApJDc6cd8R8xoRGfCG4OMa9mzW4OPGCCs,10065
 parsl/monitoring/remote.py,sha256=t0qCTUMCzeJ_JOARFpjqlTNrAWdEb20BxhmZh9X7kEM,13728
 parsl/monitoring/types.py,sha256=oOCrzv-ab-_rv4pb8o58Sdb8G_RGp1aZriRbdf9zBEk,339
 parsl/monitoring/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -131,7 +131,7 @@ parsl/monitoring/radios/multiprocessing.py,sha256=fsfaaoMDp6VJv1DSAl-P0R2ofO6jp1
 parsl/monitoring/radios/udp.py,sha256=bTpt7JYp-5hyBBLzgiLj1_BlSTn28UVp39OYgVGLXCw,1613
 parsl/monitoring/radios/udp_router.py,sha256=LEiHZVhw3lVFhqUK1FAFFtpvNOWbB6RNRBK8FaMvtDw,5771
 parsl/monitoring/radios/zmq.py,sha256=fhoHp9ylhf-D3eTJb2aSHRsuic8-FJ_oRNGnniGkCAI,592
-parsl/monitoring/radios/zmq_router.py,sha256=pYhol8-SV8FThv7YIjqc5tv149E4ktDLb-l7-ot4nfg,5579
+parsl/monitoring/radios/zmq_router.py,sha256=ksaWb9bceyFhGGMDC8Nc16JhQ3qpmg8uXQypbrvvtcg,7984
 parsl/monitoring/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/monitoring/visualization/app.py,sha256=xMeRlAnzl5lHddAOdSBcqY3D5lmOYw3Z3Z2_YyoVwnw,1425
 parsl/monitoring/visualization/models.py,sha256=C7CcF6w6PhtrdvDX9VgDH-aSrpLfvYU1fJ4-HDUeFVQ,5138
@@ -339,12 +339,13 @@ parsl/tests/test_monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 parsl/tests/test_monitoring/test_app_names.py,sha256=A-mOMCVhZDnUyJp32fsTUkHdcyval8o7WPEWacDkbD4,2208
 parsl/tests/test_monitoring/test_basic.py,sha256=VdF6JHfqsEOIMg-ysIAREgygZIjHWNDVLNVQ7jhWxmQ,4592
 parsl/tests/test_monitoring/test_db_locks.py,sha256=3s3c1xhKo230ZZIJ3f1Ca4U7LcEdXnanOGVXQyNlk2U,2895
-parsl/tests/test_monitoring/test_exit_helper.py,sha256=FsMcQ1GF70vPXEfexDyo674_c5cglJBrLXKBzAYIfOk,1266
-parsl/tests/test_monitoring/test_fuzz_zmq.py,sha256=--3-pQUvXXbkr8v_BEJoPvVvNly1oXvrD2nJh6yl_0M,3436
+parsl/tests/test_monitoring/test_exit_helper.py,sha256=ob8Qd1hlkq_mowygfPetTnYN9LfuqeXHRpPilSfDSog,1232
+parsl/tests/test_monitoring/test_fuzz_zmq.py,sha256=SQNNHhXxHB_LwW4Ujqkgut3lbG0XVW-hliPagQQpiTc,3449
 parsl/tests/test_monitoring/test_htex_init_blocks_vs_monitoring.py,sha256=_QV8zjBKVF_qBbBnhT0C3X9AmfS7IKLcOnEw_cU6HeM,2622
 parsl/tests/test_monitoring/test_incomplete_futures.py,sha256=ZnO1sFSwlWUBHX64C_zwfTVRVC_UFNlU4h0POgx6NEo,2005
 parsl/tests/test_monitoring/test_memoization_representation.py,sha256=dknv2nO7pNZ1jGxWGsC_AW3rs90gjMIeC5d7pIJ75Xc,2645
-parsl/tests/test_monitoring/test_stdouterr.py,sha256=AjzD4oumRIe9XMDPU4Cn_9-fwx34Vg8eAq58VfCO_zc,4492
+parsl/tests/test_monitoring/test_radio_zmq.py,sha256=7ARjDbde9kSuP4NCx_z-UtmMf2X5opbkkKM7mZcayuA,783
+parsl/tests/test_monitoring/test_stdouterr.py,sha256=SEMKBk4v5Saoq3QiraFpzUpVe5vS_132GQPSf1Qu0qM,4573
 parsl/tests/test_monitoring/test_viz_colouring.py,sha256=83Qdmn3gM0j7IL6kPDcuIsp_nl4zj-liPijyIN632SY,592
 parsl/tests/test_mpi_apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/tests/test_mpi_apps/test_bad_mpi_config.py,sha256=QKvEUSrHIBrvqu2fRj1MAqxsYxDfcrdQ7dzWdOZejuU,1320
@@ -423,7 +424,7 @@ parsl/tests/test_serialization/test_pack_resource_spec.py,sha256=-Vtyh8KyezZw8e7
 parsl/tests/test_serialization/test_proxystore_configured.py,sha256=lGWOSEWul16enDWhW-s7CK0d3eMDzm1324Fmj0cZMVU,2293
 parsl/tests/test_serialization/test_proxystore_impl.py,sha256=uGd45sfPm9rJhzqKV0rI3lqdSOAUddQf-diEpcJAlcY,1228
 parsl/tests/test_shutdown/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-parsl/tests/test_shutdown/test_kill_monitoring.py,sha256=BycTDLwxhHbbV68Qkgrmn8UUzSr55SvbNvydp35UCTM,1948
+parsl/tests/test_shutdown/test_kill_monitoring.py,sha256=UNU_VeorxRq8mRGhjrDmqF_axZMCQjsPfAK0wh6ZN04,1929
 parsl/tests/test_staging/__init__.py,sha256=WZl9EHSkfYiSoE3Gbulcq2ifmn7IFGUkasJIobL5T5A,208
 parsl/tests/test_staging/staging_provider.py,sha256=6FDpImkWOLgysqM68NbCAoXZciZokI8dmBWRAxnggBk,3242
 parsl/tests/test_staging/test_1316.py,sha256=eS0e2BDM2vmPNF60aDr35wcuGgDPfXjTjRV6kyBZOQc,2652
@@ -457,14 +458,14 @@ parsl/tests/unit/test_usage_tracking.py,sha256=xEfUlbBRpsFdUdOrCsk1Kz5AfmMxJT7f0
 parsl/usage_tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/usage_tracking/api.py,sha256=iaCY58Dc5J4UM7_dJzEEs871P1p1HdxBMtNGyVdzc9g,1821
 parsl/usage_tracking/levels.py,sha256=xbfzYEsd55KiZJ-mzNgPebvOH4rRHum04hROzEf41tU,291
-parsl/usage_tracking/usage.py,sha256=f9k6QcpbQxkGyP5WTC9PVyv0CA05s9NDpRe5wwRdBTM,9163
-parsl-2025.3.17.data/scripts/exec_parsl_function.py,sha256=YXKVVIa4zXmOtz-0Ca4E_5nQfN_3S2bh2tB75uZZB4w,7774
-parsl-2025.3.17.data/scripts/interchange.py,sha256=17MrOc7-FXxKBWTwkzIbUoa8fvvDfPelfjByd3ZD2Wk,29446
-parsl-2025.3.17.data/scripts/parsl_coprocess.py,sha256=zrVjEqQvFOHxsLufPi00xzMONagjVwLZbavPM7bbjK4,5722
-parsl-2025.3.17.data/scripts/process_worker_pool.py,sha256=__gFeFQJpV5moRofj3WKQCnKp6gmzieXjzkmzVuTmX4,41123
-parsl-2025.3.17.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-parsl-2025.3.17.dist-info/METADATA,sha256=d_WFIKY6wmq4VQQcz-BCh0yhu9i3i627EjutSTqSNH4,4023
-parsl-2025.3.17.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-parsl-2025.3.17.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
-parsl-2025.3.17.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
-parsl-2025.3.17.dist-info/RECORD,,
+parsl/usage_tracking/usage.py,sha256=8hq1UPdFlVcC0V3aj0ve-MvCyvwK8Xr3CVuSto3dTW4,9165
+parsl-2025.3.24.data/scripts/exec_parsl_function.py,sha256=YXKVVIa4zXmOtz-0Ca4E_5nQfN_3S2bh2tB75uZZB4w,7774
+parsl-2025.3.24.data/scripts/interchange.py,sha256=17MrOc7-FXxKBWTwkzIbUoa8fvvDfPelfjByd3ZD2Wk,29446
+parsl-2025.3.24.data/scripts/parsl_coprocess.py,sha256=zrVjEqQvFOHxsLufPi00xzMONagjVwLZbavPM7bbjK4,5722
+parsl-2025.3.24.data/scripts/process_worker_pool.py,sha256=__gFeFQJpV5moRofj3WKQCnKp6gmzieXjzkmzVuTmX4,41123
+parsl-2025.3.24.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+parsl-2025.3.24.dist-info/METADATA,sha256=_Wl6Xlf9aCRKSbnQxEquJuYSA3_uNmlLKPgs-2B9nf8,4023
+parsl-2025.3.24.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+parsl-2025.3.24.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
+parsl-2025.3.24.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
+parsl-2025.3.24.dist-info/RECORD,,