parsl 2025.6.9__py3-none-any.whl → 2025.6.23__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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,40 +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,
-                                                    "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.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()
@@ -169,30 +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,
-                                            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)
-
-        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")
 
@@ -201,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")
@@ -213,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/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/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)
+def filesystem_router_starter(*, q: Queue[TaggedMonitoringMessage], run_dir: str, exit_event: Event) -> None:
+    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, e
 
         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/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/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
 
@@ -23,10 +34,7 @@ class MonitoringRouter:
 
     def __init__(self,
                  *,
-                 hub_address: str,
                  udp_port: Optional[int] = None,
-
-                 monitoring_hub_address: str = "127.0.0.1",
                  run_dir: str = ".",
                  logging_level: int = logging.INFO,
                  atexit_timeout: int = 3,   # in seconds
@@ -37,8 +45,6 @@ class MonitoringRouter:
 
         Parameters
         ----------
-        hub_address : str
-             The ip address at which the workers will be able to reach the Hub.
         udp_port : int
              The specific port at which workers will be able to reach the Hub via UDP. Default: None
         run_dir : str
@@ -53,12 +59,10 @@ 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.hub_address = hub_address
         self.atexit_timeout = atexit_timeout
 
         self.loop_freq = 10.0  # milliseconds
@@ -79,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
@@ -121,15 +125,13 @@ def udp_router_starter(*,
                        resource_msgs: mpq.Queue,
                        exit_event: Event,
 
-                       hub_address: str,
                        udp_port: Optional[int],
 
                        run_dir: str,
                        logging_level: int) -> None:
     setproctitle("parsl: monitoring UDP router")
     try:
-        router = MonitoringRouter(hub_address=hub_address,
-                                  udp_port=udp_port,
+        router = MonitoringRouter(udp_port=udp_port,
                                   run_dir=run_dir,
                                   logging_level=logging_level,
                                   resource_msgs=resource_msgs,
@@ -140,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/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/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/tests/test_monitoring/{test_fuzz_zmq.py → 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/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

parsl/tests/test_monitoring/test_radio_udp.py

@@ -0,0 +1,53 @@
+import pytest
+
+from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.udp import UDPRadioSender
+from parsl.monitoring.radios.udp_router import start_udp_receiver
+from parsl.multiprocessing import SpawnQueue
+
+
+@pytest.mark.local
+def test_udp(tmpd_cwd):
+    """Test UDP 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
+    udp_receiver = start_udp_receiver(debug=True,
+                                      logdir=str(tmpd_cwd),
+                                      monitoring_messages=resource_msgs,
+                                      port=None
+                                      )
+
+    # make radio
+
+    # this comes from monitoring.py:
+    url = "udp://{}:{}".format("localhost", udp_receiver.port)
+
+    radio_sender = UDPRadioSender(url)
+
+    # 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
+
+    udp_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):
+        udp_receiver.process.exitcode

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", ["udp_router_proc", "dbm_proc", "filesystem_proc"])
+@pytest.mark.parametrize("process_attr", ["dbm_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/version.py

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

{parsl-2025.6.9.dist-info → parsl-2025.6.23.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2025.6.9
+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.09.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.9.dist-info → parsl-2025.6.23.dist-info}/RECORD

@@ -8,7 +8,7 @@ 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=V1z-I8PIxtzsopTNaicGQyPvTgxgd_XObWB24hDcXS4,131
+parsl/version.py,sha256=Ic4ZXjmRNaNVe4VgUeJZzbs04AL3PcIpDFnIlIUjmIQ,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
@@ -61,37 +61,37 @@ 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=_X-huuXKCoQatT_TYx9ApEuXiVVvUYI0S7uKlVMHP-U,4488
+parsl/executors/base.py,sha256=OApNwTcBrzVXweWFPj8rMrP87qStcvF2facsxaevSqA,4568
 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=xIJawhdvnYgHbVd-mQD23Nmlldty13hURoPjOv4I_qE,5276
+parsl/executors/globus_compute.py,sha256=p59iBrv2BvYUAZ3YZSpOrm_Wpai592ueiJm3zFS7gvY,5304
 parsl/executors/status_handling.py,sha256=n2DLASEvKZNgFpviAMYDfqcAsxMiU7QxFemw91YSenc,15746
-parsl/executors/threads.py,sha256=_LA5NA3GSvtjDend-1HVpjoDoNHHW13rAD0CET99fjQ,3463
+parsl/executors/threads.py,sha256=JkbjJGtZPJNzsVF3DFQHOsZpKmFr7wcGbH1wbwDPSrw,3754
 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=ii1i5V7uQnhf1BDq5nnMscmmpXJkCWtrFCuBbDaPyWI,17041
+parsl/executors/flux/executor.py,sha256=NLdjOli5VjrSdEfyWbfqKN_8APvFkp_qFCouS_9NeLQ,17069
 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=x5759lCTIev1yzsJ4OwMp_0me7Cs108HLqKbz1r_zkg,39812
+parsl/executors/high_throughput/executor.py,sha256=JTNgVfZfwzgH9RheMWCCDuNd_1i3LN69B_SYzL7rY3Q,39840
 parsl/executors/high_throughput/interchange.py,sha256=lnPhV-5OR_rp4fa_Wj0tmG3avwUdPgJH4LTTBZQcrf8,28922
 parsl/executors/high_throughput/manager_record.py,sha256=ZMsqFxvreGLRXAw3N-JnODDa9Qfizw2tMmcBhm4lco4,490
 parsl/executors/high_throughput/manager_selector.py,sha256=UKcUE6v0tO7PDMTThpKSKxVpOpOUilxDL7UbNgpZCxo,2116
 parsl/executors/high_throughput/monitoring_info.py,sha256=HC0drp6nlXQpAop5PTUKNjdXMgtZVvrBL0JzZJebPP4,298
-parsl/executors/high_throughput/mpi_executor.py,sha256=U-aatbLF_Mu1p6lP0HmT7Yn1Swn3cc7hPmDfuUb9TpI,4797
+parsl/executors/high_throughput/mpi_executor.py,sha256=AKc5OX7mNH9eYPiBL1g7Xlrj3P-ouniDgE17bhpIems,5052
 parsl/executors/high_throughput/mpi_prefix_composer.py,sha256=DmpKugANNa1bdYlqQBLHkrFc15fJpefPPhW9hkAlh1s,4308
 parsl/executors/high_throughput/mpi_resource_management.py,sha256=73bTW2ZbHRfcrPN318cyjiqDN50AM1cOCQqUGJDIlBg,8199
 parsl/executors/high_throughput/probe.py,sha256=QOEaliO3x5cB6ltMOZMsZQ-ath9AAuFqXcBzRgWOM60,2754
 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=cRxEAPLvdYozCHT_zSj79KAOltfZySFYUbMU4rTbGng,22859
+parsl/executors/radical/executor.py,sha256=e3XS4mvug1uJ6wrt4UH6hBgfbDbc-mQH3xUW2ZmBsMQ,22888
 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=JNGag87n1NYHcevZQaw6aK0JlIqwUuNc0PfYbHQ8o-c,30950
+parsl/executors/taskvine/executor.py,sha256=h47c90QoaeoWcqTdJKgfqwQBZVW-kkF44O95sKUfJ8g,30978
 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=kE0vNN4cSau5p3R6uRDI20THN8e4dBGPHiGKWx5xpo4,49827
+parsl/executors/workqueue/executor.py,sha256=R4cBX3Ac2OePpKsXo-4Kq68X6wAkyltYkhLysk45QwY,49855
 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,23 +115,23 @@ 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=GParOWoCTp2w1Hmif0PaF5J6p5dWVOwyhO18bcvr_uo,277
+parsl/monitoring/errors.py,sha256=pol4Xp9lkpTurc1F5vJ0g48R4R-nUr8GBHubD7SU9Aw,165
 parsl/monitoring/message_type.py,sha256=Khn88afNxcOIciKiCK4GLnn90I5BlRTiOL3zK-P07yQ,401
-parsl/monitoring/monitoring.py,sha256=wWxcBnMSzHEPCXcavxrQQ-1ggNWSLLBc1y7b7v4usBs,9751
+parsl/monitoring/monitoring.py,sha256=8g8JVbR9Nq2JV17EBBwMaFFR-kvKDVd_PWtHyO0vUlQ,7564
 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
 parsl/monitoring/queries/pandas.py,sha256=0Z2r0rjTKCemf0eaDkF1irvVHn5g7KC5SYETvQPRxwU,2232
 parsl/monitoring/radios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/monitoring/radios/base.py,sha256=MBW3aAbxQY7TMuNGZEN15dWoy3mAELOqz-GMN1d7vF4,221
-parsl/monitoring/radios/filesystem.py,sha256=ioZ3jOKX5Qf0DYRtWmpCEorfuMVbS58OMS_QV7DOFOs,1765
-parsl/monitoring/radios/filesystem_router.py,sha256=kQkinktSpsVwfNESfUggSzBlRZ5JgwjM7IDN-jARAhM,2146
-parsl/monitoring/radios/htex.py,sha256=qBu4O5NYnSETHX0ptdwxSpqa2Pp3Z_V6a6lb3TbjKm4,1643
+parsl/monitoring/radios/filesystem.py,sha256=nn9NJ7EteEAixkqS2b0jJ9M7j55xdouXmYiK0qu5AjY,1763
+parsl/monitoring/radios/filesystem_router.py,sha256=T6Okb5deWeLwaugb1Bkskjfdz1_KpM6pX2EyQLey8p4,3312
+parsl/monitoring/radios/htex.py,sha256=1v4on4_KmJa_PuEc3a9OrL4NJV2h0bIuUKh_mdoPVKc,1641
 parsl/monitoring/radios/multiprocessing.py,sha256=fsfaaoMDp6VJv1DSAl-P0R2ofO6jp13byx6NsPItV3Y,655
 parsl/monitoring/radios/udp.py,sha256=bTpt7JYp-5hyBBLzgiLj1_BlSTn28UVp39OYgVGLXCw,1613
-parsl/monitoring/radios/udp_router.py,sha256=LEiHZVhw3lVFhqUK1FAFFtpvNOWbB6RNRBK8FaMvtDw,5771
+parsl/monitoring/radios/udp_router.py,sha256=M7UtHx5dYphKU4YKB2KmkA7aZRtqOFcxuaLVvBn8QJA,7590
 parsl/monitoring/radios/zmq.py,sha256=fhoHp9ylhf-D3eTJb2aSHRsuic8-FJ_oRNGnniGkCAI,592
-parsl/monitoring/radios/zmq_router.py,sha256=ksaWb9bceyFhGGMDC8Nc16JhQ3qpmg8uXQypbrvvtcg,7984
+parsl/monitoring/radios/zmq_router.py,sha256=oqGlOI4OkmvGLNKGp5F0iLFLYj3JdUkpnwg40JOvEak,7826
 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
@@ -196,7 +196,7 @@ parsl/serialize/facade.py,sha256=3uOuVp0epfyLn7qDzuWqLfsy971YVGD3sqwqcAiRwh0,668
 parsl/serialize/proxystore.py,sha256=o-ha9QAvVhbN8y9S1itk3W0O75eyHYZw2AvB2xu5_Lg,1624
 parsl/tests/__init__.py,sha256=VTtJzOzz_x6fWNh8IOnsgFqVbdiJShi2AZH21mcmID4,204
 parsl/tests/callables_helper.py,sha256=ceP1YYsNtrZgKT6MAIvpgdccEjQ_CpFEOnZBGHKGOx0,30
-parsl/tests/conftest.py,sha256=ssY-ZP12a1TXj99ifRc0E83MQjri2bgwvMIe-YF5yd0,15485
+parsl/tests/conftest.py,sha256=PqXpj1AxpPQrcKXJBQ83WIF8TIzZ4-YhAjKQPahE1Tw,15618
 parsl/tests/test_aalst_patterns.py,sha256=lNIxb7nIgh1yX7hR2fr_ck_mxYJxx8ASKK9zHUVqPno,9614
 parsl/tests/test_callables.py,sha256=97vrIF1_hfDGd81FM1bhR6FemZMWFcALrH6pVHMTCt8,1974
 parsl/tests/test_curvezmq.py,sha256=yyhlS4vmaZdMitiySoy4l_ih9H1bsPiN-tMdwIh3H20,12431
@@ -230,7 +230,6 @@ parsl/tests/configs/local_threads_checkpoint_task_exit.py,sha256=zHKN68T-xhAVQwQ
 parsl/tests/configs/local_threads_ftp_in_task.py,sha256=c9odRbxgj1bM_ttpkWTh2Ch_MV7f5cmn-68BOjLeJ70,444
 parsl/tests/configs/local_threads_globus.py,sha256=NhY27cD4vcqLh762Ye0BINZnt63EmTyHXg7FQMffOBw,1097
 parsl/tests/configs/local_threads_http_in_task.py,sha256=csDY-C50tXKO2ntbbPBvppCRlXBcB7UCQOHN_FyfFYc,447
-parsl/tests/configs/local_threads_monitoring.py,sha256=me-wWCtDwg_CGLQ7j4JRXcc_YTq3FGrffznjht07L08,368
 parsl/tests/configs/local_threads_no_cache.py,sha256=2LM8rYhl62LIFUMjAs2_VI_R25YW5AI3RfVK_e5bdN8,236
 parsl/tests/configs/midway.py,sha256=ZLdAUDR5paPA8gheRNLI0q9Vj5HcnCYuIttu-C-TlJs,1335
 parsl/tests/configs/nscc_singapore.py,sha256=ECENZcBuCjkY6OWZstEMhfMrmjRmjCc7ELdfGEp7ly4,1481
@@ -254,7 +253,6 @@ parsl/tests/manual_tests/test_basic.py,sha256=3uCS9BqaZmKTNtNfJSsJIg2exlTAdC0Sdc
 parsl/tests/manual_tests/test_log_filter.py,sha256=jwKclAVuESdlGK_giBuHDkY6ryX6rZB7q01lXT5K0XU,1872
 parsl/tests/manual_tests/test_memory_limits.py,sha256=fjQhGsZu1PUl2Z4v75mssqve51QmtVrK94q9zJWQefU,2593
 parsl/tests/manual_tests/test_regression_220.py,sha256=Jo2puWt1W0r1rJfaJFgd2ZPgR3i6uOXzrLRcfYDZWDo,931
-parsl/tests/manual_tests/test_udp_simple.py,sha256=cleSqvzblTFN6sCG0egQtLYVSQeCo7JMpCMjYKjBZUw,1009
 parsl/tests/manual_tests/test_worker_count.py,sha256=Cv8nAWMXAREiiGEBUr_8JyI87ffp8JGAyDqVXzcjX_0,2072
 parsl/tests/scaling_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/tests/scaling_tests/htex_local.py,sha256=opgR-l18aunWeReuqBvNP7nSAk8CpsYqhAZE9PNPV8M,483
@@ -341,10 +339,12 @@ parsl/tests/test_monitoring/test_app_names.py,sha256=A-mOMCVhZDnUyJp32fsTUkHdcyv
 parsl/tests/test_monitoring/test_basic.py,sha256=QJS0SJkf1KV6A4UvikBu-wAIcBJZVoVe-BSVWgyFonI,6180
 parsl/tests/test_monitoring/test_db_locks.py,sha256=3s3c1xhKo230ZZIJ3f1Ca4U7LcEdXnanOGVXQyNlk2U,2895
 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_fuzz_zmq.py,sha256=MUaVBVjmoKSVg00DlMIRdj9KUizYvHjzW95Y3n_ViqE,3659
 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_radio_filesystem.py,sha256=hA-RXmU29nEG4Dm6eLcyVYoTdGog_wvYDcvNsN5-3lU,1531
+parsl/tests/test_monitoring/test_radio_udp.py,sha256=dyb9SOY-ceSuZ4R2rAIn-7DqsRljYl4U6zNdACyCACU,1538
 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
@@ -425,7 +425,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=UNU_VeorxRq8mRGhjrDmqF_axZMCQjsPfAK0wh6ZN04,1929
+parsl/tests/test_shutdown/test_kill_monitoring.py,sha256=yWeYgizqGAq1ezlKWwRrJGcc0U9d2Vuzp0YuXYO1b20,1891
 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
@@ -460,13 +460,13 @@ parsl/usage_tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 parsl/usage_tracking/api.py,sha256=iaCY58Dc5J4UM7_dJzEEs871P1p1HdxBMtNGyVdzc9g,1821
 parsl/usage_tracking/levels.py,sha256=xbfzYEsd55KiZJ-mzNgPebvOH4rRHum04hROzEf41tU,291
 parsl/usage_tracking/usage.py,sha256=hbMo5BYgIWqMcFWqN-HYP1TbwNrTonpv-usfwnCFJKY,9212
-parsl-2025.6.9.data/scripts/exec_parsl_function.py,sha256=YXKVVIa4zXmOtz-0Ca4E_5nQfN_3S2bh2tB75uZZB4w,7774
-parsl-2025.6.9.data/scripts/interchange.py,sha256=_FRB1LxkL9vnT3y24NTXHOzotMlDJEXwF5ZZCjGmcww,28909
-parsl-2025.6.9.data/scripts/parsl_coprocess.py,sha256=zrVjEqQvFOHxsLufPi00xzMONagjVwLZbavPM7bbjK4,5722
-parsl-2025.6.9.data/scripts/process_worker_pool.py,sha256=__gFeFQJpV5moRofj3WKQCnKp6gmzieXjzkmzVuTmX4,41123
-parsl-2025.6.9.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-parsl-2025.6.9.dist-info/METADATA,sha256=yAjU-1rMVRSwg9zcdOsAHwW9IOAEkzyILXM2AbEgRhM,4054
-parsl-2025.6.9.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-parsl-2025.6.9.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
-parsl-2025.6.9.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
-parsl-2025.6.9.dist-info/RECORD,,
+parsl-2025.6.23.data/scripts/exec_parsl_function.py,sha256=YXKVVIa4zXmOtz-0Ca4E_5nQfN_3S2bh2tB75uZZB4w,7774
+parsl-2025.6.23.data/scripts/interchange.py,sha256=_FRB1LxkL9vnT3y24NTXHOzotMlDJEXwF5ZZCjGmcww,28909
+parsl-2025.6.23.data/scripts/parsl_coprocess.py,sha256=zrVjEqQvFOHxsLufPi00xzMONagjVwLZbavPM7bbjK4,5722
+parsl-2025.6.23.data/scripts/process_worker_pool.py,sha256=__gFeFQJpV5moRofj3WKQCnKp6gmzieXjzkmzVuTmX4,41123
+parsl-2025.6.23.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+parsl-2025.6.23.dist-info/METADATA,sha256=MzCr6YRZ0einE2SSqmtGkBDaX8tdfR0I57QP3W3QOXE,4055
+parsl-2025.6.23.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+parsl-2025.6.23.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
+parsl-2025.6.23.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
+parsl-2025.6.23.dist-info/RECORD,,

parsl/tests/configs/local_threads_monitoring.py

@@ -1,10 +0,0 @@
-from parsl import ThreadPoolExecutor
-from parsl.config import Config
-from parsl.monitoring import MonitoringHub
-
-config = Config(executors=[ThreadPoolExecutor(label='threads', max_threads=4)],
-                monitoring=MonitoringHub(
-                    hub_address="localhost",
-                    resource_monitoring_interval=3,
-                )
-                )

parsl/tests/manual_tests/test_udp_simple.py

@@ -1,51 +0,0 @@
-import logging
-
-import parsl
-from parsl import python_app
-from parsl.config import Config
-from parsl.executors import ThreadPoolExecutor
-from parsl.monitoring.monitoring import MonitoringHub
-
-
-def local_setup():
-    threads_config = Config(
-        executors=[ThreadPoolExecutor(
-            label='threads',
-            max_threads=4)
-        ],
-        monitoring=MonitoringHub(
-            hub_address="127.0.0.1",
-            logging_level=logging.INFO,
-            resource_monitoring_interval=10))
-
-    parsl.load(threads_config)
-
-
-def local_teardown():
-    parsl.clear()
-
-
-@python_app
-def sleeper(dur=25):
-    import time
-    time.sleep(dur)
-
-
-@python_app
-def cpu_stress(dur=30):
-    import time
-    s = 0
-    start = time.time()
-    for i in range(10**8):
-        s += i
-        if time.time() - start >= dur:
-            break
-    return s
-
-
-if __name__ == "__main__":
-
-    tasks = [sleeper() for i in range(8)]
-    # tasks = [cpu_stress() for i in range(10)]
-
-    print([i.result() for i in tasks])