parsl 2025.6.16__py3-none-any.whl → 2025.6.30__py3-none-any.whl

parsl/monitoring/radios/udp_router.py

@@ -1,18 +1,31 @@
 from __future__ import annotations
 
+import hmac
 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.base import MonitoringRadioReceiver
 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
 
@@ -26,9 +39,11 @@ class MonitoringRouter:
                  udp_port: Optional[int] = None,
                  run_dir: str = ".",
                  logging_level: int = logging.INFO,
-                 atexit_timeout: int = 3,   # in seconds
+                 atexit_timeout: int,   # in seconds
                  resource_msgs: mpq.Queue,
                  exit_event: Event,
+                 hmac_key: bytes,
+                 hmac_digest: str,
                  ):
         """ Initializes a monitoring configuration class.
 
@@ -48,13 +63,15 @@ 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
 
+        self.hmac_key = hmac_key
+        self.hmac_digest = hmac_digest
+
         self.loop_freq = 10.0  # milliseconds
 
         # Initialize the UDP socket
@@ -73,39 +90,55 @@ 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))
-                    self.target_radio.send(resource_msg)
+                    self.process_message()
                 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))
-                    self.target_radio.send(msg)
+                    self.process_message()
                     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")
+
+    def process_message(self) -> None:
+        hmdata, addr = self.udp_sock.recvfrom(2048)
+        h = hmac.HMAC(key=self.hmac_key, digestmod=self.hmac_digest)
+        origin_hmac = hmdata[0:h.digest_size]
+        h.update(hmdata[h.digest_size:])
+        data = hmdata[h.digest_size:]
+
+        # Check hmac before pickle load.
+        # If data is wrong, do not log it because it is suspect,
+        # but it should be safe to log the addr, at error level.
+
+        recomputed_hmac = h.digest()
+
+        if not hmac.compare_digest(origin_hmac, recomputed_hmac):
+            logger.error("HMAC does not match on received message")
+            # No exception, because this can be arbitrary network noise
+            # that shouldn't break the receiver.
+        else:
+            resource_msg = pickle.loads(data)
+            logger.debug("Got UDP Message from {}: {}".format(addr, resource_msg))
+            self.target_radio.send(resource_msg)
 
 
 @wrap_with_logs
@@ -116,24 +149,85 @@ def udp_router_starter(*,
                        exit_event: Event,
 
                        udp_port: Optional[int],
-
+                       hmac_key: bytes,
                        run_dir: str,
-                       logging_level: int) -> None:
+                       logging_level: int,
+                       atexit_timeout: int,
+                       hmac_digest: str) -> None:
     setproctitle("parsl: monitoring UDP router")
     try:
         router = MonitoringRouter(udp_port=udp_port,
                                   run_dir=run_dir,
                                   logging_level=logging_level,
                                   resource_msgs=resource_msgs,
-                                  exit_event=exit_event)
+                                  exit_event=exit_event,
+                                  atexit_timeout=atexit_timeout,
+                                  hmac_key=hmac_key,
+                                  hmac_digest=hmac_digest)
     except Exception as e:
         logger.error("MonitoringRouter construction failed.", exc_info=True)
         comm_q.put(f"Monitoring router construction failed: {e}")
     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(MonitoringRadioReceiver):
+    def __init__(self, *, process: SpawnProcessType, exit_event: EventType, port: int) -> None:
+        self.process = process
+        self.exit_event = exit_event
+        self.port = port
+
+    def shutdown(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,
+                       atexit_timeout: int,
+                       hmac_key: bytes,
+                       hmac_digest: str) -> 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,
+                                       "atexit_timeout": atexit_timeout,
+                                       "hmac_key": hmac_key,
+                                       "hmac_digest": hmac_digest,
+                                       },
+                               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/monitoring/remote.py

@@ -7,10 +7,7 @@ from multiprocessing import Event
 from typing import Any, Callable, Dict, List, Sequence, Tuple
 
 from parsl.monitoring.message_type import MessageType
-from parsl.monitoring.radios.base import MonitoringRadioSender
-from parsl.monitoring.radios.filesystem import FilesystemRadioSender
-from parsl.monitoring.radios.htex import HTEXRadioSender
-from parsl.monitoring.radios.udp import UDPRadioSender
+from parsl.monitoring.radios.base import RadioConfig
 from parsl.multiprocessing import ForkProcess
 from parsl.process_loggers import wrap_with_logs
 
@@ -23,11 +20,10 @@ def monitor_wrapper(*,
                     kwargs: Dict,     # per invocation
                     x_try_id: int,    # per invocation
                     x_task_id: int,   # per invocation
-                    monitoring_hub_url: str,   # per workflow
+                    radio_config: RadioConfig,   # per executor
                     run_id: str,      # per workflow
                     logging_level: int,  # per workflow
                     sleep_dur: float,  # per workflow
-                    radio_mode: str,   # per executor
                     monitor_resources: bool,  # per workflow
                     run_dir: str) -> Tuple[Callable, Sequence, Dict]:
     """Wrap the Parsl app with a function that will call the monitor function and point it at the correct pid when the task begins.
@@ -41,9 +37,8 @@ def monitor_wrapper(*,
         # Send first message to monitoring router
         send_first_message(try_id,
                            task_id,
-                           monitoring_hub_url,
+                           radio_config,
                            run_id,
-                           radio_mode,
                            run_dir)
 
         if monitor_resources and sleep_dur > 0:
@@ -52,9 +47,8 @@ def monitor_wrapper(*,
                              args=(os.getpid(),
                                    try_id,
                                    task_id,
-                                   monitoring_hub_url,
+                                   radio_config,
                                    run_id,
-                                   radio_mode,
                                    logging_level,
                                    sleep_dur,
                                    run_dir,
@@ -87,9 +81,9 @@ def monitor_wrapper(*,
 
             send_last_message(try_id,
                               task_id,
-                              monitoring_hub_url,
+                              radio_config,
                               run_id,
-                              radio_mode, run_dir)
+                              run_dir)
 
     new_kwargs = kwargs.copy()
     new_kwargs['_parsl_monitoring_task_id'] = x_task_id
@@ -98,47 +92,33 @@ def monitor_wrapper(*,
     return (wrapped, args, new_kwargs)
 
 
-def get_radio(radio_mode: str, monitoring_hub_url: str, task_id: int, run_dir: str) -> MonitoringRadioSender:
-    radio: MonitoringRadioSender
-    if radio_mode == "udp":
-        radio = UDPRadioSender(monitoring_hub_url)
-    elif radio_mode == "htex":
-        radio = HTEXRadioSender(monitoring_hub_url)
-    elif radio_mode == "filesystem":
-        radio = FilesystemRadioSender(monitoring_url=monitoring_hub_url,
-                                      run_dir=run_dir)
-    else:
-        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
-    return radio
-
-
 @wrap_with_logs
 def send_first_message(try_id: int,
                        task_id: int,
-                       monitoring_hub_url: str,
-                       run_id: str, radio_mode: str, run_dir: str) -> None:
-    send_first_last_message(try_id, task_id, monitoring_hub_url, run_id,
-                            radio_mode, run_dir, False)
+                       radio_config: RadioConfig,
+                       run_id: str, run_dir: str) -> None:
+    send_first_last_message(try_id, task_id, radio_config, run_id,
+                            run_dir, False)
 
 
 @wrap_with_logs
 def send_last_message(try_id: int,
                       task_id: int,
-                      monitoring_hub_url: str,
-                      run_id: str, radio_mode: str, run_dir: str) -> None:
-    send_first_last_message(try_id, task_id, monitoring_hub_url, run_id,
-                            radio_mode, run_dir, True)
+                      radio_config: RadioConfig,
+                      run_id: str, run_dir: str) -> None:
+    send_first_last_message(try_id, task_id, radio_config, run_id,
+                            run_dir, True)
 
 
 def send_first_last_message(try_id: int,
                             task_id: int,
-                            monitoring_hub_url: str,
-                            run_id: str, radio_mode: str, run_dir: str,
+                            radio_config: RadioConfig,
+                            run_id: str, run_dir: str,
                             is_last: bool) -> None:
     import os
     import platform
 
-    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
+    radio = radio_config.create_sender()
 
     msg = (MessageType.RESOURCE_INFO,
            {'run_id': run_id,
@@ -158,9 +138,8 @@ def send_first_last_message(try_id: int,
 def monitor(pid: int,
             try_id: int,
             task_id: int,
-            monitoring_hub_url: str,
+            radio_config: RadioConfig,
             run_id: str,
-            radio_mode: str,
             logging_level: int,
             sleep_dur: float,
             run_dir: str,
@@ -184,7 +163,7 @@ def monitor(pid: int,
 
     setproctitle("parsl: task resource monitor")
 
-    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
+    radio = radio_config.create_sender()
 
     logging.debug("start of monitor")
 

parsl/providers/local/local.py

@@ -114,17 +114,15 @@ class LocalProvider(ExecutionProvider, RepresentationMixin):
 
         return [self.resources[jid]['status'] for jid in job_ids]
 
-    def _is_alive(self, job_dict):
-        retcode, stdout, stderr = execute_wait(
-            'ps -p {} > /dev/null 2> /dev/null; echo "STATUS:$?" '.format(
-                job_dict['remote_pid']), self.cmd_timeout)
-        for line in stdout.split('\n'):
-            if line.startswith("STATUS:"):
-                status = line.split("STATUS:")[1].strip()
-                if status == "0":
-                    return True
-                else:
-                    return False
+    @staticmethod
+    def _is_alive(job_dict) -> bool:
+        try:
+            os.kill(job_dict['remote_pid'], 0)
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            pass  # exists; just no permissions to send signal
+        return True
 
     def _job_file_path(self, script_path: str, suffix: str) -> str:
         path = '{0}{1}'.format(script_path, suffix)
@@ -230,8 +228,9 @@ class LocalProvider(ExecutionProvider, RepresentationMixin):
                                   stdout, stderr)
         for line in stdout.split('\n'):
             if line.startswith("PID:"):
-                remote_pid = line.split("PID:")[1].strip()
-                job_id = remote_pid
+                job_id = line.split("PID:")[1].strip()
+                remote_pid = int(job_id)
+                break
         if job_id is None:
             raise SubmitException(job_name, "Channel failed to start remote command/retrieve PID")
 

parsl/tests/configs/htex_local_alternate.py

@@ -59,7 +59,6 @@ def fresh_config():
         app_cache=True, checkpoint_mode='task_exit',
         retries=2,
         monitoring=MonitoringHub(
-                        hub_address="localhost",
                         monitoring_debug=False,
                         resource_monitoring_interval=1,
         ),

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_htex/test_interchange_exit_bad_registration.py

@@ -40,7 +40,7 @@ def test_exit_with_bad_registration(tmpd_cwd, try_assert):
                                            incoming_q.port,
                                            command_client.port),
                           "interchange_address": "127.0.0.1",
-                          "worker_ports": None,
+                          "worker_port": None,
                           "worker_port_range": (50000, 60000),
                           "hub_address": None,
                           "hub_zmq_port": None,
@@ -67,7 +67,7 @@ def test_exit_with_bad_registration(tmpd_cwd, try_assert):
     # responsive. if the interchange process didn't start enough to get the command
     # thread running, this will time out.
 
-    (task_port, result_port) = command_client.run("WORKER_PORTS", timeout_s=120)
+    worker_port = command_client.run("WORKER_BINDS", timeout_s=120)
 
     # now we'll assume that if the interchange command thread is responding,
     # then the worker polling code is also running and that the interchange has
@@ -80,7 +80,7 @@ def test_exit_with_bad_registration(tmpd_cwd, try_assert):
 
     msg = {'type': 'registration',
            'parsl_v': PARSL_VERSION,
-           'python_v': "{}.{}.{}".format(1, 1, 1),  # this is the bad bit
+           'python_v': "1.1.1",  # this is the bad bit
            'worker_count': 1,
            'uid': 'testuid',
            'block_id': 0,
@@ -104,11 +104,9 @@ def test_exit_with_bad_registration(tmpd_cwd, try_assert):
 
     task_channel.set_hwm(0)
     task_channel.setsockopt(zmq.SNDTIMEO, channel_timeout)
-    task_channel.connect(f"tcp://127.0.0.1:{task_port}")
+    task_channel.connect(f"tcp://127.0.0.1:{worker_port}")
 
-    b_msg = json.dumps(msg).encode('utf-8')
-
-    task_channel.send(b_msg)
+    task_channel.send(pickle.dumps(msg))
 
     # check that the interchange exits within some reasonable time
     try_assert(lambda: interchange_proc.poll() is not None, "Interchange did not exit after killing watched client process", timeout_ms=5000)

parsl/tests/test_htex/test_zmq_binding.py

@@ -15,12 +15,12 @@ from parsl.executors.high_throughput.manager_selector import RandomManagerSelect
 def make_interchange(*,
                      interchange_address: Optional[str],
                      cert_dir: Optional[str],
-                     worker_ports: Optional[tuple[int, int]] = None) -> Interchange:
+                     worker_port: Optional[int] = None) -> Interchange:
     return Interchange(interchange_address=interchange_address,
                        cert_dir=cert_dir,
                        client_address="127.0.0.1",
                        client_ports=(50055, 50056, 50057),
-                       worker_ports=worker_ports,
+                       worker_port=worker_port,
                        worker_port_range=(54000, 55000),
                        hub_address=None,
                        hub_zmq_port=None,
@@ -56,7 +56,7 @@ def test_interchange_curvezmq_sockets(
     ix = make_interchange(interchange_address=address, cert_dir=cert_dir)
     assert isinstance(ix.zmq_context, curvezmq.ServerContext)
     assert ix.zmq_context.encrypted is encrypted
-    assert mock_socket.call_count == 5
+    assert mock_socket.call_count == 4
 
 
 @pytest.mark.local
@@ -100,11 +100,10 @@ def test_limited_interface_binding(cert_dir: Optional[str]):
     """When address is specified the worker_port would be bound to it rather than to 0.0.0.0"""
     address = "127.0.0.1"
     ix = make_interchange(interchange_address=address, cert_dir=cert_dir)
-    ix.worker_result_port
     proc = psutil.Process()
     conns = proc.connections(kind="tcp")
 
-    matched_conns = [conn for conn in conns if conn.laddr.port == ix.worker_result_port]
+    matched_conns = [conn for conn in conns if conn.laddr.port == ix.worker_port]
     assert len(matched_conns) == 1
     # laddr.ip can return ::ffff:127.0.0.1 when using IPv6
     assert address in matched_conns[0].laddr.ip
@@ -113,5 +112,5 @@ def test_limited_interface_binding(cert_dir: Optional[str]):
 @pytest.mark.local
 @pytest.mark.parametrize("encrypted", (True, False), indirect=True)
 def test_fixed_ports(cert_dir: Optional[str]):
-    ix = make_interchange(interchange_address=None, cert_dir=cert_dir, worker_ports=(51117, 51118))
+    ix = make_interchange(interchange_address=None, cert_dir=cert_dir, worker_port=51117)
     assert ix.interchange_address == "*"

parsl/tests/test_monitoring/test_basic.py

@@ -8,6 +8,9 @@ from parsl import HighThroughputExecutor, ThreadPoolExecutor
 from parsl.config import Config
 from parsl.executors.status_handling import BlockProviderExecutor
 from parsl.monitoring import MonitoringHub
+from parsl.monitoring.radios.filesystem import FilesystemRadio
+from parsl.monitoring.radios.htex import HTEXRadio
+from parsl.monitoring.radios.udp import UDPRadio
 
 
 @parsl.python_app
@@ -25,9 +28,8 @@ def this_app():
 # a configuration that is suitably configured for monitoring.
 
 def thread_config():
-    c = Config(executors=[ThreadPoolExecutor()],
-               monitoring=MonitoringHub(hub_address="localhost",
-                                        resource_monitoring_interval=0))
+    c = Config(executors=[ThreadPoolExecutor(remote_monitoring_radio=UDPRadio(address="localhost", atexit_timeout=0))],
+               monitoring=MonitoringHub(resource_monitoring_interval=0))
     return c
 
 
@@ -42,9 +44,10 @@ def htex_udp_config():
     from parsl.tests.configs.htex_local_alternate import fresh_config
     c = fresh_config()
     assert len(c.executors) == 1
+    ex = c.executors[0]
 
-    assert c.executors[0].radio_mode == "htex", "precondition: htex has a radio mode attribute, configured for htex radio"
-    c.executors[0].radio_mode = "udp"
+    assert isinstance(ex.remote_monitoring_radio, HTEXRadio), "precondition: htex is configured for the HTEXRadio"
+    ex.remote_monitoring_radio = UDPRadio(address="localhost", atexit_timeout=0)
 
     return c
 
@@ -54,9 +57,10 @@ def htex_filesystem_config():
     from parsl.tests.configs.htex_local_alternate import fresh_config
     c = fresh_config()
     assert len(c.executors) == 1
+    ex = c.executors[0]
 
-    assert c.executors[0].radio_mode == "htex", "precondition: htex has a radio mode attribute, configured for htex radio"
-    c.executors[0].radio_mode = "filesystem"
+    assert isinstance(ex.remote_monitoring_radio, HTEXRadio), "precondition: htex is configured for the HTEXRadio"
+    ex.remote_monitoring_radio = FilesystemRadio()
 
     return c
 
@@ -65,7 +69,6 @@ def workqueue_config():
     from parsl.tests.configs.workqueue_ex import fresh_config
     c = fresh_config()
     c.monitoring = MonitoringHub(
-                        hub_address="localhost",
                         resource_monitoring_interval=1)
     return c
 
@@ -76,8 +79,7 @@ def taskvine_config():
                                            worker_launch_method='provider')],
                strategy_period=0.5,
 
-               monitoring=MonitoringHub(hub_address="localhost",
-                                        resource_monitoring_interval=1))
+               monitoring=MonitoringHub(resource_monitoring_interval=1))
     return c
 
 

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