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

parsl/tests/test_scaling/test_scale_down_htex_unregistered.py

@@ -0,0 +1,71 @@
+import logging
+import time
+
+import pytest
+
+import parsl
+from parsl import File, python_app
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.jobs.states import TERMINAL_STATES, JobState
+from parsl.launchers import SingleNodeLauncher
+from parsl.providers import LocalProvider
+
+logger = logging.getLogger(__name__)
+
+_max_blocks = 1
+_min_blocks = 0
+
+
+def local_config():
+    return Config(
+        executors=[
+            HighThroughputExecutor(
+                heartbeat_period=1,
+                heartbeat_threshold=2,
+                poll_period=100,
+                label="htex_local",
+                address="127.0.0.1",
+                max_workers_per_node=1,
+                encrypted=True,
+                launch_cmd="sleep inf",
+                provider=LocalProvider(
+                    init_blocks=1,
+                    max_blocks=_max_blocks,
+                    min_blocks=_min_blocks,
+                    launcher=SingleNodeLauncher(),
+                ),
+            )
+        ],
+        max_idletime=0.5,
+        strategy='htex_auto_scale',
+        strategy_period=0.1
+    )
+
+
+# see issue #1885 for details of failures of this test.
+# at the time of issue #1885 this test was failing frequently
+# in CI.
+@pytest.mark.local
+def test_scaledown_with_register(try_assert):
+    dfk = parsl.dfk()
+    htex = dfk.executors['htex_local']
+
+    num_managers = len(htex.connected_managers())
+    assert num_managers == 0, "Expected 0 managers at start"
+
+    try_assert(lambda: len(htex.status()),
+               fail_msg="Expected 1 block at start")
+
+    s = htex.status()
+    assert s['0'].state == JobState.RUNNING, "Expected block to be in RUNNING"
+
+    def check_zero_blocks():
+        s = htex.status()
+        return len(s) == 1 and s['0'].state in TERMINAL_STATES
+
+    try_assert(
+        check_zero_blocks,
+        fail_msg="Expected 0 blocks after idle scaledown",
+        timeout_ms=15000,
+    )

parsl/tests/test_scaling/test_shutdown_scalein.py

@@ -0,0 +1,73 @@
+import random
+import threading
+
+import pytest
+
+import parsl
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SimpleLauncher
+from parsl.providers import LocalProvider
+
+# we need some blocks, but it doesn't matter too much how many, as long
+# as they can all start up and get registered within the try_assert
+# timeout later on.
+BLOCK_COUNT = 3
+
+
+class AccumulatingLocalProvider(LocalProvider):
+    def __init__(self, *args, **kwargs):
+        # Use a list for submitted job IDs because if there are multiple
+        # submissions returning the same job ID, this test should count
+        # those...
+        self.submit_job_ids = []
+
+        # ... but there's no requirement, I think, that cancel must be called
+        # only once per job id. What matters here is that each job ID is
+        # cancelled at least once.
+        self.cancel_job_ids = set()
+
+        super().__init__(*args, **kwargs)
+
+    def submit(self, *args, **kwargs):
+        job_id = super().submit(*args, **kwargs)
+        self.submit_job_ids.append(job_id)
+        return job_id
+
+    def cancel(self, job_ids):
+        self.cancel_job_ids.update(job_ids)
+        return super().cancel(job_ids)
+
+
+@pytest.mark.local
+def test_shutdown_scalein_blocks(tmpd_cwd, try_assert):
+    """
+    This test scales up several blocks, and then checks that they are all
+    scaled in at DFK shutdown.
+    """
+    accumulating_provider = AccumulatingLocalProvider(
+        init_blocks=BLOCK_COUNT,
+        min_blocks=0,
+        max_blocks=0,
+        launcher=SimpleLauncher(),
+    )
+
+    htex = HighThroughputExecutor(
+               label="htex_local",
+               cores_per_worker=1,
+               provider=accumulating_provider
+           )
+
+    config = Config(
+        executors=[htex],
+        strategy='none',
+        strategy_period=0.1,
+        run_dir=str(tmpd_cwd)
+    )
+
+    with parsl.load(config):
+        # this will wait for everything to be scaled out fully
+        try_assert(lambda: len(htex.connected_managers()) == BLOCK_COUNT)
+
+    assert len(accumulating_provider.submit_job_ids) == BLOCK_COUNT, f"Exactly {BLOCK_COUNT} blocks should have been launched"
+    assert len(accumulating_provider.cancel_job_ids) == BLOCK_COUNT, f"Exactly {BLOCK_COUNT} blocks should have been scaled in"

parsl/tests/test_scaling/test_worker_interchange_bad_messages_3262.py

@@ -0,0 +1,90 @@
+import os
+import signal
+import time
+
+import pytest
+import zmq
+
+import parsl
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SimpleLauncher
+from parsl.providers import LocalProvider
+
+T_s = 1
+
+
+def fresh_config():
+    htex = HighThroughputExecutor(
+               heartbeat_period=1 * T_s,
+               heartbeat_threshold=3 * T_s,
+               label="htex_local",
+               worker_debug=True,
+               cores_per_worker=1,
+               encrypted=False,
+               provider=LocalProvider(
+                   init_blocks=0,
+                   min_blocks=0,
+                   max_blocks=0,
+                   launcher=SimpleLauncher(),
+               ),
+           )
+    c = Config(
+        executors=[htex],
+        strategy='none',
+        strategy_period=0.5,
+    )
+    return c, htex
+
+
+@parsl.python_app
+def app():
+    return 7
+
+
+@pytest.mark.local
+@pytest.mark.parametrize("msg",
+                         (b'FuzzyByte\rSTREAM',  # not JSON
+                          b'{}',  # missing fields
+                          b'{"type":"heartbeat"}',  # regression test #3262
+                          )
+                         )
+def test_bad_messages(try_assert, msg):
+    """This tests that the interchange is resilient to a few different bad
+    messages: malformed messages caused by implementation errors, and
+    heartbeat messages from managers that are not registered.
+
+    The heartbeat test is a regression test for issues #3262, #3632
+    """
+
+    c, htex = fresh_config()
+
+    with parsl.load(c):
+
+        # send a bad message into the interchange on the task_outgoing 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")
+
+        context = zmq.Context()
+        channel_timeout = 10000  # in milliseconds
+        task_channel = context.socket(zmq.DEALER)
+        task_channel.setsockopt(zmq.LINGER, 0)
+        task_channel.setsockopt(zmq.IDENTITY, b'testid')
+
+        task_channel.set_hwm(0)
+        task_channel.setsockopt(zmq.SNDTIMEO, channel_timeout)
+        task_channel.connect(f"tcp://localhost:{task_port}")
+
+        task_channel.send(msg)
+
+        # If the interchange exits, it's likely that this test will hang rather
+        # than raise an error, because the interchange interaction code
+        # assumes the interchange is always there.
+        # In the case of issue #3262, an exception message goes to stderr, and
+        # no error goes to the interchange log file.
+        htex.scale_out_facade(1)
+        try_assert(lambda: len(htex.connected_managers()) == 1, timeout_ms=10000)
+
+        assert app().result() == 7

parsl/tests/test_serialization/test_2555_caching_deserializer.py

@@ -1,6 +1,6 @@
-import parsl
 import pytest
 
+import parsl
 from parsl.tests.configs.htex_local import fresh_config as local_config
 
 

parsl/tests/test_serialization/test_3495_deserialize_managerlost.py

@@ -0,0 +1,47 @@
+import os
+import signal
+
+import pytest
+
+import parsl
+from parsl import Config, HighThroughputExecutor
+from parsl.executors.high_throughput.errors import ManagerLost
+
+
+@parsl.python_app
+def get_manager_pgid():
+    import os
+    return os.getpgid(os.getpid())
+
+
+@parsl.python_app
+def lose_manager():
+    import os
+    import signal
+
+    manager_pid = os.getppid()
+    os.kill(manager_pid, signal.SIGSTOP)
+
+
+@pytest.mark.local
+def test_manager_lost_system_failure(tmpd_cwd):
+    hte = HighThroughputExecutor(
+        label="htex_local",
+        address="127.0.0.1",
+        max_workers_per_node=2,
+        cores_per_worker=1,
+        worker_logdir_root=str(tmpd_cwd),
+        heartbeat_period=1,
+        heartbeat_threshold=3,
+    )
+    c = Config(executors=[hte], strategy='simple', strategy_period=0.1)
+
+    with parsl.load(c):
+        manager_pgid = get_manager_pgid().result()
+        try:
+            with pytest.raises(ManagerLost):
+                lose_manager().result()
+        finally:
+            # Allow process to clean itself up
+            os.killpg(manager_pgid, signal.SIGCONT)
+            os.killpg(manager_pgid, signal.SIGTERM)

parsl/tests/test_serialization/test_basic.py

@@ -1,5 +1,6 @@
 import pytest
-from parsl.serialize import serialize, deserialize
+
+from parsl.serialize import deserialize, serialize
 from parsl.serialize.concretes import DillSerializer, PickleSerializer
 
 

parsl/tests/test_serialization/test_htex_code_cache.py

@@ -1,10 +1,9 @@
-import parsl
-import pytest
-
 from typing import Any
 
-from parsl.serialize.facade import methods_for_code
+import pytest
 
+import parsl
+from parsl.serialize.facade import methods_for_code
 from parsl.tests.configs.htex_local import fresh_config as local_config
 
 

parsl/tests/test_serialization/test_pack_resource_spec.py

@@ -1,5 +1,6 @@
 import pytest
-from parsl.serialize import unpack_res_spec_apply_message, pack_res_spec_apply_message
+
+from parsl.serialize import pack_res_spec_apply_message, unpack_res_spec_apply_message
 
 
 def double(x: int, y: int = 2) -> int:

parsl/tests/test_serialization/test_proxystore_configured.py

@@ -1,19 +1,24 @@
 import logging
-import pytest
 import uuid
 
+import pytest
+
 import parsl
-from parsl.serialize.facade import additional_methods_for_deserialization, methods_for_data, register_method_for_data
+from parsl.serialize.facade import (
+    additional_methods_for_deserialization,
+    methods_for_data,
+    register_method_for_data,
+)
 from parsl.tests.configs.htex_local import fresh_config
 
-
 logger = logging.getLogger(__name__)
 
 
 def local_setup():
-    from parsl.serialize.proxystore import ProxyStoreSerializer
-    from proxystore.store import Store, register_store
     from proxystore.connectors.file import FileConnector
+    from proxystore.store import Store, register_store
+
+    from parsl.serialize.proxystore import ProxyStoreSerializer
 
     parsl.load(fresh_config())
 
@@ -38,7 +43,6 @@ def local_setup():
 
 def local_teardown():
     parsl.dfk().cleanup()
-    parsl.clear()
 
     methods_for_data.clear()
     methods_for_data.update(previous_methods)

parsl/tests/test_serialization/test_proxystore_impl.py

@@ -1,6 +1,7 @@
-import pytest
 import uuid
 
+import pytest
+
 
 def policy_example(o):
     """Example policy will proxy only lists."""
@@ -13,10 +14,11 @@ def test_proxystore_nonglobal():
     """
     # import in function, because proxystore is not importable in base parsl
     # installation.
-    from parsl.serialize.proxystore import ProxyStoreSerializer
+    from proxystore.connectors.file import FileConnector
     from proxystore.proxy import Proxy
     from proxystore.store import Store, register_store
-    from proxystore.connectors.file import FileConnector
+
+    from parsl.serialize.proxystore import ProxyStoreSerializer
 
     store = Store(name='parsl_store_' + str(uuid.uuid4()), connector=FileConnector(store_dir="/tmp"))
     register_store(store)

parsl/tests/test_shutdown/test_kill_monitoring.py

@@ -0,0 +1,64 @@
+import os
+import signal
+import time
+
+import pytest
+
+import parsl
+from parsl.tests.configs.htex_local_alternate import fresh_config
+
+# This is a very generous upper bound on expected shutdown time of target
+# process after receiving a signal, measured in seconds.
+PERMITTED_SHUTDOWN_TIME_S = 60
+
+
+@parsl.python_app
+def simple_app():
+    return True
+
+
+@pytest.mark.local
+def test_no_kills():
+    """This tests that we can create a monitoring-enabled DFK and shut it down."""
+
+    parsl.load(fresh_config())
+
+    assert parsl.dfk().monitoring is not None, "This test requires monitoring"
+
+    parsl.dfk().cleanup()
+
+
+@pytest.mark.local
+@pytest.mark.parametrize("sig", [signal.SIGINT, signal.SIGTERM, signal.SIGKILL, signal.SIGQUIT])
+@pytest.mark.parametrize("process_attr", ["router_proc", "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
+    monitoring processes receive a ctrl-C too, and so the other processes
+    need to be tolerant to monitoring processes arbitrarily exiting.
+    """
+
+    parsl.load(fresh_config())
+
+    dfk = parsl.dfk()
+
+    assert dfk.monitoring is not None, "Monitoring required"
+
+    target_proc = getattr(dfk.monitoring, process_attr)
+
+    assert target_proc is not None, "prereq: target process must exist"
+    assert target_proc.is_alive(), "prereq: target process must be alive"
+
+    target_pid = target_proc.pid
+    assert target_pid is not None, "prereq: target process must have a pid"
+
+    os.kill(target_pid, sig)
+
+    try_assert(lambda: not target_proc.is_alive(), timeout_ms=PERMITTED_SHUTDOWN_TIME_S * 1000)
+
+    # now we have broken one piece of the monitoring system, do some app
+    # execution and then shut down.
+
+    simple_app().result()
+
+    parsl.dfk().cleanup()

parsl/tests/test_staging/staging_provider.py

@@ -62,8 +62,8 @@ def make_stage_out_app(executor, dfk):
 
 
 def stage_out_noop(app_fu, inputs=[], _parsl_staging_inhibit=True):
-    import time
     import logging
+    import time
     logger = logging.getLogger(__name__)
     logger.info("stage_out_noop")
     time.sleep(1)
@@ -75,8 +75,8 @@ def make_stage_in_app(executor, dfk):
 
 
 def stage_in_noop(parent_fut=None, outputs=[], _parsl_staging_inhibit=True):
-    import time
     import logging
+    import time
     logger = logging.getLogger(__name__)
     logger.info("stage_in_noop")
     time.sleep(1)

parsl/tests/test_staging/test_1316.py

@@ -1,8 +1,9 @@
+import time
+
 import pytest
 
 import parsl
-import time
-from parsl import python_app, ThreadPoolExecutor
+from parsl import ThreadPoolExecutor, python_app
 from parsl.config import Config
 from parsl.data_provider.files import File
 from parsl.data_provider.staging import Staging
@@ -60,7 +61,6 @@ def test_1316_local_path_on_execution_side_sp2():
     assert not file.local_path, "The local_path on the submit side should not be set"
 
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @pytest.mark.local
@@ -83,4 +83,3 @@ def test_1316_local_path_setting_preserves_dependency_sp2():
     assert not file.local_path, "The local_path on the submit side should not be set"
 
     parsl.dfk().cleanup()
-    parsl.clear()

parsl/tests/test_staging/test_docs_1.py

@@ -1,6 +1,6 @@
 import pytest
 
-from parsl import python_app, File
+from parsl import File, python_app
 
 
 @python_app
@@ -12,6 +12,7 @@ def convert(inputs=[], outputs=[]):
 
 
 @pytest.mark.cleannet
+@pytest.mark.staging_required
 def test():
     # create an remote Parsl file
     inp = File('ftp://ftp.iana.org/pub/mirror/rirstats/arin/ARIN-STATS-FORMAT-CHANGE.txt')

parsl/tests/test_staging/test_docs_2.py

@@ -1,5 +1,6 @@
 import pytest
-from parsl import bash_app, File
+
+from parsl import File, bash_app
 from parsl.tests.configs.local_threads import fresh_config as local_config
 
 

parsl/tests/test_staging/test_elaborate_noop_file.py

@@ -6,15 +6,15 @@
 # of the globus staging provider
 
 import logging
+
 import pytest
 
 import parsl
-
 from parsl import bash_app, python_app
 from parsl.config import Config
 from parsl.data_provider.files import File
 from parsl.executors.threads import ThreadPoolExecutor
-from parsl.tests.test_staging.staging_provider import NoOpTestingFileStaging, NoOpError
+from parsl.tests.test_staging.staging_provider import NoOpError, NoOpTestingFileStaging
 
 logger = logging.getLogger(__name__)
 
@@ -44,7 +44,6 @@ def storage_access_parsl():
     yield _setup_config
 
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @pytest.mark.local

parsl/tests/{test_data → test_staging}/test_file.py

@@ -22,11 +22,11 @@ def test_files():
 
 
 @pytest.mark.local
-def test_open():
-    with open('test-open.txt', 'w') as tfile:
-        tfile.write('Hello')
+def test_open(tmpd_cwd):
+    fpath = tmpd_cwd / 'test-open.txt'
+    fpath.write_text('Hello')
 
-    pfile = File('test-open.txt')
+    pfile = File(fpath)
 
-    with open(str(pfile), 'r') as opfile:
-        assert (opfile.readlines()[0] == 'Hello')
+    with open(pfile) as opfile:
+        assert (opfile.read() == 'Hello')

parsl/tests/{test_data → test_staging}/test_output_chain_filenames.py

@@ -1,5 +1,7 @@
 from concurrent.futures import Future
 
+import pytest
+
 from parsl import File
 from parsl.app.app import bash_app
 
@@ -14,6 +16,7 @@ def app2(inputs=(), outputs=(), stdout=None, stderr=None, mock=False):
     return f"echo '{inputs[0]}' > {outputs[0]}"
 
 
+@pytest.mark.shared_fs
 def test_behavior(tmpd_cwd):
     expected_path = str(tmpd_cwd / "simple-out.txt")
     app1_future = app1(

parsl/tests/test_staging/test_staging_ftp.py

@@ -15,6 +15,7 @@ def sort_strings(inputs=[], outputs=[]):
 
 
 @pytest.mark.cleannet
+@pytest.mark.staging_required
 def test_staging_ftp():
     """Test staging for an ftp file
 

parsl/tests/test_staging/test_staging_https.py

@@ -1,9 +1,9 @@
+import pytest
+
 import parsl
 from parsl.app.app import python_app
 from parsl.data_provider.files import File
 
-import pytest
-
 # This config is for the local test which will adding an executor.
 # Most tests in this file should be non-local and use the configuration
 # specificed with --config, not this one.
@@ -48,6 +48,7 @@ def sort_strings_additional_executor(inputs=(), outputs=()):
 
 
 @pytest.mark.cleannet
+@pytest.mark.staging_required
 def test_staging_https_cleannet(tmpd_cwd):
     unsorted_file = File(_unsorted_url)
     sorted_file = File(tmpd_cwd / 'sorted.txt')
@@ -68,6 +69,7 @@ def test_staging_https_local(tmpd_cwd):
 
 
 @pytest.mark.cleannet
+@pytest.mark.staging_required
 def test_staging_https_kwargs(tmpd_cwd):
     unsorted_file = File(_unsorted_url)
     sorted_file = File(tmpd_cwd / 'sorted.txt')
@@ -78,6 +80,7 @@ def test_staging_https_kwargs(tmpd_cwd):
 
 
 @pytest.mark.cleannet
+@pytest.mark.staging_required
 def test_staging_https_args(tmpd_cwd):
     unsorted_file = File(_unsorted_url)
     sorted_file = File(tmpd_cwd / 'sorted.txt')