parsl 2024.10.21__py3-none-any.whl → 2024.11.4__py3-none-any.whl

parsl/channels/base.py

@@ -120,14 +120,3 @@ class Channel(metaclass=ABCMeta):
             Path of directory to check.
         """
         pass
-
-    @abstractmethod
-    def abspath(self, path: str) -> str:
-        """Return the absolute path.
-
-        Parameters
-        ----------
-        path : str
-            Path for which the absolute path will be returned.
-        """
-        pass

parsl/channels/errors.py

@@ -1,7 +1,5 @@
 ''' Exceptions raise by Apps.
 '''
-from typing import Optional
-
 from parsl.errors import ParslError
 
 
@@ -60,21 +58,6 @@ class BadPermsScriptPath(ChannelError):
         super().__init__("User does not have permissions to access the script_dir", e, hostname)
 
 
-class FileExists(ChannelError):
-    ''' Push or pull of file over channel fails since a file of the name already
-    exists on the destination.
-
-    Contains:
-    reason(string)
-    e (paramiko exception object)
-    hostname (string)
-    '''
-
-    def __init__(self, e: Exception, hostname: str, filename: Optional[str] = None) -> None:
-        super().__init__("File name collision in channel transport phase: {}".format(filename),
-                         e, hostname)
-
-
 class AuthException(ChannelError):
     ''' An error raised during execution of an app.
     What this exception contains depends entirely on context

parsl/channels/local/local.py

@@ -37,19 +37,16 @@ class LocalChannel(Channel, RepresentationMixin):
 
         Args:
             - cmd (string) : Commandline string to execute
-            - walltime (int) : walltime in seconds, this is not really used now.
+            - walltime (int) : walltime in seconds
 
         Kwargs:
             - envs (dict) : Dictionary of env variables. This will be used
               to override the envs set at channel initialization.
 
         Returns:
-            - retcode : Return code from the execution, -1 on fail
+            - retcode : Return code from the execution
             - stdout  : stdout string
             - stderr  : stderr string
-
-        Raises:
-        None.
         '''
         current_env = copy.deepcopy(self._envs)
         current_env.update(envs)
@@ -145,16 +142,6 @@ class LocalChannel(Channel, RepresentationMixin):
 
         return os.makedirs(path, mode, exist_ok)
 
-    def abspath(self, path):
-        """Return the absolute path.
-
-        Parameters
-        ----------
-        path : str
-            Path for which the absolute path will be returned.
-        """
-        return os.path.abspath(path)
-
     @property
     def script_dir(self):
         return self._script_dir
@@ -162,5 +149,5 @@ class LocalChannel(Channel, RepresentationMixin):
     @script_dir.setter
     def script_dir(self, value):
         if value is not None:
-            value = self.abspath(value)
+            value = os.path.abspath(value)
         self._script_dir = value

parsl/channels/ssh/ssh.py

@@ -214,7 +214,6 @@ class DeprecatedSSHChannel(Channel, RepresentationMixin):
             - str: Local path to file
 
         Raises:
-            - FileExists : Name collision at local directory.
             - FileCopyException : FileCopy failed.
         '''
 
@@ -287,16 +286,6 @@ class DeprecatedSSHChannel(Channel, RepresentationMixin):
         self.execute_wait('mkdir -p {}'.format(path))
         self._valid_sftp_client().chmod(path, mode)
 
-    def abspath(self, path):
-        """Return the absolute path on the remote side.
-
-        Parameters
-        ----------
-        path : str
-            Path for which the absolute path will be returned.
-        """
-        return self._valid_sftp_client().normalize(path)
-
     @property
     def script_dir(self):
         return self._script_dir

parsl/dataflow/dflow.py

@@ -162,8 +162,8 @@ class DataFlowKernel:
         }
 
         if self.monitoring:
-            self.monitoring.send(MessageType.WORKFLOW_INFO,
-                                 workflow_info)
+            self.monitoring.send((MessageType.WORKFLOW_INFO,
+                                 workflow_info))
 
         if config.checkpoint_files is not None:
             checkpoints = self.load_checkpoints(config.checkpoint_files)
@@ -238,7 +238,7 @@ class DataFlowKernel:
     def _send_task_log_info(self, task_record: TaskRecord) -> None:
         if self.monitoring:
             task_log_info = self._create_task_log_info(task_record)
-            self.monitoring.send(MessageType.TASK_INFO, task_log_info)
+            self.monitoring.send((MessageType.TASK_INFO, task_log_info))
 
     def _create_task_log_info(self, task_record: TaskRecord) -> Dict[str, Any]:
         """
@@ -987,7 +987,7 @@ class DataFlowKernel:
             - app_kwargs (dict) : Rest of the kwargs to the fn passed as dict.
 
         Returns:
-               (AppFuture) [DataFutures,]
+            AppFuture
 
         """
 
@@ -1295,12 +1295,12 @@ class DataFlowKernel:
 
         if self.monitoring:
             logger.info("Sending final monitoring message")
-            self.monitoring.send(MessageType.WORKFLOW_INFO,
+            self.monitoring.send((MessageType.WORKFLOW_INFO,
                                  {'tasks_failed_count': self.task_state_counts[States.failed],
                                   'tasks_completed_count': self.task_state_counts[States.exec_done],
                                   "time_began": self.time_began,
                                   'time_completed': self.time_completed,
-                                  'run_id': self.run_id, 'rundir': self.run_dir})
+                                  'run_id': self.run_id, 'rundir': self.run_dir}))
 
             logger.info("Terminating monitoring")
             self.monitoring.close()

parsl/executors/high_throughput/executor.py

@@ -63,7 +63,6 @@ DEFAULT_INTERCHANGE_LAUNCH_CMD = ["interchange.py"]
 
 GENERAL_HTEX_PARAM_DOCS = """provider : :class:`~parsl.providers.base.ExecutionProvider`
        Provider to access computation resources. Can be one of :class:`~parsl.providers.aws.aws.EC2Provider`,
-        :class:`~parsl.providers.cobalt.cobalt.Cobalt`,
         :class:`~parsl.providers.condor.condor.Condor`,
         :class:`~parsl.providers.googlecloud.googlecloud.GoogleCloud`,
         :class:`~parsl.providers.gridEngine.gridEngine.GridEngine`,

parsl/executors/high_throughput/interchange.py

@@ -66,7 +66,7 @@ class Interchange:
              If specified the interchange will only listen on this address for connections from workers
              else, it binds to all addresses.
 
-        client_ports : triple(int, int, int)
+        client_ports : tuple(int, int, int)
              The ports at which the client can be reached
 
         worker_ports : tuple(int, int)
@@ -104,7 +104,6 @@ class Interchange:
         os.makedirs(self.logdir, exist_ok=True)
 
         start_file_logger("{}/interchange.log".format(self.logdir), level=logging_level)
-        logger.propagate = False
         logger.debug("Initializing Interchange process")
 
         self.client_address = client_address
@@ -437,9 +436,13 @@ class Interchange:
                     logger.info(f"Manager {manager_id!r} has compatible Parsl version {msg['parsl_v']}")
                     logger.info(f"Manager {manager_id!r} has compatible Python version {msg['python_v'].rsplit('.', 1)[0]}")
             elif msg['type'] == 'heartbeat':
-                self._ready_managers[manager_id]['last_heartbeat'] = time.time()
-                logger.debug("Manager %r sent heartbeat via tasks connection", manager_id)
-                self.task_outgoing.send_multipart([manager_id, b'', PKL_HEARTBEAT_CODE])
+                manager = self._ready_managers.get(manager_id)
+                if manager:
+                    manager['last_heartbeat'] = time.time()
+                    logger.debug("Manager %r sent heartbeat via tasks connection", manager_id)
+                    self.task_outgoing.send_multipart([manager_id, b'', PKL_HEARTBEAT_CODE])
+                else:
+                    logger.warning("Received heartbeat via tasks connection for not-registered manager %r", manager_id)
             elif msg['type'] == 'drain':
                 self._ready_managers[manager_id]['draining'] = True
                 logger.debug("Manager %r requested drain", manager_id)

parsl/executors/high_throughput/mpi_resource_management.py

@@ -17,7 +17,6 @@ class Scheduler(Enum):
     Unknown = 0
     Slurm = 1
     PBS = 2
-    Cobalt = 3
 
 
 def get_slurm_hosts_list() -> List[str]:
@@ -37,13 +36,6 @@ def get_pbs_hosts_list() -> List[str]:
         return [line.strip() for line in f.readlines()]
 
 
-def get_cobalt_hosts_list() -> List[str]:
-    """Get list of COBALT hosts from envvar: COBALT_NODEFILE"""
-    nodefile_name = os.environ["COBALT_NODEFILE"]
-    with open(nodefile_name) as f:
-        return [line.strip() for line in f.readlines()]
-
-
 def get_nodes_in_batchjob(scheduler: Scheduler) -> List[str]:
     """Get nodelist from all supported schedulers"""
     nodelist = []
@@ -51,8 +43,6 @@ def get_nodes_in_batchjob(scheduler: Scheduler) -> List[str]:
         nodelist = get_slurm_hosts_list()
     elif scheduler == Scheduler.PBS:
         nodelist = get_pbs_hosts_list()
-    elif scheduler == Scheduler.Cobalt:
-        nodelist = get_cobalt_hosts_list()
     else:
         raise RuntimeError(f"mpi_mode does not support scheduler:{scheduler}")
     return nodelist
@@ -64,8 +54,6 @@ def identify_scheduler() -> Scheduler:
         return Scheduler.Slurm
     elif os.environ.get("PBS_NODEFILE"):
         return Scheduler.PBS
-    elif os.environ.get("COBALT_NODEFILE"):
-        return Scheduler.Cobalt
     else:
         return Scheduler.Unknown
 

parsl/executors/high_throughput/process_worker_pool.py

@@ -650,14 +650,6 @@ def worker(
     debug: bool,
     mpi_launcher: str,
 ):
-    """
-
-    Put request token into queue
-    Get task from task_queue
-    Pop request from queue
-    Put result into result_queue
-    """
-
     # override the global logger inherited from the __main__ process (which
     # usually logs to manager.log) with one specific to this worker.
     global logger

parsl/monitoring/db_manager.py

@@ -556,7 +556,7 @@ class DatabaseManager:
             logger.debug("Checking STOP conditions: kill event: %s, queue has entries: %s",
                          kill_event.is_set(), logs_queue.qsize() != 0)
             try:
-                x, addr = logs_queue.get(timeout=0.1)
+                x = logs_queue.get(timeout=0.1)
             except queue.Empty:
                 continue
             else:

parsl/monitoring/monitoring.py

@@ -7,16 +7,15 @@ import queue
 import time
 from multiprocessing import Event, Process
 from multiprocessing.queues import Queue
-from typing import TYPE_CHECKING, Any, Literal, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Literal, Optional, Tuple, Union, cast
 
 import typeguard
 
 from parsl.log_utils import set_file_logger
 from parsl.monitoring.errors import MonitoringHubStartError
-from parsl.monitoring.message_type import MessageType
 from parsl.monitoring.radios import MultiprocessingQueueRadioSender
 from parsl.monitoring.router import router_starter
-from parsl.monitoring.types import AddressedMonitoringMessage
+from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import ForkProcess, SizedQueue
 from parsl.process_loggers import wrap_with_logs
 from parsl.serialize import deserialize
@@ -138,7 +137,7 @@ class MonitoringHub(RepresentationMixin):
         self.exception_q: Queue[Tuple[str, str]]
         self.exception_q = SizedQueue(maxsize=10)
 
-        self.resource_msgs: Queue[Union[AddressedMonitoringMessage, Tuple[Literal["STOP"], Literal[0]]]]
+        self.resource_msgs: Queue[Union[TaggedMonitoringMessage, Literal["STOP"]]]
         self.resource_msgs = SizedQueue()
 
         self.router_exit_event: ms.Event
@@ -202,10 +201,9 @@ class MonitoringHub(RepresentationMixin):
 
         self.hub_zmq_port = zmq_port
 
-    # TODO: tighten the Any message format
-    def send(self, mtype: MessageType, message: Any) -> None:
-        logger.debug("Sending message type {}".format(mtype))
-        self.radio.send((mtype, message))
+    def send(self, message: TaggedMonitoringMessage) -> None:
+        logger.debug("Sending message type {}".format(message[0]))
+        self.radio.send(message)
 
     def close(self) -> None:
         logger.info("Terminating Monitoring Hub")
@@ -237,7 +235,7 @@ class MonitoringHub(RepresentationMixin):
             logger.debug("Finished waiting for router termination")
             if len(exception_msgs) == 0:
                 logger.debug("Sending STOP to DBM")
-                self.resource_msgs.put(("STOP", 0))
+                self.resource_msgs.put("STOP")
             else:
                 logger.debug("Not sending STOP to DBM, because there were DBM exceptions")
             logger.debug("Waiting for DB termination")
@@ -261,7 +259,7 @@ class MonitoringHub(RepresentationMixin):
 
 
 @wrap_with_logs
-def filesystem_receiver(logdir: str, q: "queue.Queue[AddressedMonitoringMessage]", run_dir: str) -> None:
+def filesystem_receiver(logdir: str, q: "queue.Queue[TaggedMonitoringMessage]", run_dir: str) -> None:
     logger = set_file_logger("{}/monitoring_filesystem_radio.log".format(logdir),
                              name="monitoring_filesystem_radio",
                              level=logging.INFO)
@@ -288,7 +286,7 @@ def filesystem_receiver(logdir: str, q: "queue.Queue[AddressedMonitoringMessage]
                     message = deserialize(f.read())
                 logger.debug(f"Message received is: {message}")
                 assert isinstance(message, tuple)
-                q.put(cast(AddressedMonitoringMessage, message))
+                q.put(cast(TaggedMonitoringMessage, message))
                 os.remove(full_path_filename)
             except Exception:
                 logger.exception(f"Exception processing {filename} - probably will be retried next iteration")

parsl/monitoring/radios.py

@@ -5,15 +5,11 @@ import socket
 import uuid
 from abc import ABCMeta, abstractmethod
 from multiprocessing.queues import Queue
-from typing import Optional
 
 import zmq
 
 from parsl.serialize import serialize
 
-_db_manager_excepts: Optional[Exception]
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -41,9 +37,8 @@ class FilesystemRadioSender(MonitoringRadioSender):
     the UDP radio, but should be much more reliable.
     """
 
-    def __init__(self, *, monitoring_url: str, source_id: int, timeout: int = 10, run_dir: str):
+    def __init__(self, *, monitoring_url: str, timeout: int = 10, run_dir: str):
         logger.info("filesystem based monitoring channel initializing")
-        self.source_id = source_id
         self.base_path = f"{run_dir}/monitor-fs-radio/"
         self.tmp_path = f"{self.base_path}/tmp"
         self.new_path = f"{self.base_path}/new"
@@ -58,7 +53,7 @@ class FilesystemRadioSender(MonitoringRadioSender):
 
         tmp_filename = f"{self.tmp_path}/{unique_id}"
         new_filename = f"{self.new_path}/{unique_id}"
-        buffer = (message, "NA")
+        buffer = message
 
         # this will write the message out then atomically
         # move it into new/, so that a partially written
@@ -70,19 +65,16 @@ class FilesystemRadioSender(MonitoringRadioSender):
 
 class HTEXRadioSender(MonitoringRadioSender):
 
-    def __init__(self, monitoring_url: str, source_id: int, timeout: int = 10):
+    def __init__(self, monitoring_url: str, timeout: int = 10):
         """
         Parameters
         ----------
 
         monitoring_url : str
             URL of the form <scheme>://<IP>:<PORT>
-        source_id : str
-            String identifier of the source
         timeout : int
             timeout, default=10s
         """
-        self.source_id = source_id
         logger.info("htex-based monitoring channel initialising")
 
     def send(self, message: object) -> None:
@@ -124,21 +116,18 @@ class HTEXRadioSender(MonitoringRadioSender):
 
 class UDPRadioSender(MonitoringRadioSender):
 
-    def __init__(self, monitoring_url: str, source_id: int, timeout: int = 10):
+    def __init__(self, monitoring_url: str, timeout: int = 10):
         """
         Parameters
         ----------
 
         monitoring_url : str
             URL of the form <scheme>://<IP>:<PORT>
-        source_id : str
-            String identifier of the source
         timeout : int
             timeout, default=10s
         """
         self.monitoring_url = monitoring_url
         self.sock_timeout = timeout
-        self.source_id = source_id
         try:
             self.scheme, self.ip, port = (x.strip('/') for x in monitoring_url.split(':'))
             self.port = int(port)
@@ -187,7 +176,7 @@ class MultiprocessingQueueRadioSender(MonitoringRadioSender):
         self.queue = queue
 
     def send(self, message: object) -> None:
-        self.queue.put((message, 0))
+        self.queue.put(message)
 
 
 class ZMQRadioSender(MonitoringRadioSender):

parsl/monitoring/remote.py

@@ -103,14 +103,12 @@ def monitor_wrapper(*,
 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,
-                               source_id=task_id)
+        radio = UDPRadioSender(monitoring_hub_url)
     elif radio_mode == "htex":
-        radio = HTEXRadioSender(monitoring_hub_url,
-                                source_id=task_id)
+        radio = HTEXRadioSender(monitoring_hub_url)
     elif radio_mode == "filesystem":
         radio = FilesystemRadioSender(monitoring_url=monitoring_hub_url,
-                                      source_id=task_id, run_dir=run_dir)
+                                      run_dir=run_dir)
     else:
         raise RuntimeError(f"Unknown radio mode: {radio_mode}")
     return radio

parsl/monitoring/router.py

@@ -14,7 +14,7 @@ import typeguard
 import zmq
 
 from parsl.log_utils import set_file_logger
-from parsl.monitoring.types import AddressedMonitoringMessage, TaggedMonitoringMessage
+from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.process_loggers import wrap_with_logs
 from parsl.utils import setproctitle
 
@@ -125,7 +125,7 @@ class MonitoringRouter:
                     data, addr = self.udp_sock.recvfrom(2048)
                     resource_msg = pickle.loads(data)
                     self.logger.debug("Got UDP Message from {}: {}".format(addr, resource_msg))
-                    self.resource_msgs.put((resource_msg, addr))
+                    self.resource_msgs.put(resource_msg)
                 except socket.timeout:
                     pass
 
@@ -136,7 +136,7 @@ class MonitoringRouter:
                     data, addr = self.udp_sock.recvfrom(2048)
                     msg = pickle.loads(data)
                     self.logger.debug("Got UDP Message from {}: {}".format(addr, msg))
-                    self.resource_msgs.put((msg, addr))
+                    self.resource_msgs.put(msg)
                     last_msg_received_time = time.time()
                 except socket.timeout:
                     pass
@@ -160,10 +160,7 @@ class MonitoringRouter:
                         assert len(msg) >= 1, "ZMQ Receiver expects tuples of length at least 1, got {}".format(msg)
                         assert len(msg) == 2, "ZMQ Receiver expects message tuples of exactly length 2, got {}".format(msg)
 
-                        msg_0: AddressedMonitoringMessage
-                        msg_0 = (msg, 0)
-
-                        self.resource_msgs.put(msg_0)
+                        self.resource_msgs.put(msg)
                 except zmq.Again:
                     pass
                 except Exception:

parsl/monitoring/types.py

@@ -1,14 +1,11 @@
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, Tuple
 
 from typing_extensions import TypeAlias
 
 from parsl.monitoring.message_type import MessageType
 
-# A basic parsl monitoring message is wrapped by up to two wrappers:
-# The basic monitoring message dictionary can first be tagged, giving
-# a TaggedMonitoringMessage, and then that can be further tagged with
-# an often unused sender address, giving an AddressedMonitoringMessage.
+# A MonitoringMessage dictionary can be tagged, giving a
+# TaggedMonitoringMessage.
 
 MonitoringMessage: TypeAlias = Dict[str, Any]
 TaggedMonitoringMessage: TypeAlias = Tuple[MessageType, MonitoringMessage]
-AddressedMonitoringMessage: TypeAlias = Tuple[TaggedMonitoringMessage, Union[str, int]]

parsl/providers/__init__.py

@@ -1,7 +1,6 @@
 # Cloud Providers
 from parsl.providers.aws.aws import AWSProvider
 from parsl.providers.azure.azure import AzureProvider
-from parsl.providers.cobalt.cobalt import CobaltProvider
 from parsl.providers.condor.condor import CondorProvider
 from parsl.providers.googlecloud.googlecloud import GoogleCloudProvider
 from parsl.providers.grid_engine.grid_engine import GridEngineProvider
@@ -15,7 +14,6 @@ from parsl.providers.slurm.slurm import SlurmProvider
 from parsl.providers.torque.torque import TorqueProvider
 
 __all__ = ['LocalProvider',
-           'CobaltProvider',
            'CondorProvider',
            'GridEngineProvider',
            'SlurmProvider',

parsl/providers/base.py

@@ -2,7 +2,6 @@ import logging
 from abc import ABCMeta, abstractmethod, abstractproperty
 from typing import Any, Dict, List, Optional
 
-from parsl.channels.base import Channel
 from parsl.jobs.states import JobStatus
 
 logger = logging.getLogger(__name__)
@@ -12,7 +11,7 @@ class ExecutionProvider(metaclass=ABCMeta):
     """Execution providers are responsible for managing execution resources
     that have a Local Resource Manager (LRM). For instance, campus clusters
     and supercomputers generally have LRMs (schedulers) such as Slurm,
-    Torque/PBS, Condor and Cobalt. Clouds, on the other hand, have API
+    Torque/PBS, and Condor. Clouds, on the other hand, have API
     interfaces that allow much more fine-grained composition of an execution
     environment. An execution provider abstracts these types of resources and
     provides a single uniform interface to them.
@@ -154,18 +153,3 @@ class ExecutionProvider(metaclass=ABCMeta):
         :return: the number of seconds to wait between calls to status()
         """
         pass
-
-
-class Channeled():
-    """A marker type to indicate that parsl should manage a Channel for this provider"""
-    def __init__(self) -> None:
-        self.channel: Channel
-        pass
-
-
-class MultiChanneled():
-    """A marker type to indicate that parsl should manage multiple Channels for this provider"""
-
-    def __init__(self) -> None:
-        self.channels: List[Channel]
-        pass

parsl/tests/conftest.py

@@ -163,6 +163,10 @@ def pytest_configure(config):
         'markers',
         'executor_supports_std_stream_tuples: Marks tests that require tuple support for stdout/stderr'
     )
+    config.addinivalue_line(
+        'markers',
+        'shared_fs: Marks tests that require a shared_fs between the workers are the test client'
+    )
 
 
 @pytest.fixture(autouse=True, scope='session')

parsl/tests/site_tests/site_config_selector.py

@@ -7,12 +7,7 @@ def fresh_config():
     hostname = os.getenv('PARSL_HOSTNAME', platform.uname().node)
     print("Loading config for {}".format(hostname))
 
-    if 'thetalogin' in hostname:
-        from parsl.tests.configs.theta import fresh_config
-        config = fresh_config()
-        print("Loading Theta config")
-
-    elif 'frontera' in hostname:
+    if 'frontera' in hostname:
         print("Loading Frontera config")
         from parsl.tests.configs.frontera import fresh_config
         config = fresh_config()

parsl/tests/test_bash_apps/test_basic.py

@@ -24,6 +24,7 @@ def foo(x, y, z=10, stdout=None, label=None):
     return f"echo {x} {y} {z}"
 
 
+@pytest.mark.shared_fs
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps"""
 
@@ -38,6 +39,7 @@ def test_command_format_1(tmpd_cwd):
     assert so_content == "1 4 10"
 
 
+@pytest.mark.shared_fs
 def test_auto_log_filename_format(caplog):
     """Testing auto log filename format for BashApps
     """
@@ -66,6 +68,7 @@ def test_auto_log_filename_format(caplog):
         assert record.levelno < logging.ERROR
 
 
+@pytest.mark.shared_fs
 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

@@ -58,6 +58,7 @@ test_matrix = {
 whitelist = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'configs', '*threads*')
 
 
+@pytest.mark.shared_fs
 def test_div_0(test_fn=div_0):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -73,6 +74,7 @@ def test_div_0(test_fn=div_0):
     os.remove('std.out')
 
 
+@pytest.mark.shared_fs
 def test_bash_misuse(test_fn=bash_misuse):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -87,6 +89,7 @@ def test_bash_misuse(test_fn=bash_misuse):
     os.remove('std.out')
 
 
+@pytest.mark.shared_fs
 def test_command_not_found(test_fn=command_not_found):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -103,6 +106,7 @@ def test_command_not_found(test_fn=command_not_found):
     return True
 
 
+@pytest.mark.shared_fs
 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,6 +8,7 @@ def foo(z=2, stdout=None):
     return f"echo {z}"
 
 
+@pytest.mark.shared_fs
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps
     """