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

parsl/monitoring/monitoring.py

@@ -4,9 +4,9 @@ import logging
 import multiprocessing.synchronize as ms
 import os
 import queue
-from multiprocessing import Event
+import warnings
 from multiprocessing.queues import Queue
-from typing import TYPE_CHECKING, Literal, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import typeguard
 
@@ -14,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]
@@ -37,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,
@@ -56,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
@@ -88,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
@@ -119,91 +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.exception_q: Queue[Tuple[str, str]]
-        self.exception_q = SizedQueue(maxsize=10)
-
-        self.resource_msgs: Queue[Union[TaggedMonitoringMessage, Literal["STOP"]]]
+        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,
-                                                   "exception_q": self.exception_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,
-                                                   "exception_q": self.exception_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_proc = ForkProcess(target=dbm_starter,
-                                    args=(self.exception_q, 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,
-                                            },
-                                    name="Monitoring-DBM-Process",
-                                    daemon=True,
-                                    )
+        self.dbm_exit_event: ms.Event
+        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),
-                                           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()
@@ -227,58 +205,24 @@ class MonitoringHub(RepresentationMixin):
 
     def close(self) -> None:
         logger.info("Terminating Monitoring Hub")
-        exception_msgs = []
-        while True:
-            try:
-                exception_msgs.append(self.exception_q.get(block=False))
-                logger.error("There was a queued exception (Either router or DBM process got exception much earlier?)")
-            except queue.Empty:
-                break
         if self.monitoring_hub_active:
             self.monitoring_hub_active = False
-            if exception_msgs:
-                for exception_msg in exception_msgs:
-                    logger.error(
-                        "%s process delivered an exception: %s. Terminating all monitoring processes immediately.",
-                        exception_msg[0],
-                        exception_msg[1]
-                    )
-                self.zmq_router_proc.terminate()
-                self.udp_router_proc.terminate()
-                self.dbm_proc.terminate()
-                self.filesystem_proc.terminate()
             logger.info("Setting router termination event")
             self.router_exit_event.set()
 
-            logger.info("Waiting for ZMQ router to terminate")
-            self.zmq_router_proc.join()
-            self.zmq_router_proc.close()
-
             logger.info("Waiting for UDP router to terminate")
-            self.udp_router_proc.join()
-            self.udp_router_proc.close()
+            join_terminate_close_proc(self.udp_router_proc)
 
             logger.debug("Finished waiting for router termination")
-            if len(exception_msgs) == 0:
-                logger.debug("Sending STOP to DBM")
-                self.resource_msgs.put("STOP")
-            else:
-                logger.debug("Not sending STOP to DBM, because there were DBM exceptions")
             logger.debug("Waiting for DB termination")
-            self.dbm_proc.join()
-            self.dbm_proc.close()
+            self.dbm_exit_event.set()
+            join_terminate_close_proc(self.dbm_proc)
             logger.debug("Finished waiting for DBM termination")
 
-            # should this be message based? it probably doesn't need to be if
-            # we believe we've received all messages
             logger.info("Terminating filesystem radio receiver process")
-            self.filesystem_proc.terminate()
-            self.filesystem_proc.join()
-            self.filesystem_proc.close()
+            join_terminate_close_proc(self.filesystem_proc)
 
             logger.info("Closing monitoring multiprocessing queues")
-            self.exception_q.close()
-            self.exception_q.join_thread()
             self.resource_msgs.close()
             self.resource_msgs.join_thread()
             logger.info("Closed monitoring multiprocessing queues")

parsl/monitoring/radios/filesystem_router.py

@@ -5,6 +5,7 @@ import os
 import pickle
 import time
 from multiprocessing.queues import Queue
+from multiprocessing.synchronize import Event
 from typing import cast
 
 from parsl.log_utils import set_file_logger
@@ -15,7 +16,7 @@ from parsl.utils import setproctitle
 
 
 @wrap_with_logs
-def filesystem_router_starter(q: Queue[TaggedMonitoringMessage], run_dir: str) -> None:
+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)
@@ -32,7 +33,7 @@ def filesystem_router_starter(q: Queue[TaggedMonitoringMessage], run_dir: str) -
     os.makedirs(tmp_dir, exist_ok=True)
     os.makedirs(new_dir, exist_ok=True)
 
-    while True:  # this loop will end on process termination
+    while not exit_event.is_set():
         logger.debug("Start filesystem radio receiver loop")
 
         # iterate over files in new_dir
@@ -50,3 +51,4 @@ def filesystem_router_starter(q: Queue[TaggedMonitoringMessage], run_dir: str) -
                 logger.exception("Exception processing %s - probably will be retried next iteration", filename)
 
         time.sleep(1)  # whats a good time for this poll?
+    logger.info("Ending filesystem radio receiver")

parsl/monitoring/radios/udp_router.py

@@ -118,7 +118,6 @@ class MonitoringRouter:
 @typeguard.typechecked
 def udp_router_starter(*,
                        comm_q: mpq.Queue,
-                       exception_q: mpq.Queue,
                        resource_msgs: mpq.Queue,
                        exit_event: Event,
 
@@ -144,6 +143,5 @@ def udp_router_starter(*,
         router.logger.info("Starting MonitoringRouter in router_starter")
         try:
             router.start()
-        except Exception as e:
+        except Exception:
             router.logger.exception("UDP router start exception")
-            exception_q.put(('Hub', str(e)))

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:
@@ -107,19 +118,18 @@ class MonitoringRouter:
 @typeguard.typechecked
 def zmq_router_starter(*,
                        comm_q: mpq.Queue,
-                       exception_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,10 +139,55 @@ def zmq_router_starter(*,
         comm_q.put(f"Monitoring router construction failed: {e}")
     else:
         comm_q.put(router.zmq_receiver_port)
+        router.start()
 
-        router.logger.info("Starting MonitoringRouter in router_starter")
-        try:
-            router.start()
-        except Exception as e:
-            router.logger.exception("ZMQ router start exception")
-            exception_q.put(('Hub', str(e)))
+
+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

@@ -0,0 +1,54 @@
+import multiprocessing
+import signal
+
+import psutil
+import pytest
+
+from parsl.multiprocessing import SpawnEvent, SpawnProcess, join_terminate_close_proc
+
+
+def noop():
+    pass
+
+
+@pytest.mark.local
+def test_end_process_already_exited():
+    p = SpawnProcess(target=noop)
+    p.start()
+    p.join()
+    join_terminate_close_proc(p)
+
+
+def hang():
+    while True:
+        pass
+
+
+@pytest.mark.local
+def test_end_hung_process():
+    """Test calling against a process that will not exit itself."""
+    p = SpawnProcess(target=hang)
+    p.start()
+    pid = p.pid
+    join_terminate_close_proc(p, timeout=1)
+    assert not psutil.pid_exists(pid), "process should not exist any more"
+
+
+def hang_no_sigint(e):
+    def s(*args, **kwargs):
+        e.set()
+    signal.signal(signal.SIGTERM, s)
+    while True:
+        pass
+
+
+@pytest.mark.local
+def test_end_hung_process_no_sigint():
+    """Test calling against a process that will not exit itself."""
+    e = SpawnEvent()
+    p = SpawnProcess(target=hang_no_sigint, args=(e,))
+    p.start()
+    pid = p.pid
+    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