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

parsl/tests/test_monitoring/test_htex_init_blocks_vs_monitoring.py

@@ -34,7 +34,6 @@ def fresh_config(run_dir, strategy, db_url):
         strategy=strategy,
         strategy_period=0.1,
         monitoring=MonitoringHub(
-                        hub_address="localhost",
                         logging_endpoint=db_url
         )
     )

parsl/tests/test_monitoring/test_radio_filesystem.py

@@ -0,0 +1,48 @@
+import pytest
+
+from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.filesystem import FilesystemRadio
+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()
+
+    radio_config = FilesystemRadio()
+
+    # start receiver
+    receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                            resource_msgs=resource_msgs)
+
+    # make radio
+
+    radio_sender = radio_config.create_sender()
+
+    # 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.shutdown()
+
+    # 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_multiprocessing.py

@@ -0,0 +1,44 @@
+import pytest
+
+from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadio
+from parsl.multiprocessing import SpawnQueue
+
+
+@pytest.mark.local
+def test_radio(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()
+
+    radio_config = MultiprocessingQueueRadio()
+
+    # start receiver
+    receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                            resource_msgs=resource_msgs)
+
+    # make radio
+
+    radio_sender = radio_config.create_sender()
+
+    # 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.
+    # In the multiprocessing radio, nothing happens at shutdown, so this
+    # validates that the call executes without raising an exception, but
+    # not much else.
+    receiver.shutdown()

parsl/tests/test_monitoring/test_radio_udp.py

@@ -0,0 +1,204 @@
+import socket
+import time
+
+import pytest
+
+from parsl.monitoring.message_type import MessageType
+from parsl.monitoring.radios.udp import UDPRadio
+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()
+
+    radio_config = UDPRadio(address="localhost", atexit_timeout=0)
+
+    # start receiver
+    udp_receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                                resource_msgs=resource_msgs)
+
+    # check hash properties
+
+    assert len(radio_config.hmac_key) == 64, "With default hash, should expect 64 byte key"
+
+    # make radio
+
+    radio_sender = radio_config.create_sender()
+
+    # 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.shutdown()
+
+    # 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
+
+
+@pytest.mark.local
+def test_bad_hmac(tmpd_cwd, caplog):
+    """Test when HMAC does not match.
+    """
+
+    resource_msgs = SpawnQueue()
+
+    radio_config = UDPRadio(address="localhost", atexit_timeout=0)
+
+    # start receiver
+    udp_receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                                resource_msgs=resource_msgs)
+
+    # check the hmac is configured in the right place,
+    # then change it to something different (by prepending a new byte)
+    assert radio_config.hmac_key is not None
+    radio_config.hmac_key += b'x'
+
+    # make radio, after changing the HMAC key
+
+    radio_sender = radio_config.create_sender()
+
+    # send message into radio
+
+    message = (MessageType.RESOURCE_INFO, {})
+
+    radio_sender.send(message)
+
+    # We should expect no message from the UDP side. That's hard to
+    # state in this scenario because UDP doesn't have any delivery
+    # guarantees for the test-failing case.
+    # So sleep a while to allow that test to misdeliver and fail.
+    time.sleep(1)
+
+    assert resource_msgs.empty(), "receiving queue should be empty"
+    assert udp_receiver.process.is_alive(), "UDP router process should still be alive"
+
+    with open(f"{tmpd_cwd}/monitoring_udp_router.log", "r") as logfile:
+        assert "ERROR" in logfile.read(), "Router log file should contain an error"
+
+    # shut down router
+
+    udp_receiver.shutdown()
+
+    # 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
+
+
+@pytest.mark.local
+def test_wrong_digest(tmpd_cwd, caplog):
+    """Test when HMAC does not match.
+    """
+
+    resource_msgs = SpawnQueue()
+
+    radio_config = UDPRadio(address="localhost", atexit_timeout=0)
+
+    # start receiver
+    udp_receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                                resource_msgs=resource_msgs)
+
+    # check the hmac is configured in the right place,
+    # then change it to a different digest. The choice of different
+    # digest is arbitrary.
+    assert radio_config.hmac_digest is not None
+    radio_config.hmac_digest = "sha3_224"
+
+    # make radio, after changing the HMAC digest
+
+    radio_sender = radio_config.create_sender()
+
+    # send message into radio
+
+    message = (MessageType.RESOURCE_INFO, {})
+
+    radio_sender.send(message)
+
+    # We should expect no message from the UDP side. That's hard to
+    # state in this scenario because UDP doesn't have any delivery
+    # guarantees for the test-failing case.
+    # So sleep a while to allow that test to misdeliver and fail.
+    time.sleep(1)
+
+    assert resource_msgs.empty(), "receiving queue should be empty"
+    assert udp_receiver.process.is_alive(), "UDP router process should still be alive"
+
+    with open(f"{tmpd_cwd}/monitoring_udp_router.log", "r") as logfile:
+        assert "ERROR" in logfile.read(), "Router log file should contain an error"
+
+    # shut down router
+
+    udp_receiver.shutdown()
+
+    # 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
+
+
+@pytest.mark.local
+def test_short_message(tmpd_cwd, caplog):
+    """Test when UDP message is so short it can't even be parsed into
+    HMAC + the rest.
+    """
+
+    resource_msgs = SpawnQueue()
+
+    radio_config = UDPRadio(address="localhost", atexit_timeout=0)
+
+    # start receiver
+    udp_receiver = radio_config.create_receiver(run_dir=str(tmpd_cwd),
+                                                resource_msgs=resource_msgs)
+
+    # now send a bad UDP message, rather than using the sender mechanism.
+
+    sock = socket.socket(socket.AF_INET,
+                         socket.SOCK_DGRAM,
+                         socket.IPPROTO_UDP)
+
+    sock.sendto(b'', (radio_config.address, radio_config.port))
+    sock.close()
+
+    # We should expect no message from the UDP side. That's hard to
+    # state in this scenario because UDP doesn't have any delivery
+    # guarantees for the test-failing case.
+    # So sleep a while to allow that test to misdeliver and fail.
+    time.sleep(1)
+
+    assert resource_msgs.empty(), "receiving queue should be empty"
+    assert udp_receiver.process.is_alive(), "UDP router process should still be alive"
+
+    with open(f"{tmpd_cwd}/monitoring_udp_router.log", "r") as logfile:
+        assert "ERROR" in logfile.read(), "Router log file should contain an error"
+
+    # shut down router
+
+    udp_receiver.shutdown()
+
+    # 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_monitoring/test_stdouterr.py

@@ -35,9 +35,7 @@ def fresh_config(run_dir):
         ],
         strategy='simple',
         strategy_period=0.1,
-        monitoring=MonitoringHub(
-                        hub_address="localhost",
-        )
+        monitoring=MonitoringHub(),
     )
 
 

parsl/tests/test_scaling/test_worker_interchange_bad_messages_3262.py

@@ -1,7 +1,3 @@
-import os
-import signal
-import time
-
 import pytest
 import zmq
 
@@ -61,11 +57,11 @@ def test_bad_messages(try_assert, msg):
 
     with parsl.load(c):
 
-        # send a bad message into the interchange on the task_outgoing worker
+        # send a bad message into the interchange on the worker_sock worker
         # channel, and then check that the interchange is still alive enough
         # that we can scale out a block and run a task.
 
-        (task_port, result_port) = htex.command_client.run("WORKER_PORTS")
+        worker_port = htex.command_client.run("WORKER_BINDS")
 
         context = zmq.Context()
         channel_timeout = 10000  # in milliseconds
@@ -75,7 +71,7 @@ def test_bad_messages(try_assert, msg):
 
         task_channel.set_hwm(0)
         task_channel.setsockopt(zmq.SNDTIMEO, channel_timeout)
-        task_channel.connect(f"tcp://localhost:{task_port}")
+        task_channel.connect(f"tcp://localhost:{worker_port}")
 
         task_channel.send(msg)
 

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.16'
+VERSION = '2025.06.30'