parsl 2024.3.11__py3-none-any.whl → 2025.1.13__py3-none-any.whl

parsl/tests/test_monitoring/test_basic.py

@@ -1,10 +1,13 @@
-import logging
 import os
-import parsl
-import pytest
 import time
 
-logger = logging.getLogger(__name__)
+import pytest
+
+import parsl
+from parsl import HighThroughputExecutor
+from parsl.config import Config
+from parsl.executors.taskvine import TaskVineExecutor, TaskVineManagerConfig
+from parsl.monitoring import MonitoringHub
 
 
 @parsl.python_app
@@ -18,34 +21,79 @@ def this_app():
     return 5
 
 
+# The below fresh configs are for use in parametrization, and should return
+# a configuration that is suitably configured for monitoring.
+
+def htex_config():
+    """This config will use htex's default htex-specific monitoring radio mode"""
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+    return fresh_config()
+
+
+def htex_udp_config():
+    """This config will force UDP"""
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+    c = fresh_config()
+    assert len(c.executors) == 1
+
+    assert c.executors[0].radio_mode == "htex", "precondition: htex has a radio mode attribute, configured for htex radio"
+    c.executors[0].radio_mode = "udp"
+
+    return c
+
+
+def htex_filesystem_config():
+    """This config will force filesystem radio"""
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+    c = fresh_config()
+    assert len(c.executors) == 1
+
+    assert c.executors[0].radio_mode == "htex", "precondition: htex has a radio mode attribute, configured for htex radio"
+    c.executors[0].radio_mode = "filesystem"
+
+    return c
+
+
+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
+
+
+def taskvine_config():
+    c = Config(executors=[TaskVineExecutor(manager_config=TaskVineManagerConfig(port=9000),
+                                           worker_launch_method='provider')],
+
+               monitoring=MonitoringHub(hub_address="localhost",
+                                        resource_monitoring_interval=1))
+    return c
+
+
 @pytest.mark.local
-def test_row_counts():
+@pytest.mark.parametrize("fresh_config", [htex_config, htex_filesystem_config, htex_udp_config, workqueue_config, taskvine_config])
+def test_row_counts(tmpd_cwd, fresh_config):
     # this is imported here rather than at module level because
     # it isn't available in a plain parsl install, so this module
     # would otherwise fail to import and break even a basic test
     # run.
     import sqlalchemy
     from sqlalchemy import text
-    from parsl.tests.configs.htex_local_alternate import fresh_config
 
-    if os.path.exists("runinfo/monitoring.db"):
-        logger.info("Monitoring database already exists - deleting")
-        os.remove("runinfo/monitoring.db")
+    db_url = f"sqlite:///{tmpd_cwd}/monitoring.db"
 
-    logger.info("loading parsl")
-    parsl.load(fresh_config())
+    config = fresh_config()
+    config.run_dir = tmpd_cwd
+    config.monitoring.logging_endpoint = db_url
 
-    logger.info("invoking and waiting for result")
-    assert this_app().result() == 5
-
-    logger.info("cleaning up parsl")
-    parsl.dfk().cleanup()
-    parsl.clear()
+    with parsl.load(config):
+        assert this_app().result() == 5
 
     # at this point, we should find one row in the monitoring database.
 
-    logger.info("checking database content")
-    engine = sqlalchemy.create_engine("sqlite:///runinfo/monitoring.db")
+    engine = sqlalchemy.create_engine(db_url)
     with engine.begin() as connection:
 
         result = connection.execute(text("SELECT COUNT(*) FROM workflow"))
@@ -67,10 +115,12 @@ def test_row_counts():
         (c, ) = result.first()
         assert c == 0
 
-        # Two entries: one showing manager active, one inactive
-        result = connection.execute(text("SELECT COUNT(*) FROM node"))
-        (c, ) = result.first()
-        assert c == 2
+        if isinstance(config.executors[0], HighThroughputExecutor):
+            # The node table is specific to the HighThroughputExecutor
+            # Two entries: one showing manager active, one inactive
+            result = connection.execute(text("SELECT COUNT(*) FROM node"))
+            (c, ) = result.first()
+            assert c == 2
 
         # There should be one block polling status
         # local provider has a status_polling_interval of 5s
@@ -81,5 +131,3 @@ def test_row_counts():
         result = connection.execute(text("SELECT COUNT(*) FROM resource"))
         (c, ) = result.first()
         assert c >= 1
-
-    logger.info("all done")

parsl/tests/test_monitoring/test_db_locks.py

@@ -1,9 +1,11 @@
 import logging
 import os
-import parsl
-import pytest
 import time
 
+import pytest
+
+import parsl
+
 logger = logging.getLogger(__name__)
 
 
@@ -14,9 +16,10 @@ def this_app():
 
 @pytest.mark.local
 def test_row_counts():
-    from parsl.tests.configs.htex_local_alternate import fresh_config
     import sqlalchemy
     from sqlalchemy import text
+
+    from parsl.tests.configs.htex_local_alternate import fresh_config
     if os.path.exists("runinfo/monitoring.db"):
         logger.info("Monitoring database already exists - deleting")
         os.remove("runinfo/monitoring.db")
@@ -63,7 +66,6 @@ def test_row_counts():
 
     logger.info("cleaning up parsl")
     parsl.dfk().cleanup()
-    parsl.clear()
 
     # at this point, we should find data consistent with executing one
     # task in the database.

parsl/tests/test_monitoring/test_fuzz_zmq.py

@@ -1,10 +1,13 @@
 import logging
 import os
-import parsl
-import pytest
 import socket
 import time
 
+import pytest
+import zmq
+
+import parsl
+
 logger = logging.getLogger(__name__)
 
 
@@ -15,10 +18,11 @@ def this_app():
 
 @pytest.mark.local
 def test_row_counts():
-    from parsl.tests.configs.htex_local_alternate import fresh_config
     import sqlalchemy
     from sqlalchemy import text
 
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+
     if os.path.exists("runinfo/monitoring.db"):
         logger.info("Monitoring database already exists - deleting")
         os.remove("runinfo/monitoring.db")
@@ -40,16 +44,24 @@ 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().hub_address
-    hub_interchange_port = parsl.dfk().hub_interchange_port
+    hub_address = parsl.dfk().monitoring.hub_address
+    hub_zmq_port = parsl.dfk().monitoring.hub_zmq_port
 
     # this will send a string to a new socket connection
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.connect((hub_address, hub_interchange_port))
+        s.connect((hub_address, hub_zmq_port))
         s.sendall(b'fuzzing\r')
 
+    context = zmq.Context()
+    channel_timeout = 10000  # in milliseconds
+    hub_channel = context.socket(zmq.DEALER)
+    hub_channel.setsockopt(zmq.LINGER, 0)
+    hub_channel.set_hwm(0)
+    hub_channel.setsockopt(zmq.SNDTIMEO, channel_timeout)
+    hub_channel.connect("tcp://{}:{}".format(hub_address, hub_zmq_port))
+
     # this will send a non-object down the DFK's existing ZMQ connection
-    parsl.dfk().monitoring._dfk_channel.send(b'FuzzyByte\rSTREAM')
+    hub_channel.send(b'FuzzyByte\rSTREAM')
 
     # This following attack is commented out, because monitoring is not resilient
     # to this.
@@ -74,7 +86,6 @@ def test_row_counts():
 
     logger.info("cleaning up parsl")
     parsl.dfk().cleanup()
-    parsl.clear()
 
     # at this point, we should find one row in the monitoring database.
 

parsl/tests/test_monitoring/test_htex_init_blocks_vs_monitoring.py

@@ -0,0 +1,80 @@
+import logging
+import os
+import time
+
+import pytest
+
+import parsl
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SimpleLauncher
+from parsl.monitoring import MonitoringHub
+from parsl.providers import LocalProvider
+
+
+def fresh_config(run_dir, strategy, db_url):
+    return Config(
+        run_dir=os.fspath(run_dir),
+        executors=[
+            HighThroughputExecutor(
+                label="htex_local",
+                cores_per_worker=1,
+                encrypted=True,
+                provider=LocalProvider(
+                    init_blocks=1,
+                    # min and max are set to 0 to ensure that we don't get
+                    # a block from ongoing strategy scaling, only from
+                    # init_blocks
+                    min_blocks=0,
+                    max_blocks=0,
+                    launcher=SimpleLauncher(),
+                ),
+            )
+        ],
+        strategy=strategy,
+        strategy_period=0.1,
+        monitoring=MonitoringHub(
+                        hub_address="localhost",
+                        logging_endpoint=db_url
+        )
+    )
+
+
+@parsl.python_app
+def this_app():
+    pass
+
+
+@pytest.mark.local
+@pytest.mark.parametrize("strategy", ('none', 'simple', 'htex_auto_scale'))
+def test_row_counts(tmpd_cwd, strategy):
+    # this is imported here rather than at module level because
+    # it isn't available in a plain parsl install, so this module
+    # would otherwise fail to import and break even a basic test
+    # run.
+    import sqlalchemy
+    from sqlalchemy import text
+
+    db_url = f"sqlite:///{tmpd_cwd}/monitoring.db"
+    with parsl.load(fresh_config(tmpd_cwd, strategy, db_url)):
+        dfk = parsl.dfk()
+        run_id = dfk.run_id
+
+        this_app().result()
+
+    engine = sqlalchemy.create_engine(db_url)
+    with engine.begin() as connection:
+
+        binds = {"run_id": run_id}
+
+        result = connection.execute(text("SELECT COUNT(DISTINCT block_id) FROM block WHERE run_id = :run_id"), binds)
+        (c, ) = result.first()
+        assert c == 1, "We should see a single block in this database"
+
+        result = connection.execute(text("SELECT COUNT(*) FROM block WHERE block_id = 0 AND status = 'PENDING' AND run_id = :run_id"), binds)
+        (c, ) = result.first()
+        assert c == 1, "There should be a single pending status"
+
+        result = connection.execute(text("SELECT COUNT(*) FROM block WHERE block_id = 0 AND status = 'SCALED_IN' AND run_id = :run_id"), binds)
+        (c, ) = result.first()
+        assert c == 1, "There should be a single cancelled status"

parsl/tests/test_monitoring/test_incomplete_futures.py

@@ -1,11 +1,12 @@
 import logging
 import os
-import parsl
-import pytest
 import random
-
 from concurrent.futures import Future
 
+import pytest
+
+import parsl
+
 
 @parsl.python_app
 def this_app(inputs=()):
@@ -16,6 +17,7 @@ def this_app(inputs=()):
 def test_future_representation(tmpd_cwd):
     import sqlalchemy
     from sqlalchemy import text
+
     from parsl.tests.configs.htex_local_alternate import fresh_config
 
     monitoring_db = str(tmpd_cwd / "monitoring.db")
@@ -52,7 +54,6 @@ def test_future_representation(tmpd_cwd):
     # seconds, with the assumption "data will arrive in the DB within
     # 30 seconds, but probably much sooner".
     parsl.dfk().cleanup()
-    parsl.clear()
 
     engine = sqlalchemy.create_engine(monitoring_url)
     with engine.begin() as connection:

parsl/tests/test_monitoring/test_memoization_representation.py

@@ -1,9 +1,11 @@
 
 import logging
 import os
-import parsl
+
 import pytest
 
+import parsl
+
 logger = logging.getLogger(__name__)
 
 
@@ -16,6 +18,7 @@ def this_app(x):
 def test_hashsum():
     import sqlalchemy
     from sqlalchemy import text
+
     from parsl.tests.configs.htex_local_alternate import fresh_config
 
     if os.path.exists("runinfo/monitoring.db"):
@@ -47,7 +50,6 @@ def test_hashsum():
 
     logger.info("cleaning up parsl")
     parsl.dfk().cleanup()
-    parsl.clear()
 
     # at this point, we should find one row in the monitoring database.
 

parsl/tests/test_monitoring/test_stdouterr.py

@@ -0,0 +1,134 @@
+"""Tests monitoring records app name under various decoration patterns.
+"""
+
+import logging
+import os
+import re
+import time
+from typing import Union
+
+import pytest
+
+import parsl
+from parsl.config import Config
+from parsl.data_provider.data_manager import default_staging
+from parsl.data_provider.files import File
+from parsl.data_provider.staging import Staging
+from parsl.executors import HighThroughputExecutor
+from parsl.monitoring import MonitoringHub
+from parsl.providers import LocalProvider
+
+
+def fresh_config(run_dir):
+    return Config(
+        run_dir=str(run_dir),
+        executors=[
+            HighThroughputExecutor(
+                address="127.0.0.1",
+                label="htex_Local",
+                provider=LocalProvider(
+                    init_blocks=1,
+                    min_blocks=1,
+                    max_blocks=1,
+                )
+            )
+        ],
+        strategy='simple',
+        strategy_period=0.1,
+        monitoring=MonitoringHub(
+                        hub_address="localhost",
+        )
+    )
+
+
+@parsl.python_app
+def stdapp(stdout=None, stderr=None):
+    pass
+
+
+class ArbitraryPathLike(os.PathLike):
+    def __init__(self, path: Union[str, bytes]) -> None:
+        self.path = path
+
+    def __fspath__(self) -> Union[str, bytes]:
+        return self.path
+
+
+class ArbitraryStaging(Staging):
+    """This staging provider will not actually do any staging, but will
+    accept arbitrary: scheme URLs. That's enough for this monitoring test
+    which doesn't need any actual stage out action to happen.
+    """
+    def can_stage_out(self, file):
+        return file.scheme == "arbitrary"
+
+
+@pytest.mark.local
+@pytest.mark.parametrize('stdx,expected_stdx',
+                         [('hello.txt', 'hello.txt'),
+                          (None, ''),
+                          (('tuple.txt', 'w'), 'tuple.txt'),
+                          (ArbitraryPathLike('pl.txt'), 'pl.txt'),
+                          (ArbitraryPathLike(b'pl2.txt'), 'pl2.txt'),
+                          ((ArbitraryPathLike('pl3.txt'), 'w'), 'pl3.txt'),
+                          ((ArbitraryPathLike(b'pl4.txt'), 'w'), 'pl4.txt'),
+                          (parsl.AUTO_LOGNAME,
+                              lambda p:
+                              isinstance(p, str) and
+                              os.path.isabs(p) and
+                              re.match("^.*/task_0000_stdapp\\.std...$", p)),
+                          (File("arbitrary:abc123"), "arbitrary:abc123"),
+                          (File("file:///tmp/pl5"), "file:///tmp/pl5"),
+                          ])
+@pytest.mark.parametrize('stream', ['stdout', 'stderr'])
+def test_stdstream_to_monitoring(stdx, expected_stdx, stream, tmpd_cwd, caplog):
+    """This tests that various forms of stdout/err specification are
+       represented in monitoring correctly. The stderr and stdout codepaths
+       are generally duplicated, rather than factorised, and so this test
+       runs the same tests on both stdout and stderr.
+    """
+
+    # this is imported here rather than at module level because
+    # it isn't available in a plain parsl install, so this module
+    # would otherwise fail to import and break even a basic test
+    # run.
+    import sqlalchemy
+
+    c = fresh_config(tmpd_cwd)
+    c.monitoring.logging_endpoint = f"sqlite:///{tmpd_cwd}/monitoring.db"
+    c.executors[0].storage_access = default_staging + [ArbitraryStaging()]
+
+    with parsl.load(c):
+        kwargs = {stream: stdx}
+        stdapp(**kwargs).result()
+
+    engine = sqlalchemy.create_engine(c.monitoring.logging_endpoint)
+    with engine.begin() as connection:
+
+        def count_rows(table: str):
+            result = connection.execute(sqlalchemy.text(f"SELECT COUNT(*) FROM {table}"))
+            (c, ) = result.first()
+            return c
+
+        # one workflow...
+        assert count_rows("workflow") == 1
+
+        # ... with one task ...
+        assert count_rows("task") == 1
+
+        # ... that was tried once ...
+        assert count_rows("try") == 1
+
+        # ... and has the expected name.
+        result = connection.execute(sqlalchemy.text(f"SELECT task_{stream} FROM task"))
+        (c, ) = result.first()
+
+        if isinstance(expected_stdx, str):
+            assert c == expected_stdx
+        elif callable(expected_stdx):
+            assert expected_stdx(c)
+        else:
+            raise RuntimeError("Bad expected_stdx value")
+
+    for record in caplog.records:
+        assert record.levelno < logging.ERROR

parsl/tests/test_monitoring/test_viz_colouring.py

@@ -1,4 +1,5 @@
 import pytest
+
 from parsl.dataflow.states import States
 
 

parsl/tests/test_mpi_apps/test_bad_mpi_config.py

@@ -1,41 +1,48 @@
 import pytest
 
 from parsl import Config
-from parsl.executors import HighThroughputExecutor
-from parsl.launchers import SrunLauncher, SingleNodeLauncher, SimpleLauncher, AprunLauncher
+from parsl.executors import MPIExecutor
+from parsl.launchers import AprunLauncher, SimpleLauncher, SrunLauncher
 from parsl.providers import SlurmProvider
 
 
 @pytest.mark.local
-def test_bad_launcher_with_mpi_mode():
-    """AssertionError if a launcher other than SingleNodeLauncher is supplied"""
+def test_bad_launcher():
+    """TypeError if a launcher other than SimpleLauncher is supplied"""
 
-    for launcher in [SrunLauncher(), SimpleLauncher(), AprunLauncher()]:
-        with pytest.raises(AssertionError):
+    for launcher in [SrunLauncher(), AprunLauncher()]:
+        with pytest.raises(TypeError):
             Config(executors=[
-                HighThroughputExecutor(
-                    enable_mpi_mode=True,
+                MPIExecutor(
                     provider=SlurmProvider(launcher=launcher),
                 )
             ])
 
 
 @pytest.mark.local
-def test_correct_launcher_with_mpi_mode():
-    """Confirm that SingleNodeLauncer works with mpi_mode"""
-
-    config = Config(executors=[
-        HighThroughputExecutor(
-            enable_mpi_mode=True,
-            provider=SlurmProvider(launcher=SingleNodeLauncher()),
-        )
-    ])
-    assert isinstance(config.executors[0].provider.launcher, SingleNodeLauncher)
-
-    config = Config(executors=[
-        HighThroughputExecutor(
-            enable_mpi_mode=True,
-            provider=SlurmProvider(),
-        )
-    ])
-    assert isinstance(config.executors[0].provider.launcher, SingleNodeLauncher)
+def test_bad_mpi_launcher():
+    """ValueError if an unsupported mpi_launcher is specified"""
+
+    with pytest.raises(ValueError):
+        Config(executors=[
+            MPIExecutor(
+                mpi_launcher="bad_launcher",
+                provider=SlurmProvider(launcher=SimpleLauncher()),
+            )
+        ])
+
+
+@pytest.mark.local
+@pytest.mark.parametrize(
+    "mpi_launcher",
+    ["srun", "aprun", "mpiexec"]
+)
+def test_correct_launcher_with_mpi_mode(mpi_launcher: str):
+    """Confirm that SimpleLauncher works with mpi_mode"""
+
+    executor = MPIExecutor(
+        mpi_launcher=mpi_launcher,
+        provider=SlurmProvider(launcher=SimpleLauncher()),
+    )
+
+    assert isinstance(executor.provider.launcher, SimpleLauncher)

parsl/tests/test_mpi_apps/test_mpi_mode_enabled.py

@@ -1,34 +1,43 @@
 import logging
+import os
 import random
 from typing import Dict
+
 import pytest
-import parsl
-from parsl import python_app, bash_app
-from parsl.tests.configs.htex_local import fresh_config
 
-import os
+import parsl
+from parsl import Config, bash_app, python_app
+from parsl.executors import MPIExecutor
+from parsl.executors.errors import InvalidResourceSpecification
+from parsl.launchers import SimpleLauncher
+from parsl.providers import LocalProvider
 
 EXECUTOR_LABEL = "MPI_TEST"
 
 
 def local_setup():
-    config = fresh_config()
-    config.executors[0].label = EXECUTOR_LABEL
-    config.executors[0].max_workers_per_node = 2
-    config.executors[0].enable_mpi_mode = True
-    config.executors[0].mpi_launcher = "mpiexec"
 
     cwd = os.path.abspath(os.path.dirname(__file__))
     pbs_nodefile = os.path.join(cwd, "mocks", "pbs_nodefile")
 
-    config.executors[0].provider.worker_init = f"export PBS_NODEFILE={pbs_nodefile}"
+    config = Config(
+        executors=[
+            MPIExecutor(
+                label=EXECUTOR_LABEL,
+                max_workers_per_block=2,
+                mpi_launcher="mpiexec",
+                provider=LocalProvider(
+                    worker_init=f"export PBS_NODEFILE={pbs_nodefile}",
+                    launcher=SimpleLauncher()
+                )
+            )
+        ])
 
     parsl.load(config)
 
 
 def local_teardown():
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app
@@ -169,3 +178,11 @@ def test_simulated_load(rounds: int = 100):
         total_ranks, nodes = future.result(timeout=10)
         assert len(nodes) == futures[future]["num_nodes"]
         assert total_ranks == futures[future]["num_nodes"] * futures[future]["ranks_per_node"]
+
+
+@pytest.mark.local
+def test_missing_resource_spec():
+
+    with pytest.raises(InvalidResourceSpecification):
+        future = mock_app(sleep_dur=0.4)
+        future.result(timeout=10)

parsl/tests/test_mpi_apps/test_mpi_prefix.py

@@ -1,14 +1,14 @@
 import logging
+
 import pytest
 
-from parsl.executors.high_throughput.mpi_resource_management import Scheduler
 from parsl.executors.high_throughput.mpi_prefix_composer import (
-    compose_srun_launch_cmd,
+    compose_all,
     compose_aprun_launch_cmd,
     compose_mpiexec_launch_cmd,
-    compose_all,
+    compose_srun_launch_cmd,
 )
-
+from parsl.executors.high_throughput.mpi_resource_management import Scheduler
 
 resource_spec = {"num_nodes": 2,
                  "num_ranks": 8,