parsl 2025.6.16__tar.gz → 2025.6.23__tar.gz

{parsl-2025.6.16/parsl.egg-info → parsl-2025.6.23}/PKG-INFO

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

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/base.py

@@ -98,15 +98,17 @@ class ParslExecutor(metaclass=ABCMeta):
     def shutdown(self) -> None:
         """Shutdown the executor.
 
-        This includes all attached resources such as workers and controllers.
+        Executors should call super().shutdown() as part of their overridden
+        implementation.
         """
         pass
 
     def monitor_resources(self) -> bool:
         """Should resource monitoring happen for tasks on running on this executor?
 
-        Parsl resource monitoring conflicts with execution styles which use threads, and
-        can deadlock while running.
+        Parsl resource monitoring conflicts with execution styles which do
+        not directly use a process tree - for example, the ThreadPoolExecutor
+        and the MPIExecutor.
 
         This function allows resource monitoring to be disabled per executor implementation.
         """

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/flux/executor.py

@@ -248,6 +248,8 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
         if wait:
             self._submission_thread.join()
 
+        super().shutdown()
+
     def submit(
         self,
         func: Callable,

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/globus_compute.py

@@ -134,3 +134,5 @@ class GlobusComputeExecutor(ParslExecutor, RepresentationMixin):
         self.executor.shutdown(wait=False, cancel_futures=True)
         result_watcher = self.executor._get_result_watcher()
         result_watcher.shutdown(wait=False, cancel_futures=True)
+
+        super().shutdown()

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/high_throughput/executor.py

@@ -881,6 +881,8 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         if self.zmq_monitoring:
             self.zmq_monitoring.close()
 
+        super().shutdown()
+
         logger.info("Finished HighThroughputExecutor shutdown attempt")
 
     def get_usage_information(self):

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/high_throughput/mpi_executor.py

@@ -111,3 +111,10 @@ class MPIExecutor(HighThroughputExecutor):
 
     def validate_resource_spec(self, resource_specification: dict):
         return validate_resource_spec(resource_specification)
+
+    def monitor_resources(self):
+        """Resource monitoring does not make sense when using the
+        MPIExecutor, as the process tree launched for each task is spread
+        across multiple OS images/worker nodes.
+        """
+        return False

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/radical/executor.py

@@ -601,6 +601,9 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
             self._bulk_thread.join()
 
         self.session.close(download=True)
+
+        super().shutdown()
+
         logger.info("RadicalPilotExecutor is terminated.")
 
         return True

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/taskvine/executor.py

@@ -601,6 +601,8 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         self._finished_task_queue.close()
         self._finished_task_queue.join_thread()
 
+        super().shutdown()
+
         logger.debug("TaskVine shutdown completed")
 
     @wrap_with_logs

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/threads.py

@@ -73,9 +73,18 @@ class ThreadPoolExecutor(ParslExecutor, RepresentationMixin):
         """
         logger.debug("Shutting down executor, which involves waiting for running tasks to complete")
         self.executor.shutdown(wait=block)
+
+        super().shutdown()
+
         logger.debug("Done with executor shutdown")
 
     def monitor_resources(self):
-        """Resource monitoring sometimes deadlocks when using threads, so this function
-        returns false to disable it."""
+        """Resource monitoring does not make sense when using the
+        ThreadPoolExecutor, as there is no per-task process tree: all tasks
+        run inside the same single submitting process.
+
+        In addition, the use of fork-based multiprocessing in the remote
+        wrapper in parsl/monitoring/remote.py was especially prone to deadlock
+        with this executor.
+        """
         return False

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/executors/workqueue/executor.py

@@ -714,6 +714,8 @@ class WorkQueueExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         self.collector_queue.close()
         self.collector_queue.join_thread()
 
+        super().shutdown()
+
         logger.debug("Work Queue shutdown completed")
 
     @wrap_with_logs

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/errors.py

@@ -1,11 +1,6 @@
 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-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/monitoring.py

@@ -3,16 +3,14 @@ from __future__ import annotations
 import logging
 import multiprocessing.synchronize as ms
 import os
-import queue
 import warnings
 from multiprocessing.queues import Queue
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import Any, Optional, Union
 
 import typeguard
 
-from parsl.monitoring.errors import MonitoringHubStartError
-from parsl.monitoring.radios.filesystem_router import filesystem_router_starter
-from parsl.monitoring.radios.udp_router import udp_router_starter
+from parsl.monitoring.radios.filesystem_router import start_filesystem_receiver
+from parsl.monitoring.radios.udp_router import start_udp_receiver
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
     SizedQueue,
@@ -119,39 +117,14 @@ class MonitoringHub(RepresentationMixin):
 
         self.monitoring_hub_active = True
 
-        # This annotation is incompatible with typeguard 4.x instrumentation
-        # of local variables: Queue is not subscriptable at runtime, as far
-        # as typeguard is concerned. The more general Queue annotation works,
-        # but does not restrict the contents of the Queue. Using TYPE_CHECKING
-        # here allows the stricter definition to be seen by mypy, and the
-        # simpler definition to be seen by typeguard. Hopefully at some point
-        # in the future, Queue will allow runtime subscripts.
-
-        if TYPE_CHECKING:
-            udp_comm_q: Queue[Union[int, str]]
-        else:
-            udp_comm_q: Queue
-
-        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 = 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,
-                                                    "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.udp_receiver = start_udp_receiver(debug=self.monitoring_debug,
+                                               logdir=dfk_run_dir,
+                                               monitoring_messages=self.resource_msgs,
+                                               port=self.hub_port
+                                               )
 
         self.dbm_exit_event: ms.Event
         self.dbm_exit_event = SpawnEvent()
@@ -168,32 +141,15 @@ class MonitoringHub(RepresentationMixin):
                                      )
         self.dbm_proc.start()
         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,
-                                            kwargs={"q": self.resource_msgs,
-                                                    "run_dir": dfk_run_dir,
-                                                    "exit_event": 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)
-
-        try:
-            udp_comm_q_result = udp_comm_q.get(block=True, timeout=120)
-            udp_comm_q.close()
-            udp_comm_q.join_thread()
-        except queue.Empty:
-            logger.error("Monitoring UDP router has not reported port in 120s. Aborting")
-            raise MonitoringHubStartError()
-
-        if isinstance(udp_comm_q_result, str):
-            logger.error("MonitoringRouter sent an error message: %s", udp_comm_q_result)
-            raise RuntimeError(f"MonitoringRouter failed to start: {udp_comm_q_result}")
-
-        udp_port = udp_comm_q_result
-        self.monitoring_hub_url = "udp://{}:{}".format(self.hub_address, udp_port)
+                    self.udp_receiver.process.pid, self.dbm_proc.pid)
+
+        self.filesystem_receiver = start_filesystem_receiver(debug=self.monitoring_debug,
+                                                             logdir=dfk_run_dir,
+                                                             monitoring_messages=self.resource_msgs
+                                                             )
+        logger.info("Started filesystem radio receiver process %s", self.filesystem_receiver.process.pid)
+
+        self.monitoring_hub_url = "udp://{}:{}".format(self.hub_address, self.udp_receiver.port)
 
         logger.info("Monitoring Hub initialized")
 
@@ -202,10 +158,9 @@ class MonitoringHub(RepresentationMixin):
         if self.monitoring_hub_active:
             self.monitoring_hub_active = False
             logger.info("Setting router termination event")
-            self.router_exit_event.set()
 
             logger.info("Waiting for UDP router to terminate")
-            join_terminate_close_proc(self.udp_router_proc)
+            self.udp_receiver.close()
 
             logger.debug("Finished waiting for router termination")
             logger.debug("Waiting for DB termination")
@@ -214,7 +169,7 @@ class MonitoringHub(RepresentationMixin):
             logger.debug("Finished waiting for DBM termination")
 
             logger.info("Terminating filesystem radio receiver process")
-            join_terminate_close_proc(self.filesystem_proc)
+            self.filesystem_receiver.close()
 
             logger.info("Closing monitoring multiprocessing queues")
             self.resource_msgs.close()

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/radios/filesystem.py

@@ -27,7 +27,7 @@ class FilesystemRadioSender(MonitoringRadioSender):
     """
 
     def __init__(self, *, monitoring_url: str, timeout: int = 10, run_dir: str):
-        logger.info("filesystem based monitoring channel initializing")
+        logger.info("filesystem based monitoring radio initializing")
         self.base_path = f"{run_dir}/monitor-fs-radio/"
         self.tmp_path = f"{self.base_path}/tmp"
         self.new_path = f"{self.base_path}/new"

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/radios/filesystem_router.py

@@ -4,6 +4,7 @@ import logging
 import os
 import pickle
 import time
+from multiprocessing.context import SpawnProcess
 from multiprocessing.queues import Queue
 from multiprocessing.synchronize import Event
 from typing import cast
@@ -11,15 +12,17 @@ from typing import cast
 from parsl.log_utils import set_file_logger
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.types import TaggedMonitoringMessage
+from parsl.multiprocessing import SpawnEvent, join_terminate_close_proc
 from parsl.process_loggers import wrap_with_logs
 from parsl.utils import setproctitle
 
+logger = logging.getLogger(__name__)
+
 
 @wrap_with_logs
 def filesystem_router_starter(*, q: Queue[TaggedMonitoringMessage], run_dir: str, exit_event: Event) -> None:
-    logger = set_file_logger(f"{run_dir}/monitoring_filesystem_radio.log",
-                             name="monitoring_filesystem_radio",
-                             level=logging.INFO)
+    set_file_logger(f"{run_dir}/monitoring_filesystem_radio.log",
+                    level=logging.INFO)
 
     logger.info("Starting filesystem radio receiver")
     setproctitle("parsl: monitoring filesystem receiver")
@@ -52,3 +55,32 @@ def filesystem_router_starter(*, q: Queue[TaggedMonitoringMessage], run_dir: str
 
         time.sleep(1)  # whats a good time for this poll?
     logger.info("Ending filesystem radio receiver")
+
+
+class FilesystemRadioReceiver():
+    def __init__(self, *, process: SpawnProcess, exit_event: Event) -> None:
+        self.process = process
+        self.exit_event = exit_event
+
+    def close(self) -> None:
+        self.exit_event.set()
+        join_terminate_close_proc(self.process)
+
+
+def start_filesystem_receiver(*,
+                              monitoring_messages: Queue,
+                              logdir: str,
+                              debug: bool) -> FilesystemRadioReceiver:
+
+    router_exit_event = SpawnEvent()
+
+    filesystem_proc = SpawnProcess(target=filesystem_router_starter,
+                                   kwargs={"q": monitoring_messages,
+                                           "run_dir": logdir,
+                                           "exit_event": router_exit_event},
+                                   name="Monitoring-Filesystem-Process",
+                                   daemon=True
+                                   )
+    filesystem_proc.start()
+
+    return FilesystemRadioReceiver(process=filesystem_proc, exit_event=router_exit_event)

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/radios/htex.py

@@ -18,7 +18,7 @@ class HTEXRadioSender(MonitoringRadioSender):
         timeout : int
             timeout, default=10s
         """
-        logger.info("htex-based monitoring channel initialising")
+        logger.info("htex-based monitoring radio initialising")
 
     def send(self, message: object) -> None:
         """ Sends a message to the UDP receiver

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/radios/udp_router.py

@@ -4,15 +4,26 @@ import logging
 import multiprocessing.queues as mpq
 import os
 import pickle
+import queue
 import socket
 import time
+from multiprocessing.context import SpawnProcess as SpawnProcessType
+from multiprocessing.queues import Queue
 from multiprocessing.synchronize import Event
-from typing import Optional
+from multiprocessing.synchronize import Event as EventType
+from typing import Optional, Union
 
 import typeguard
 
 from parsl.log_utils import set_file_logger
+from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
+from parsl.multiprocessing import (
+    SizedQueue,
+    SpawnEvent,
+    SpawnProcess,
+    join_terminate_close_proc,
+)
 from parsl.process_loggers import wrap_with_logs
 from parsl.utils import setproctitle
 
@@ -48,10 +59,9 @@ class MonitoringRouter:
             An event that the main Parsl process will set to signal that the monitoring router should shut down.
         """
         os.makedirs(run_dir, exist_ok=True)
-        self.logger = set_file_logger(f"{run_dir}/monitoring_udp_router.log",
-                                      name="monitoring_router",
-                                      level=logging_level)
-        self.logger.debug("Monitoring router starting")
+        set_file_logger(f"{run_dir}/monitoring_udp_router.log",
+                        level=logging_level)
+        logger.debug("Monitoring router starting")
 
         self.atexit_timeout = atexit_timeout
 
@@ -73,39 +83,39 @@ class MonitoringRouter:
             except Exception as e:
                 raise RuntimeError(f"Could not bind to udp_port {udp_port} because: {e}")
         self.udp_sock.settimeout(self.loop_freq / 1000)
-        self.logger.info("Initialized the UDP socket on 0.0.0.0:{}".format(self.udp_port))
+        logger.info("Initialized the UDP socket on 0.0.0.0:{}".format(self.udp_port))
 
         self.target_radio = MultiprocessingQueueRadioSender(resource_msgs)
         self.exit_event = exit_event
 
-    @wrap_with_logs(target="monitoring_router")
+    @wrap_with_logs
     def start(self) -> None:
-        self.logger.info("Starting UDP listener")
+        logger.info("Starting UDP listener")
         try:
             while not self.exit_event.is_set():
                 try:
                     data, addr = self.udp_sock.recvfrom(2048)
                     resource_msg = pickle.loads(data)
-                    self.logger.debug("Got UDP Message from {}: {}".format(addr, resource_msg))
+                    logger.debug("Got UDP Message from {}: {}".format(addr, resource_msg))
                     self.target_radio.send(resource_msg)
                 except socket.timeout:
                     pass
 
-            self.logger.info("UDP listener draining")
+            logger.info("UDP listener draining")
             last_msg_received_time = time.time()
             while time.time() - last_msg_received_time < self.atexit_timeout:
                 try:
                     data, addr = self.udp_sock.recvfrom(2048)
                     msg = pickle.loads(data)
-                    self.logger.debug("Got UDP Message from {}: {}".format(addr, msg))
+                    logger.debug("Got UDP Message from {}: {}".format(addr, msg))
                     self.target_radio.send(msg)
                     last_msg_received_time = time.time()
                 except socket.timeout:
                     pass
 
-            self.logger.info("UDP listener finishing normally")
+            logger.info("UDP listener finishing normally")
         finally:
-            self.logger.info("UDP listener finished")
+            logger.info("UDP listener finished")
 
 
 @wrap_with_logs
@@ -132,8 +142,58 @@ def udp_router_starter(*,
     else:
         comm_q.put(router.udp_port)
 
-        router.logger.info("Starting MonitoringRouter in router_starter")
+        logger.info("Starting MonitoringRouter in router_starter")
         try:
             router.start()
         except Exception:
-            router.logger.exception("UDP router start exception")
+            logger.exception("UDP router start exception")
+
+
+class UDPRadioReceiver():
+    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_udp_receiver(*,
+                       monitoring_messages: Queue,
+                       port: Optional[int],
+                       logdir: str,
+                       debug: bool) -> UDPRadioReceiver:
+
+    udp_comm_q: Queue[Union[int, str]]
+    udp_comm_q = SizedQueue(maxsize=10)
+
+    router_exit_event = SpawnEvent()
+
+    router_proc = SpawnProcess(target=udp_router_starter,
+                               kwargs={"comm_q": udp_comm_q,
+                                       "resource_msgs": monitoring_messages,
+                                       "exit_event": router_exit_event,
+                                       "udp_port": port,
+                                       "run_dir": logdir,
+                                       "logging_level": logging.DEBUG if debug else logging.INFO,
+                                       },
+                               name="Monitoring-UDP-Router-Process",
+                               daemon=True,
+                               )
+    router_proc.start()
+
+    try:
+        udp_comm_q_result = udp_comm_q.get(block=True, timeout=120)
+        udp_comm_q.close()
+        udp_comm_q.join_thread()
+    except queue.Empty:
+        logger.error("Monitoring UDP router has not reported port in 120s. Aborting")
+        raise MonitoringRouterStartError()
+
+    if isinstance(udp_comm_q_result, str):
+        logger.error("MonitoringRouter sent an error message: %s", udp_comm_q_result)
+        raise RuntimeError(f"MonitoringRouter failed to start: {udp_comm_q_result}")
+
+    return UDPRadioReceiver(process=router_proc, exit_event=router_exit_event, port=udp_comm_q_result)

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/monitoring/radios/zmq_router.py

@@ -61,10 +61,9 @@ class MonitoringRouter:
             An event that the main Parsl process will set to signal that the monitoring router should shut down.
         """
         os.makedirs(run_dir, exist_ok=True)
-        self.logger = set_file_logger(f"{run_dir}/monitoring_zmq_router.log",
-                                      name="zmq_monitoring_router",
-                                      level=logging_level)
-        self.logger.debug("Monitoring router starting")
+        set_file_logger(f"{run_dir}/monitoring_zmq_router.log",
+                        level=logging_level)
+        logger.debug("Monitoring router starting")
 
         self.address = address
 
@@ -75,7 +74,7 @@ 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("address: {}. port_range {}".format(address, port_range))
+        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])
@@ -83,9 +82,9 @@ class MonitoringRouter:
         self.target_radio = MultiprocessingQueueRadioSender(resource_msgs)
         self.exit_event = exit_event
 
-    @wrap_with_logs(target="zmq_monitoring_router")
+    @wrap_with_logs
     def start(self) -> None:
-        self.logger.info("Starting ZMQ listener")
+        logger.info("Starting ZMQ listener")
         try:
             while not self.exit_event.is_set():
                 try:
@@ -107,11 +106,11 @@ class MonitoringRouter:
                     # channel is broken in such a way that it always raises
                     # an exception? Looping on this would maybe be the wrong
                     # thing to do.
-                    self.logger.warning("Failure processing a ZMQ message", exc_info=True)
+                    logger.warning("Failure processing a ZMQ message", exc_info=True)
 
-            self.logger.info("ZMQ listener finishing normally")
+            logger.info("ZMQ listener finishing normally")
         finally:
-            self.logger.info("ZMQ listener finished")
+            logger.info("ZMQ listener finished")
 
 
 @wrap_with_logs

{parsl-2025.6.16 → parsl-2025.6.23}/parsl/tests/conftest.py

@@ -406,13 +406,15 @@ def try_assert():
         timeout_ms: float = 5000,
         attempts: int = 0,
         check_period_ms: int = 20,
+        factor: float = 2,
     ):
         tb = create_traceback(start=1)
         check_period_s = abs(check_period_ms) / 1000.0
         if attempts > 0:
             for _attempt_no in range(attempts):
-                time.sleep(random.random() * check_period_s)  # jitter
-                check_period_s *= 2
+                fraction = random.random()
+                time.sleep(fraction * check_period_s)  # jitter
+                check_period_s *= factor ** fraction
                 if test_func():
                     return
             else:
@@ -427,9 +429,10 @@ def try_assert():
             timeout_s = abs(timeout_ms) / 1000.0
             end = time.monotonic() + timeout_s
             while time.monotonic() < end:
-                wait_for = random.random() * check_period_s  # jitter
+                fraction = random.random()
+                wait_for = fraction * check_period_s  # jitter
                 time.sleep(min(wait_for, end - time.monotonic()))
-                check_period_s *= 2
+                check_period_s *= factor ** fraction
                 if test_func():
                     return
             att_fail = (

parsl-2025.6.16/parsl/tests/test_monitoring/test_fuzz_zmq.py → parsl-2025.6.23/parsl/tests/test_monitoring/test_htex_fuzz_zmq.py

@@ -17,7 +17,12 @@ def this_app():
 
 
 @pytest.mark.local
-def test_row_counts():
+def test_fuzz():
+    """This test sends fuzz into the ZMQ radio receiver that HTEX starts
+    for receiving monitoring messages from the interchange, and checks
+    that monitoring still records things ok.
+    """
+
     import sqlalchemy
     from sqlalchemy import text
 
@@ -44,7 +49,7 @@ def test_row_counts():
     #   the latter is what i'm most suspicious of in my present investigation
 
     # dig out the interchange port...
-    hub_address = parsl.dfk().monitoring.hub_address
+    hub_address = parsl.dfk().executors["htex_Local"].loopback_address
     hub_zmq_port = parsl.dfk().executors["htex_Local"].hub_zmq_port
 
     # this will send a string to a new socket connection

parsl-2025.6.23/parsl/tests/test_monitoring/test_radio_filesystem.py

@@ -0,0 +1,50 @@
+import pytest
+
+from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.filesystem import FilesystemRadioSender
+from parsl.monitoring.radios.filesystem_router import start_filesystem_receiver
+from parsl.multiprocessing import SpawnQueue
+
+
+@pytest.mark.local
+def test_filesystem(tmpd_cwd):
+    """Test filesystem radio/receiver pair.
+    This test checks that the pair can be started up locally, that a message
+    is conveyed from radio to receiver, and that the receiver process goes
+    away at shutdown.
+    """
+
+    resource_msgs = SpawnQueue()
+
+    # start receiver
+    receiver = start_filesystem_receiver(debug=True,
+                                         logdir=str(tmpd_cwd),
+                                         monitoring_messages=resource_msgs,
+                                         )
+
+    # make radio
+
+    radio_sender = FilesystemRadioSender(run_dir=str(tmpd_cwd),
+                                         monitoring_url="irrelevant:")
+
+    # send message into radio
+
+    message = (MessageType.RESOURCE_INFO, {})
+
+    radio_sender.send(message)
+
+    # verify it comes out of the receiver
+
+    m = resource_msgs.get()
+
+    assert m == message, "The sent message should appear in the queue"
+
+    # shut down router
+
+    receiver.close()
+
+    # we can't inspect the process if it has been closed properly, but
+    # we can verify that it raises the expected ValueError the closed
+    # processes raise on access.
+    with pytest.raises(ValueError):
+        receiver.process.exitcode