parsl 2024.4.8__py3-none-any.whl → 2024.4.22__py3-none-any.whl

parsl/monitoring/router.py

@@ -15,6 +15,8 @@ from parsl.utils import setproctitle
 
 from parsl.monitoring.message_type import MessageType
 from parsl.monitoring.types import AddressedMonitoringMessage, TaggedMonitoringMessage
+
+from multiprocessing.synchronize import Event
 from typing import Optional, Tuple, Union
 
 
@@ -98,10 +100,10 @@ class MonitoringRouter:
               priority_msgs: "queue.Queue[AddressedMonitoringMessage]",
               node_msgs: "queue.Queue[AddressedMonitoringMessage]",
               block_msgs: "queue.Queue[AddressedMonitoringMessage]",
-              resource_msgs: "queue.Queue[AddressedMonitoringMessage]") -> None:
+              resource_msgs: "queue.Queue[AddressedMonitoringMessage]",
+              exit_event: Event) -> None:
         try:
-            router_keep_going = True
-            while router_keep_going:
+            while not exit_event.is_set():
                 try:
                     data, addr = self.udp_sock.recvfrom(2048)
                     resource_msg = pickle.loads(data)
@@ -135,8 +137,6 @@ class MonitoringRouter:
                             priority_msgs.put(msg_0)
                         elif msg[0] == MessageType.WORKFLOW_INFO:
                             priority_msgs.put(msg_0)
-                            if 'exit_now' in msg[1] and msg[1]['exit_now']:
-                                router_keep_going = False
                         else:
                             # There is a type: ignore here because if msg[0]
                             # is of the correct type, this code is unreachable,
@@ -178,6 +178,7 @@ def router_starter(comm_q: "queue.Queue[Union[Tuple[int, int], str]]",
                    node_msgs: "queue.Queue[AddressedMonitoringMessage]",
                    block_msgs: "queue.Queue[AddressedMonitoringMessage]",
                    resource_msgs: "queue.Queue[AddressedMonitoringMessage]",
+                   exit_event: Event,
 
                    hub_address: str,
                    udp_port: Optional[int],
@@ -202,7 +203,7 @@ def router_starter(comm_q: "queue.Queue[Union[Tuple[int, int], str]]",
 
         router.logger.info("Starting MonitoringRouter in router_starter")
         try:
-            router.start(priority_msgs, node_msgs, block_msgs, resource_msgs)
+            router.start(priority_msgs, node_msgs, block_msgs, resource_msgs, exit_event)
         except Exception as e:
             router.logger.exception("router.start exception")
             exception_q.put(('Hub', str(e)))

parsl/providers/local/local.py

@@ -266,7 +266,7 @@ class LocalProvider(ExecutionProvider, RepresentationMixin):
         for job in job_ids:
             job_dict = self.resources[job]
             job_dict['cancelled'] = True
-            logger.debug("Terminating job/proc_id: {0}".format(job))
+            logger.debug("Terminating job/process ID: {0}".format(job))
             cmd = "kill -- -$(ps -o pgid= {} | grep -o '[0-9]*')".format(job_dict['remote_pid'])
             retcode, stdout, stderr = self.channel.execute_wait(cmd, self.cmd_timeout)
             if retcode != 0:

parsl/tests/configs/htex_local_alternate.py

@@ -31,6 +31,7 @@ from parsl.executors import HighThroughputExecutor
 from parsl.data_provider.http import HTTPInTaskStaging
 from parsl.data_provider.ftp import FTPInTaskStaging
 from parsl.data_provider.file_noop import NoOpFileStaging
+from parsl.data_provider.zip import ZipFileStaging
 
 working_dir = os.getcwd() + "/" + "test_htex_alternate"
 
@@ -42,7 +43,7 @@ def fresh_config():
                 address="127.0.0.1",
                 label="htex_Local",
                 working_dir=working_dir,
-                storage_access=[FTPInTaskStaging(), HTTPInTaskStaging(), NoOpFileStaging()],
+                storage_access=[ZipFileStaging(), FTPInTaskStaging(), HTTPInTaskStaging(), NoOpFileStaging()],
                 worker_debug=True,
                 cores_per_worker=1,
                 heartbeat_period=2,

parsl/tests/configs/taskvine_ex.py

@@ -9,5 +9,4 @@ from parsl.data_provider.file_noop import NoOpFileStaging
 
 def fresh_config():
     return Config(executors=[TaskVineExecutor(manager_config=TaskVineManagerConfig(port=9000),
-                                              worker_launch_method='factory',
-                                              storage_access=[FTPInTaskStaging(), HTTPInTaskStaging(), NoOpFileStaging()])])
+                                              worker_launch_method='factory')])

parsl/tests/configs/workqueue_ex.py

@@ -8,5 +8,4 @@ from parsl.data_provider.file_noop import NoOpFileStaging
 
 def fresh_config():
     return Config(executors=[WorkQueueExecutor(port=9000,
-                                               coprocess=True,
-                                               storage_access=[FTPInTaskStaging(), HTTPInTaskStaging(), NoOpFileStaging()])])
+                                               coprocess=True)])

parsl/tests/conftest.py

@@ -135,28 +135,27 @@ def pytest_configure(config):
     )
     config.addinivalue_line(
         'markers',
-        'noci: mark test to be unsuitable for running during automated tests'
+        'cleannet: Enable tests that require a clean network connection (such as for testing FTP)'
     )
-
     config.addinivalue_line(
         'markers',
-        'cleannet: Enable tests that require a clean network connection (such as for testing FTP)'
+        'staging_required: Marks tests that require a staging provider, when there is no sharedFS)'
     )
     config.addinivalue_line(
         'markers',
-        'issue363: Marks tests that require a shared filesystem for stdout/stderr - see issue #363'
+        'sshd_required: Marks tests that require a SSHD'
     )
     config.addinivalue_line(
         'markers',
-        'staging_required: Marks tests that require a staging provider, when there is no sharedFS)'
+        'multiple_cores_required: Marks tests that require multiple cores, such as htex affinity'
     )
     config.addinivalue_line(
         'markers',
-        'sshd_required: Marks tests that require a SSHD'
+        'issue3328: Marks tests broken by issue #3328'
     )
     config.addinivalue_line(
         'markers',
-        'multiple_cores_required: Marks tests that require multiple cores, such as htex affinity'
+        'executor_supports_std_stream_tuples: Marks tests that require tuple support for stdout/stderr'
     )
 
 

parsl/tests/test_bash_apps/test_basic.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import random
 import re
@@ -23,7 +24,6 @@ def foo(x, y, z=10, stdout=None, label=None):
     return f"echo {x} {y} {z}"
 
 
-@pytest.mark.issue363
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps"""
 
@@ -38,8 +38,7 @@ def test_command_format_1(tmpd_cwd):
     assert so_content == "1 4 10"
 
 
-@pytest.mark.issue363
-def test_auto_log_filename_format():
+def test_auto_log_filename_format(caplog):
     """Testing auto log filename format for BashApps
     """
     app_label = "label_test_auto_log_filename_format"
@@ -51,6 +50,8 @@ def test_auto_log_filename_format():
         foo_future.result())
 
     log_fpath = foo_future.stdout
+    assert isinstance(log_fpath, str)
+
     log_pattern = fr".*/task_\d+_foo_{app_label}"
     assert re.match(log_pattern, log_fpath), 'Output file "{0}" does not match pattern "{1}"'.format(
         log_fpath, log_pattern)
@@ -61,8 +62,10 @@ def test_auto_log_filename_format():
     assert contents == '1 {0} 10\n'.format(rand_int), \
         'Output does not match expected string "1 {0} 10", Got: "{1}"'.format(rand_int, contents)
 
+    for record in caplog.records:
+        assert record.levelno < logging.ERROR
+
 
-@pytest.mark.issue363
 def test_parallel_for(tmpd_cwd, n=3):
     """Testing a simple parallel for loop"""
     outdir = tmpd_cwd / "outputs/test_parallel"

parsl/tests/test_bash_apps/test_error_codes.py

@@ -76,7 +76,6 @@ def test_div_0(test_fn=div_0):
     os.remove('std.out')
 
 
-@pytest.mark.issue363
 def test_bash_misuse(test_fn=bash_misuse):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -91,7 +90,6 @@ def test_bash_misuse(test_fn=bash_misuse):
     os.remove('std.out')
 
 
-@pytest.mark.issue363
 def test_command_not_found(test_fn=command_not_found):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -108,7 +106,6 @@ def test_command_not_found(test_fn=command_not_found):
     return True
 
 
-@pytest.mark.issue363
 def test_not_executable(test_fn=not_executable):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()

parsl/tests/test_bash_apps/test_kwarg_storage.py

@@ -8,7 +8,6 @@ def foo(z=2, stdout=None):
     return f"echo {z}"
 
 
-@pytest.mark.issue363
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps
     """

parsl/tests/test_bash_apps/test_memoize.py

@@ -12,7 +12,6 @@ def fail_on_presence(outputs=()):
 # This test is an oddity that requires a shared-FS and simply
 # won't work if there's a staging provider.
 # @pytest.mark.sharedFS_required
-@pytest.mark.issue363
 def test_bash_memoization(tmpd_cwd, n=2):
     """Testing bash memoization
     """
@@ -33,7 +32,6 @@ def fail_on_presence_kw(outputs=(), foo=None):
 # This test is an oddity that requires a shared-FS and simply
 # won't work if there's a staging provider.
 # @pytest.mark.sharedFS_required
-@pytest.mark.issue363
 def test_bash_memoization_keywords(tmpd_cwd, n=2):
     """Testing bash memoization
     """

parsl/tests/test_bash_apps/test_memoize_ignore_args.py

@@ -22,7 +22,6 @@ def no_checkpoint_stdout_app_ignore_args(stdout=None):
     return "echo X"
 
 
-@pytest.mark.issue363
 def test_memo_stdout():
 
     # this should run and create a file named after path_x

parsl/tests/test_bash_apps/test_memoize_ignore_args_regr.py

@@ -30,7 +30,6 @@ def no_checkpoint_stdout_app(stdout=None):
     return "echo X"
 
 
-@pytest.mark.issue363
 def test_memo_stdout():
 
     assert const_list_x == const_list_x_arg

parsl/tests/test_bash_apps/test_multiline.py

@@ -14,7 +14,6 @@ def multiline(inputs=(), outputs=(), stderr=None, stdout=None):
     """.format(inputs=inputs, outputs=outputs)
 
 
-@pytest.mark.issue363
 def test_multiline(tmpd_cwd):
     so, se = tmpd_cwd / "std.out", tmpd_cwd / "std.err"
     f = multiline(

parsl/tests/test_bash_apps/test_stdout.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 import pytest
@@ -35,7 +36,6 @@ testids = [
 ]
 
 
-@pytest.mark.issue363
 @pytest.mark.parametrize('spec', speclist, ids=testids)
 def test_bad_stdout_specs(spec):
     """Testing bad stdout spec cases"""
@@ -54,7 +54,7 @@ def test_bad_stdout_specs(spec):
         assert False, "Did not raise expected exception"
 
 
-@pytest.mark.issue363
+@pytest.mark.issue3328
 def test_bad_stderr_file():
     """Testing bad stderr file"""
 
@@ -72,8 +72,8 @@ def test_bad_stderr_file():
     return
 
 
-@pytest.mark.issue363
-def test_stdout_truncate(tmpd_cwd):
+@pytest.mark.executor_supports_std_stream_tuples
+def test_stdout_truncate(tmpd_cwd, caplog):
     """Testing truncation of prior content of stdout"""
 
     out = (str(tmpd_cwd / 't1.out'), 'w')
@@ -88,9 +88,11 @@ def test_stdout_truncate(tmpd_cwd):
     assert len1 == 1
     assert len1 == len2
 
+    for record in caplog.records:
+        assert record.levelno < logging.ERROR
 
-@pytest.mark.issue363
-def test_stdout_append(tmpd_cwd):
+
+def test_stdout_append(tmpd_cwd, caplog):
     """Testing appending to prior content of stdout (default open() mode)"""
 
     out = str(tmpd_cwd / 't1.out')
@@ -103,3 +105,6 @@ def test_stdout_append(tmpd_cwd):
     len2 = len(open(out).readlines())
 
     assert len1 == 1 and len2 == 2
+
+    for record in caplog.records:
+        assert record.levelno < logging.ERROR

parsl/tests/test_checkpointing/test_task_exit.py

@@ -15,7 +15,7 @@ def local_setup():
 
 
 def local_teardown():
-    parsl.dfk().cleanup
+    parsl.dfk().cleanup()
     parsl.clear()
 
 

parsl/tests/test_htex/test_zmq_binding.py

@@ -53,6 +53,7 @@ def test_interchange_binding_with_address(cert_dir: Optional[str]):
     assert ix.interchange_address == address
 
 
+@pytest.mark.skip("This behaviour is possibly unexpected. See issue #3037")
 @pytest.mark.local
 @pytest.mark.parametrize("encrypted", (True, False), indirect=True)
 def test_interchange_binding_with_non_ipv4_address(cert_dir: Optional[str]):

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__)
+from parsl import HighThroughputExecutor
+from parsl.config import Config
+from parsl.executors.taskvine import TaskVineExecutor
+from parsl.executors.taskvine import TaskVineManagerConfig
+from parsl.monitoring import MonitoringHub
 
 
 @parsl.python_app
@@ -18,34 +21,56 @@ 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():
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+    return fresh_config()
+
+
+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, 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
+    with parsl.load(config):
+        assert this_app().result() == 5
 
-    logger.info("cleaning up parsl")
-    parsl.dfk().cleanup()
     parsl.clear()
 
     # 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 +92,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 +108,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_fuzz_zmq.py

@@ -4,6 +4,7 @@ import parsl
 import pytest
 import socket
 import time
+import zmq
 
 logger = logging.getLogger(__name__)
 
@@ -48,8 +49,16 @@ def test_row_counts():
         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.

parsl/tests/test_monitoring/test_stdouterr.py

@@ -0,0 +1,137 @@
+"""Tests monitoring records app name under various decoration patterns.
+"""
+
+import logging
+import os
+import parsl
+import pytest
+import re
+import time
+
+from typing import Union
+
+from parsl.config import Config
+from parsl.data_provider.files import File
+from parsl.data_provider.data_manager import default_staging
+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",
+                        hub_port=55055,
+        )
+    )
+
+
+@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()
+
+    parsl.clear()
+
+    engine = sqlalchemy.create_engine(c.monitoring.logging_endpoint)
+    with engine.begin() as connection:
+
+        def count_rows(table: str):
+            result = connection.execute(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(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_python_apps/test_context_manager.py

@@ -24,15 +24,15 @@ def local_teardown():
 
 
 @pytest.mark.local
-def test_within_context_manger():
+def test_within_context_manger(tmpd_cwd):
     config = fresh_config()
     with parsl.load(config=config) as dfk:
         assert isinstance(dfk, DataFlowKernel)
 
-        bash_future = foo(1)
+        bash_future = foo(1, stdout=tmpd_cwd / 'foo.stdout')
         assert bash_future.result() == 0
 
-        with open('foo.stdout', 'r') as f:
+        with open(tmpd_cwd / 'foo.stdout', 'r') as f:
             assert f.read() == "2\n"
 
     with pytest.raises(NoDataFlowKernelError) as excinfo:

parsl/tests/test_python_apps/test_outputs.py

@@ -16,7 +16,6 @@ def double(x, outputs=[]):
 whitelist = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'configs', '*threads*')
 
 
-@pytest.mark.issue363
 def test_launch_apps(tmpd_cwd, n=2):
     outdir = tmpd_cwd / "outputs"
     outdir.mkdir()

parsl/tests/test_scaling/test_regression_1621.py

@@ -9,6 +9,14 @@ from parsl.executors import HighThroughputExecutor
 from parsl.launchers import SimpleLauncher
 from parsl.providers import LocalProvider
 
+# Timing notes:
+# The configured strategy_period must be much smaller than the delay in
+# app() so that multiple iterations of the strategy have had a chance
+# to (mis)behave.
+# The status polling interval in OneShotLocalProvider must be much bigger
+# than the above times, so that the job status cached from the provider
+# will not be updated while the single invocation of app() runs.
+
 
 @parsl.python_app
 def app():
@@ -55,20 +63,12 @@ def test_one_block(tmpd_cwd):
             )
         ],
         strategy='simple',
+        strategy_period=0.1
     )
 
-    parsl.load(config)
-    dfk = parsl.dfk()
-
-    def poller():
-        import time
-        while True:
-            dfk.job_status_poller.poll()
-            time.sleep(0.1)
+    with parsl.load(config):
+        app().result()
 
-    threading.Thread(target=poller, daemon=True).start()
-    app().result()
-    parsl.dfk().cleanup()
     parsl.clear()
 
     assert oneshot_provider.recorded_submits == 1