toil 5.12.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

toil/test/wdl/wdltoil_test.py

@@ -3,23 +3,44 @@ import os
 import shutil
 import subprocess
 import unittest
-import uuid
-import zipfile
-from urllib.request import urlretrieve
+from uuid import uuid4
+from typing import Optional
+
+from unittest.mock import patch
+from typing import Any, Dict, List, Set
 
 import pytest
 
-from toil.test import ToilTest, needs_docker, needs_docker_cuda, needs_google_storage, needs_java, needs_singularity_or_docker, slow
+from toil.provisioners import cluster_factory
+from toil.test import (ToilTest,
+                       needs_docker_cuda,
+                       needs_google_storage,
+                       needs_singularity_or_docker,
+                       slow, integrative)
+from toil.test.provisioners.clusterTest import AbstractClusterTest
 from toil.version import exactPython
-# Don't import the test case directly or pytest will test it again.
-import toil.test.wdl.toilwdlTest
+from toil.wdl.wdltoil import WDLSectionJob, WDLWorkflowGraph
+
+
+class BaseWDLTest(ToilTest):
+    """Base test class for WDL tests."""
 
+    def setUp(self) -> None:
+        """Runs anew before each test to create farm fresh temp dirs."""
+        self.output_dir = os.path.join('/tmp/', 'toil-wdl-test-' + str(uuid4()))
+        os.makedirs(self.output_dir)
 
-class ToilConformanceTests(toil.test.wdl.toilwdlTest.BaseToilWdlTest):
+    def tearDown(self) -> None:
+        if os.path.exists(self.output_dir):
+            shutil.rmtree(self.output_dir)
+
+
+class WDLConformanceTests(BaseWDLTest):
     """
-    New WDL conformance tests for Toil
+    WDL conformance tests for Toil.
     """
     wdl_dir = "wdl-conformance-tests"
+
     @classmethod
     def setUpClass(cls) -> None:
 
@@ -47,7 +68,7 @@ class ToilConformanceTests(toil.test.wdl.toilwdlTest.BaseToilWdlTest):
         p = subprocess.run(self.base_command + ["-v", "1.0", "-n", tests_to_run], capture_output=True)
 
         if p.returncode != 0:
-            print(p.stdout)
+            print(p.stdout.decode('utf-8', errors='replace'))
 
         p.check_returncode()
 
@@ -58,7 +79,7 @@ class ToilConformanceTests(toil.test.wdl.toilwdlTest.BaseToilWdlTest):
         p = subprocess.run(self.base_command + ["-v", "1.1", "-n", tests_to_run], capture_output=True)
 
         if p.returncode != 0:
-            print(p.stdout)
+            print(p.stdout.decode('utf-8', errors='replace'))
 
         p.check_returncode()
 
@@ -69,26 +90,25 @@ class ToilConformanceTests(toil.test.wdl.toilwdlTest.BaseToilWdlTest):
         shutil.rmtree("wdl-conformance-tests")
 
 
-class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
-    """
-    Version of the old Toil WDL tests that tests the new MiniWDL-based implementation.
-    """
+class WDLTests(BaseWDLTest):
+    """Tests for Toil's MiniWDL-based implementation."""
 
     @classmethod
     def setUpClass(cls) -> None:
         """Runs once for all tests."""
         cls.base_command = [exactPython, '-m', 'toil.wdl.wdltoil']
 
-    # We inherit a testMD5sum but it is going to need Singularity and not
-    # Docker now. And also needs to have a WDL 1.0+ WDL file. So we replace it.
+    # We inherit a testMD5sum but it is going to need Singularity or Docker
+    # now. And also needs to have a WDL 1.0+ WDL file. So we replace it.
     @needs_singularity_or_docker
-    def testMD5sum(self):
+    def test_MD5sum(self):
         """Test if Toil produces the same outputs as known good outputs for WDL's
         GATK tutorial #1."""
         wdl = os.path.abspath('src/toil/test/wdl/md5sum/md5sum.1.0.wdl')
         json_file = os.path.abspath('src/toil/test/wdl/md5sum/md5sum.json')
 
-        result_json = subprocess.check_output(self.base_command + [wdl, json_file, '-o', self.output_dir, '--logDebug'])
+        result_json = subprocess.check_output(
+            self.base_command + [wdl, json_file, '-o', self.output_dir, '--logDebug', '--retryCount=0'])
         result = json.loads(result_json)
 
         assert 'ga4ghMd5.value' in result
@@ -96,25 +116,15 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
         assert os.path.exists(result['ga4ghMd5.value'])
         assert os.path.basename(result['ga4ghMd5.value']) == 'md5sum.txt'
 
-    def test_empty_file_path(self):
-        """Test if empty File type inputs are protected against"""
-        wdl = os.path.abspath('src/toil/test/wdl/md5sum/md5sum.1.0.wdl')
-        json_file = os.path.abspath('src/toil/test/wdl/md5sum/empty_file.json')
-
-        p = subprocess.Popen(self.base_command + [wdl, json_file, '-o', self.output_dir, '--logDebug'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = p.communicate()
-        retval = p.wait()
-
-        assert retval != 0
-        assert b'Could not find' in stderr
-
     @needs_singularity_or_docker
-    def test_miniwdl_self_test(self):
+    def test_miniwdl_self_test(self, extra_args: Optional[List[str]] = None) -> None:
         """Test if the MiniWDL self test runs and produces the expected output."""
         wdl_file = os.path.abspath('src/toil/test/wdl/miniwdl_self_test/self_test.wdl')
         json_file = os.path.abspath('src/toil/test/wdl/miniwdl_self_test/inputs.json')
 
-        result_json = subprocess.check_output(self.base_command + [wdl_file, json_file, '-o', self.output_dir, '--outputDialect', 'miniwdl'])
+        result_json = subprocess.check_output(
+            self.base_command + [wdl_file, json_file, '--logDebug', '-o', self.output_dir, '--outputDialect',
+                                 'miniwdl'] + (extra_args or []))
         result = json.loads(result_json)
 
         # Expect MiniWDL-style output with a designated "dir"
@@ -138,10 +148,17 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
         assert 'hello_caller.messages' in outputs
         assert outputs['hello_caller.messages'] == ["Hello, Alyssa P. Hacker!", "Hello, Ben Bitdiddle!"]
 
+    @needs_singularity_or_docker
+    def test_miniwdl_self_test_by_reference(self) -> None:
+        """
+        Test if the MiniWDL self test works when passing input files by URL reference.
+        """
+        self.test_miniwdl_self_test(extra_args=["--referenceInputs=True"])
+
     @slow
     @needs_docker_cuda
     def test_giraffe_deepvariant(self):
-        """Test if Giraffe and CPU DeepVariant run. This could take 25 minutes."""
+        """Test if Giraffe and GPU DeepVariant run. This could take 25 minutes."""
         # TODO: enable test if nvidia-container-runtime and Singularity are installed but Docker isn't.
 
         json_dir = self._createTempDir()
@@ -164,7 +181,8 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
                 "GiraffeDeepVariant.runDeepVariantCallVariants.in_dv_gpu_container": "google/deepvariant:1.3.0-gpu"
             })
 
-        result_json = subprocess.check_output(self.base_command + [wdl_file, json_file, '-o', self.output_dir, '--outputDialect', 'miniwdl'])
+        result_json = subprocess.check_output(
+            self.base_command + [wdl_file, json_file, '-o', self.output_dir, '--outputDialect', 'miniwdl'])
         result = json.loads(result_json)
 
         # Expect MiniWDL-style output with a designated "dir"
@@ -184,7 +202,7 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
     @slow
     @needs_singularity_or_docker
     def test_giraffe(self):
-        """Test if Giraffe runs. This could take 12 minutes. Also we scale it down."""
+        """Test if Giraffe runs. This could take 12 minutes. Also we scale it down but it still demands lots of memory."""
         # TODO: enable test if nvidia-container-runtime and Singularity are installed but Docker isn't.
 
         json_dir = self._createTempDir()
@@ -192,7 +210,9 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
         wdl_file = f"{base_uri}/workflows/giraffe.wdl"
         json_file = f"{base_uri}/params/giraffe.json"
 
-        result_json = subprocess.check_output(self.base_command + [wdl_file, json_file, '-o', self.output_dir, '--outputDialect', 'miniwdl', '--scale', '0.1'])
+        result_json = subprocess.check_output(
+            self.base_command + [wdl_file, json_file, '-o', self.output_dir, '--outputDialect', 'miniwdl', '--scale',
+                                 '0.1'])
         result = json.loads(result_json)
 
         # Expect MiniWDL-style output with a designated "dir"
@@ -224,17 +244,175 @@ class WdlToilTest(toil.test.wdl.toilwdlTest.ToilWdlTest):
         assert os.path.exists(result['ga4ghMd5.value'])
         assert os.path.basename(result['ga4ghMd5.value']) == 'md5sum.txt'
 
-    def test_empty_file_path(self):
-        """Test if empty File type inputs are protected against"""
-        wdl = os.path.abspath('src/toil/test/wdl/md5sum/md5sum.1.0.wdl')
-        json_file = os.path.abspath('src/toil/test/wdl/md5sum/empty_file.json')
+    def test_coalesce(self):
+        """
+        Test if WDLSectionJob can coalesce WDL decls.
+
+        White box test; will need to be changed or removed if the WDL interpreter changes.
+        """
+
+        # Set up data structures for our fake workflow graph to pull from.
+        # This has all decl-type nodes
+        all_decls: Set[str] = set()
+        # And this has all transitive dependencies for all nodes.
+        all_deps: Dict[str, Set[str]] = {}
+
+        def mock_is_decl(self: Any, node_id: str) -> bool:
+            """
+            Replacement function to determine if a node is a decl or not.
+            """
+            return node_id in all_decls
+
+        def mock_get_transitive_dependencies(self: Any, node_id: str) -> Set[str]:
+            """
+            Replacement function to get all the transitive dependencies of a node.
+            """
+            return all_deps[node_id]
+
+        # These are the only two methods coalesce_nodes calls, so we can
+        # replace them to ensure our graph is used without actually needing to
+        # make any WDL objects for it.
+        #
+        # If that changes, the test will need to change! Maybe then it will be
+        # worth extracting a base type for this interface.
+        with patch.object(WDLWorkflowGraph, 'is_decl', mock_is_decl):
+            with patch.object(WDLWorkflowGraph, 'get_transitive_dependencies', mock_get_transitive_dependencies):
+                with self.subTest(msg="Two unrelated decls can coalesce"):
+                    # Set up two unrelated decls
+                    all_decls = {"decl1", "decl2"}
+                    all_deps = {
+                        "decl1": set(),
+                        "decl2": set()
+                    }
+
+                    result = WDLSectionJob.coalesce_nodes(["decl1", "decl2"], WDLWorkflowGraph([]))
+
+                    # Make sure they coalesced
+                    assert len(result) == 1
+                    assert "decl1" in result[0]
+                    assert "decl2" in result[0]
+
+                with self.subTest(msg="A decl will not coalesce with a non-decl"):
+                    all_decls = {"decl"}
+                    all_deps = {
+                        "decl": set(),
+                        "nondecl": set()
+                    }
+
+                    result = WDLSectionJob.coalesce_nodes(["decl", "nondecl"], WDLWorkflowGraph([]))
+
+                    assert len(result) == 2
+                    assert len(result[0]) == 1
+                    assert len(result[1]) == 1
+
+                with self.subTest(msg="Two adjacent decls with a common dependency can coalesce"):
+                    all_decls = {"decl1", "decl2"}
+                    all_deps = {
+                        "decl1": {"base"},
+                        "decl2": {"base"},
+                        "base": set()
+                    }
+
+                    result = WDLSectionJob.coalesce_nodes(["base", "decl1", "decl2"], WDLWorkflowGraph([]))
+
+                    assert len(result) == 2
+                    assert "base" in result[0]
+                    assert "decl1" in result[1]
+                    assert "decl2" in result[1]
+
+                with self.subTest(msg="Two adjacent decls with different dependencies will not coalesce"):
+                    all_decls = {"decl1", "decl2"}
+                    all_deps = {
+                        "decl1": {"base"},
+                        "decl2": set(),
+                        "base": set()
+                    }
+
+                    result = WDLSectionJob.coalesce_nodes(["base", "decl1", "decl2"], WDLWorkflowGraph([]))
+
+                    assert len(result) == 3
+                    assert "base" in result[0]
+
+                with self.subTest(msg="Two adjacent decls with different successors will coalesce"):
+                    all_decls = {"decl1", "decl2"}
+                    all_deps = {
+                        "decl1": set(),
+                        "decl2": set(),
+                        "successor": {"decl2"}
+                    }
+
+                    result = WDLSectionJob.coalesce_nodes(["decl1", "decl2", "successor"], WDLWorkflowGraph([]))
+
+                    assert len(result) == 2
+                    assert "decl1" in result[0]
+                    assert "decl2" in result[0]
+                    assert "successor" in result[1]
+
+
+@integrative
+@slow
+@pytest.mark.timeout(600)
+class WDLKubernetesClusterTest(AbstractClusterTest):
+    """
+    Ensure WDL works on the Kubernetes batchsystem.
+    """
 
-        p = subprocess.Popen(self.base_command + [wdl, json_file, '-o', self.output_dir, '--logDebug'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = p.communicate()
-        retval = p.wait()
+    def __init__(self, name):
+        super().__init__(name)
+        self.clusterName = 'wdl-integration-test-' + str(uuid4())
+        # t2.medium is the minimum t2 instance that permits Kubernetes
+        self.leaderNodeType = "t2.medium"
+        self.instanceTypes = ["t2.medium"]
+        self.clusterType = "kubernetes"
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.jobStore = f'aws:{self.awsRegion()}:wdl-test-{uuid4()}'
+
+    def launchCluster(self) -> None:
+        self.createClusterUtil(args=['--leaderStorage', str(self.requestedLeaderStorage),
+                                     '--nodeTypes', ",".join(self.instanceTypes),
+                                     '-w', ",".join(self.numWorkers),
+                                     '--nodeStorage', str(self.requestedLeaderStorage)])
+
+    def test_wdl_kubernetes_cluster(self):
+        """
+        Test that a wdl workflow works on a kubernetes cluster. Launches a cluster with 1 worker. This runs a wdl
+        workflow that performs an image pull on the worker.
+        :return:
+        """
+        self.numWorkers = "1"
+        self.requestedLeaderStorage = 30
+        # create the cluster
+        self.launchCluster()
+        # get leader
+        self.cluster = cluster_factory(
+            provisioner="aws", zone=self.zone, clusterName=self.clusterName
+        )
+        self.leader = self.cluster.getLeader()
+
+        url = "https://github.com/DataBiosphere/wdl-conformance-tests.git"
+        commit = "09b9659cd01473e836738a2e0dd205df0adb49c5"
+        wdl_dir = "wdl_conformance_tests"
+
+        # get the wdl-conformance-tests repo to get WDL tasks to run
+        self.sshUtil([
+            "bash",
+            "-c",
+            f"git clone {url} {wdl_dir} && cd {wdl_dir} && git checkout {commit}"
+        ])
+
+        # run on kubernetes batchsystem
+        toil_options = ['--batchSystem=kubernetes',
+                        f"--jobstore={self.jobStore}"]
+
+        # run WDL workflow that will run singularity
+        test_options = [f"tests/md5sum/md5sum.wdl", f"tests/md5sum/md5sum.json"]
+        self.sshUtil([
+            "bash",
+            "-c",
+            f"cd {wdl_dir} && toil-wdl-runner {' '.join(test_options)} {' '.join(toil_options)}"])
 
-        assert retval != 0
-        assert b'Could not find' in stderr
 
 if __name__ == "__main__":
     unittest.main()  # run all tests

toil/toilState.py

@@ -183,6 +183,7 @@ class ToilState:
         if job_id in self.__job_database:
             # Update the one true copy in place
             old_truth = self.__job_database[job_id]
+            old_truth.check_new_version(new_truth)
             old_truth.__dict__.update(new_truth.__dict__)
         else:
             # Just keep the new one
@@ -293,7 +294,8 @@ class ToilState:
                     successor.predecessorsFinished.add(jobDesc.jobStoreID)
 
                 # If the successor has no predecessors to finish
-                assert len(successor.predecessorsFinished) <= successor.predecessorNumber
+                if len(successor.predecessorsFinished) > successor.predecessorNumber:
+                    raise RuntimeError("There are more finished predecessors than possible.")
                 if len(successor.predecessorsFinished) == successor.predecessorNumber:
 
                     # It is ready to be run, so remove it from the set of waiting jobs
@@ -322,7 +324,8 @@ class ToilState:
 
                         # We put the successor job in the set of waiting successor
                         # jobs with multiple predecessors
-                        assert successorJobStoreID not in self.jobsToBeScheduledWithMultiplePredecessors
+                        if successorJobStoreID in self.jobsToBeScheduledWithMultiplePredecessors:
+                            raise RuntimeError("Failed to schedule the successor job. The successor job is already scheduled.")
                         self.jobsToBeScheduledWithMultiplePredecessors.add(successorJobStoreID)
 
                         # Process successor
@@ -337,10 +340,8 @@ class ToilState:
                     # We've already seen the successor
 
                     # Add the job as a predecessor
-                    assert (
-                        jobDesc.jobStoreID
-                        not in self.successor_to_predecessors[successorJobStoreID]
-                    )
+                    if jobDesc.jobStoreID in self.successor_to_predecessors[successorJobStoreID]:
+                        raise RuntimeError("Failed to add the job as a predecessor. The job is already added as a predecessor.")
                     self.successor_to_predecessors[successorJobStoreID].add(
                         str(jobDesc.jobStoreID)
                     )

toil/utils/toilClean.py

@@ -22,7 +22,7 @@ logger = logging.getLogger(__name__)
 
 
 def main() -> None:
-    parser = parser_with_common_options(jobstore_option=True)
+    parser = parser_with_common_options(jobstore_option=True, prog="toil clean")
 
     options = parser.parse_args()
     set_logging_from_options(options)

toil/utils/toilConfig.py

@@ -0,0 +1,36 @@
+# Copyright (C) 2015-2021 Regents of the University of California
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Create a config file with all default Toil options."""
+import logging
+import os
+
+from configargparse import ArgParser
+
+from toil.common import generate_config
+from toil.statsAndLogging import add_logging_options, set_logging_from_options
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    parser = ArgParser()
+
+    parser.add_argument("output", default="config.yaml", help="Filepath to write the config file too. Default=%("
+                                                              "default)s")
+    add_logging_options(parser)
+    options = parser.parse_args()
+    set_logging_from_options(options)
+    logger.debug("Attempting to write a default config file to %s.", os.path.abspath(options.output))
+    generate_config(os.path.abspath(options.output))
+    logger.info("Successfully wrote a default config file to %s.", os.path.abspath(options.output))

toil/utils/toilDebugFile.py

@@ -15,17 +15,19 @@
 import argparse
 import logging
 import os.path
+import sys
 from typing import Optional
 
 from toil.common import Config, Toil, parser_with_common_options
-from toil.jobStores.abstractJobStore import AbstractJobStore
+from toil.jobStores.fileJobStore import FileJobStore
 from toil.lib.resources import glob
+from toil.lib.conversions import strtobool
 from toil.statsAndLogging import set_logging_from_options
 
 logger = logging.getLogger(__name__)
 
 
-def fetchJobStoreFiles(jobStore: AbstractJobStore, options: argparse.Namespace) -> None:
+def fetchJobStoreFiles(jobStore: FileJobStore, options: argparse.Namespace) -> None:
     """
     Takes a list of file names as glob patterns, searches for these within a
     given directory, and attempts to take all of the files found and copy them
@@ -37,6 +39,10 @@ def fetchJobStoreFiles(jobStore: AbstractJobStore, options: argparse.Namespace)
     :param options.localFilePath: Local directory to copy files into.
     :param options.jobStore: The path to the jobStore directory.
     """
+
+    # TODO: Implement the necessary methods in the job store class and stop
+    # globbing around inside it. Does this even work?
+
     for jobStoreFile in options.fetch:
         jobStoreHits = glob(directoryname=options.jobStore,
                             glob_pattern=jobStoreFile)
@@ -48,40 +54,42 @@ def fetchJobStoreFiles(jobStore: AbstractJobStore, options: argparse.Namespace)
                                symlink=options.useSymlinks)
 
 
-def printContentsOfJobStore(jobStorePath: str, nameOfJob: Optional[str] = None) -> None:
+def printContentsOfJobStore(job_store: FileJobStore, job_id: Optional[str] = None) -> None:
     """
-    Fetch a list of all files contained in the jobStore directory input if
-    nameOfJob is not declared, otherwise it only prints out the names of files
-    for that specific job for which it can find a match.  Also creates a logFile
-    containing this same record of job files in the working directory.
-
-    :param jobStorePath: Directory path to recursively look for files.
-    :param nameOfJob: Default is None, which prints out all files in the jobStore.
-    If specified, it will print all jobStore files that have been written to the
-    jobStore by that job.
+    Fetch a list of all files contained in the job store if nameOfJob is not
+    declared, otherwise it only prints out the names of files for that specific
+    job for which it can find a match.  Also creates a log file of these file
+    names in the current directory.
+
+    :param job_store: Job store to ask for files from.
+    :param job_id: Default is None, which prints out all files in the jobStore.
+        If specified, it will print all jobStore files that have been written
+        to the jobStore by that job.
     """
 
-    if nameOfJob:
-        glob_pattern = "*" + nameOfJob + "*"
-        logFile = nameOfJob + "_fileset.txt"
+    # TODO: Implement the necessary methods for job stores other than
+    # FileJobStore.
+
+    if job_id:
+        logFile = job_id.replace("/", "_") + "_fileset.txt"
     else:
-        glob_pattern = "*"
         logFile = "jobstore_files.txt"
-        nameOfJob = ""
 
-    list_of_files = glob(directoryname=jobStorePath, glob_pattern=glob_pattern)
+    list_of_files = job_store.list_all_file_names(for_job=job_id)
     if os.path.exists(logFile):
         os.remove(logFile)
     for gfile in sorted(list_of_files):
-        if not gfile.endswith('.new'):
-            logger.debug(f"{nameOfJob} File: {os.path.basename(gfile)}")
-            with open(logFile, "a+") as f:
-                f.write(os.path.basename(gfile))
-                f.write("\n")
+        if job_id:
+            logger.debug(f"{job_id} File: {os.path.basename(gfile)}")
+        else:
+            logger.debug(f"File: {os.path.basename(gfile)}")
+        with open(logFile, "a+") as f:
+            f.write(os.path.basename(gfile))
+            f.write("\n")
 
 
 def main() -> None:
-    parser = parser_with_common_options(jobstore_option=True)
+    parser = parser_with_common_options(jobstore_option=True, prog="toil debug-file")
     parser.add_argument("--localFilePath",
                         nargs=1,
                         help="Location to which to copy job store files.")
@@ -90,11 +98,11 @@ def main() -> None:
                         help="List of job-store files to be copied locally."
                              "Use either explicit names (i.e. 'data.txt'), or "
                              "specify glob patterns (i.e. '*.txt')")
-    parser.add_argument("--listFilesInJobStore",
+    parser.add_argument("--listFilesInJobStore", type=strtobool,
                         help="Prints a list of the current files in the jobStore.")
-    parser.add_argument("--fetchEntireJobStore",
+    parser.add_argument("--fetchEntireJobStore", type=strtobool,
                         help="Copy all job store files into a local directory.")
-    parser.add_argument("--useSymlinks",
+    parser.add_argument("--useSymlinks", type=strtobool,
                         help="Creates symlink 'shortcuts' of files in the localFilePath"
                              " instead of hardlinking or copying, where possible.  If this is"
                              " not possible, it will copy the files (shutil.copyfile()).")
@@ -109,18 +117,37 @@ def main() -> None:
 
     if options.fetch:
         # Copy only the listed files locally
-        logger.debug("Fetching local files: %s", options.fetch)
-        fetchJobStoreFiles(jobStore=jobStore, options=options)
+
+        if isinstance(jobStore, FileJobStore):
+            logger.debug("Fetching local files: %s", options.fetch)
+            fetchJobStoreFiles(jobStore=jobStore, options=options)
+        else:
+            # The user asked for something we can't do yet.
+            # Tell them no but don't stack trace.
+            logger.critical("Can only fetch by name or glob from file-based job stores")
+            sys.exit(1)
 
     elif options.fetchEntireJobStore:
         # Copy all jobStore files locally
-        logger.debug("Fetching all local files.")
-        options.fetch = "*"
-        fetchJobStoreFiles(jobStore=jobStore, options=options)
+
+        if isinstance(jobStore, FileJobStore):
+            logger.debug("Fetching all local files.")
+            options.fetch = "*"
+            fetchJobStoreFiles(jobStore=jobStore, options=options)
+        else:
+            logger.critical("Can only fetch by name or glob from file-based job stores")
+            sys.exit(1)
 
     if options.listFilesInJobStore:
         # Log filenames and create a file containing these names in cwd
-        printContentsOfJobStore(jobStorePath=options.jobStore)
+
+        if isinstance(jobStore, FileJobStore):
+            printContentsOfJobStore(job_store=jobStore)
+        else:
+            logger.critical("Can only list files from file-based job stores")
+            sys.exit(1)
+
+    # TODO: We can't actually do *anything* for non-file job stores.
 
 
 if __name__ == "__main__":