toil 6.1.0a1__py3-none-any.whl → 7.0.0__py3-none-any.whl

toil/provisioners/gceProvisioner.py

@@ -42,13 +42,13 @@ class GCEProvisioner(AbstractProvisioner):
     NODE_BOTO_PATH = "/root/.boto"  # boto file path on instances
     SOURCE_IMAGE = b'projects/kinvolk-public/global/images/family/flatcar-stable'
 
-    def __init__(self, clusterName, clusterType, zone, nodeStorage, nodeStorageOverrides, sseKey):
+    def __init__(self, clusterName, clusterType, zone, nodeStorage, nodeStorageOverrides, sseKey, enable_fuse):
         self.cloud = 'gce'
         self._sseKey = sseKey
 
         # Call base class constructor, which will call createClusterSettings()
         # or readClusterSettings()
-        super().__init__(clusterName, clusterType, zone, nodeStorage, nodeStorageOverrides)
+        super().__init__(clusterName, clusterType, zone, nodeStorage, nodeStorageOverrides, enable_fuse)
 
     def supportedClusterTypes(self):
         return {'mesos'}

toil/provisioners/node.py

@@ -18,6 +18,7 @@ import socket
 import subprocess
 import time
 from itertools import count
+from typing import Union, Dict, Optional, List, Any
 
 from toil.lib.memoize import parse_iso_utc
 
@@ -29,7 +30,8 @@ logger = logging.getLogger(__name__)
 class Node:
     maxWaitTime = 7 * 60
 
-    def __init__(self, publicIP, privateIP, name, launchTime, nodeType, preemptible, tags=None, use_private_ip=None):
+    def __init__(self, publicIP: str, privateIP: str, name: str, launchTime: Union[datetime.datetime, str],
+                 nodeType: Optional[str], preemptible: bool, tags: Optional[Dict[str, str]] = None, use_private_ip: Optional[bool] = None) -> None:
         self.publicIP = publicIP
         self.privateIP = privateIP
         if use_private_ip:
@@ -37,7 +39,13 @@ class Node:
         else:
             self.effectiveIP = self.publicIP or self.privateIP
         self.name = name
-        self.launchTime = launchTime
+        if isinstance(launchTime, datetime.datetime):
+            self.launchTime = launchTime
+        else:
+            try:
+                self.launchTime = parse_iso_utc(launchTime)
+            except ValueError:
+                self.launchTime = datetime.datetime.fromisoformat(launchTime)
         self.nodeType = nodeType
         self.preemptible = preemptible
         self.tags = tags
@@ -65,12 +73,12 @@ class Node:
         """
         if self.launchTime:
             now = datetime.datetime.utcnow()
-            delta = now - parse_iso_utc(self.launchTime)
+            delta = now - self.launchTime
             return 1 - delta.total_seconds() / 3600.0 % 1.0
         else:
             return 1
 
-    def waitForNode(self, role, keyName='core'):
+    def waitForNode(self, role: str, keyName: str='core') -> None:
         self._waitForSSHPort()
         # wait here so docker commands can be used reliably afterwards
         self._waitForSSHKeys(keyName=keyName)
@@ -288,7 +296,7 @@ class Node:
                                % (' '.join(args), exit_code, stdout, stderr))
         return stdout
 
-    def coreRsync(self, args, applianceName='toil_leader', **kwargs):
+    def coreRsync(self, args: List[str], applianceName: str = 'toil_leader', **kwargs: Any) -> int:
         remoteRsync = "docker exec -i %s rsync -v" % applianceName  # Access rsync inside appliance
         parsedArgs = []
         sshCommand = "ssh"

toil/server/app.py

@@ -87,7 +87,7 @@ def create_app(args: argparse.Namespace) -> "connexion.FlaskApp":
 
     if args.cors:
         # enable cross origin resource sharing
-        from flask_cors import CORS  # type: ignore
+        from flask_cors import CORS
         CORS(flask_app.app, resources={r"/ga4gh/*": {"origins": args.cors_origins}})
 
     # add workflow execution service (WES) API endpoints

toil/statsAndLogging.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import gzip
+import io
 import json
 import logging
 import os
@@ -21,8 +22,9 @@ from logging.handlers import RotatingFileHandler
 from threading import Event, Thread
 from typing import IO, TYPE_CHECKING, Any, Callable, List, Optional, Union
 
+from toil.lib.conversions import strtobool
 from toil.lib.expando import Expando
-from toil.lib.resources import get_total_cpu_time
+from toil.lib.resources import ResourceMonitor
 
 if TYPE_CHECKING:
     from toil.common import Config
@@ -38,6 +40,7 @@ __loggingFiles = []
 
 class StatsAndLogging:
     """A thread to aggregate statistics and logging."""
+
     def __init__(self, jobStore: 'AbstractJobStore', config: 'Config') -> None:
         self._stop = Event()
         self._worker = Thread(target=self.statsAndLoggingAggregator,
@@ -49,7 +52,7 @@ class StatsAndLogging:
         self._worker.start()
 
     @classmethod
-    def formatLogStream(cls, stream: Union[IO[str], IO[bytes]], job_name: Optional[str] = None) -> str:
+    def formatLogStream(cls, stream: Union[IO[str], IO[bytes]], stream_name: str) -> str:
         """
         Given a stream of text or bytes, and the job name, job itself, or some
         other optional stringifyable identity info for the job, return a big
@@ -62,7 +65,7 @@ class StatsAndLogging:
 
         :param stream: The stream of text or bytes to print for the user.
         """
-        lines = [f'Log from job "{job_name}" follows:', '=========>']
+        lines = [f'{stream_name} follows:', '=========>']
 
         for line in stream:
             if isinstance(line, bytes):
@@ -73,15 +76,15 @@ class StatsAndLogging:
 
         return '\n'.join(lines)
 
-
     @classmethod
-    def logWithFormatting(cls, jobStoreID: str, jobLogs: Union[IO[str], IO[bytes]], method: Callable[[str], None] = logger.debug,
-                            message: Optional[str] = None) -> None:
+    def logWithFormatting(cls, stream_name: str, jobLogs: Union[IO[str], IO[bytes]],
+                          method: Callable[[str], None] = logger.debug,
+                          message: Optional[str] = None) -> None:
         if message is not None:
             method(message)
 
-        # Format and log the logs, identifying the job with its job store ID.
-        method(cls.formatLogStream(jobLogs, jobStoreID))
+        # Format and log the logs, identifying the stream with the given name.
+        method(cls.formatLogStream(jobLogs, stream_name))
 
     @classmethod
     def writeLogFiles(cls, jobNames: List[str], jobLogList: List[str], config: 'Config', failed: bool = False) -> None:
@@ -95,11 +98,11 @@ class StatsAndLogging:
             logName = ('failed_' if failed else '') + logName
             counter = 0
             while True:
-                suffix = str(counter).zfill(3) + logExtension
+                suffix = '_' + str(counter).zfill(3) + logExtension
                 fullName = os.path.join(logPath, logName + suffix)
                 #  The maximum file name size in the default HFS+ file system is 255 UTF-16 encoding units, so basically 255 characters
                 if len(fullName) >= 255:
-                    return fullName[:(255-len(suffix))] + suffix
+                    return fullName[:(255 - len(suffix))] + suffix
                 if not os.path.exists(fullName):
                     return fullName
                 counter += 1
@@ -118,6 +121,9 @@ class StatsAndLogging:
             # we don't have anywhere to write the logs, return now
             return
 
+        # Make sure the destination exists
+        os.makedirs(path, exist_ok=True)
+
         fullName = createName(path, mainFileName, extension, failed)
         with writeFn(fullName, 'wb') as f:
             for l in jobLogList:
@@ -141,7 +147,7 @@ class StatsAndLogging:
         """
         #  Overall timing
         startTime = time.time()
-        startClock = get_total_cpu_time()
+        startClock = ResourceMonitor.get_total_cpu_time()
 
         def callback(fileHandle: Union[IO[bytes], IO[str]]) -> None:
             statsStr = fileHandle.read()
@@ -150,8 +156,10 @@ class StatsAndLogging:
             stats = json.loads(statsStr, object_hook=Expando)
             if not stats:
                 return
+
             try:
-                logs = stats.workers.logsToMaster
+                # Handle all the log_to_leader messages
+                logs = stats.workers.logs_to_leader
             except AttributeError:
                 # To be expected if there were no calls to log_to_leader()
                 pass
@@ -160,6 +168,28 @@ class StatsAndLogging:
                     logger.log(int(message.level),
                                'Got message from job at time %s: %s',
                                time.strftime('%m-%d-%Y %H:%M:%S'), message.text)
+
+            try:
+                # Handle all the user-level text streams reported back (command output, etc.)
+                user_logs = stats.workers.logging_user_streams
+            except AttributeError:
+                # To be expected if there were no calls to log_user_stream()
+                pass
+            else:
+                for stream_entry in user_logs:
+                    try:
+                        # Unpack the stream name and text.
+                        name, text = stream_entry.name, stream_entry.text
+                    except AttributeError:
+                        # Doesn't have a user-provided stream name and stream
+                        # text, so skip it.
+                        continue
+                    # Since this is sent as inline text we need to pretend to stream it.
+                    # TODO: Save these as individual files if they start to get too big?
+                    cls.logWithFormatting(name, io.StringIO(text), logger.info)
+                    # Save it as a log file, as if it were a Toil-level job.
+                    cls.writeLogFiles([name], [text], config=config)
+
             try:
                 logs = stats.logs
             except AttributeError:
@@ -168,7 +198,7 @@ class StatsAndLogging:
                 # we may have multiple jobs per worker
                 jobNames = logs.names
                 messages = logs.messages
-                cls.logWithFormatting(jobNames[0], messages,
+                cls.logWithFormatting(f'Log from job "{jobNames[0]}"', messages,
                                       message='Received Toil worker log. Disable debug level logging to hide this output')
                 cls.writeLogFiles(jobNames, messages, config=config)
 
@@ -182,7 +212,7 @@ class StatsAndLogging:
 
         # Finish the stats file
         text = json.dumps(dict(total_time=str(time.time() - startTime),
-                               total_clock=str(get_total_cpu_time() - startClock)), ensure_ascii=True)
+                               total_clock=str(ResourceMonitor.get_total_cpu_time() - startClock)), ensure_ascii=True)
         jobStore.write_logs(text)
 
     def check(self) -> None:
@@ -208,32 +238,70 @@ def set_log_level(level: str, set_logger: Optional[logging.Logger] = None) -> No
     level = "CRITICAL" if level.upper() == "OFF" else level.upper()
     set_logger = set_logger if set_logger else root_logger
     set_logger.setLevel(level)
-
     # Suppress any random loggers introduced by libraries we use.
     # Especially boto/boto3.  They print too much.  -__-
     suppress_exotic_logging(__name__)
 
 
-def add_logging_options(parser: ArgumentParser) -> None:
-    """Add logging options to set the global log level."""
+def install_log_color(set_logger: Optional[logging.Logger] = None) -> None:
+    """Make logs colored."""
+    # Most of this code is taken from miniwdl
+    # delayed import
+    import coloredlogs  # type: ignore[import-untyped]
+
+    level_styles = dict(coloredlogs.DEFAULT_LEVEL_STYLES)
+    level_styles["debug"]["color"] = 242
+    level_styles["notice"] = {"color": "green", "bold": True}
+    level_styles["error"]["bold"] = True
+    level_styles["warning"]["bold"] = True
+    level_styles["info"] = {}
+    field_styles = dict(coloredlogs.DEFAULT_FIELD_STYLES)
+    field_styles["asctime"] = {"color": "blue"}
+    field_styles["name"] = {"color": "magenta"}
+    field_styles["levelname"] = {"color": "blue"}
+    field_styles["threadName"] = {"color": "blue"}
+    fmt = "[%(asctime)s] [%(threadName)s] [%(levelname).1s] [%(name)s] %(message)s"  # mimic old toil logging format
+    set_logger = set_logger if set_logger else root_logger
+    coloredlogs.install(
+        level=set_logger.getEffectiveLevel(),
+        logger=set_logger,
+        level_styles=level_styles,
+        field_styles=field_styles,
+        datefmt="%Y-%m-%dT%H:%M:%S%z",  # mimic old toil date format
+        fmt=fmt,
+    )
+
+
+def add_logging_options(parser: ArgumentParser, default_level: Optional[int] = None) -> None:
+    """
+    Add logging options to set the global log level.
+
+    :param default_level: A logging level, like logging.INFO, to use as the default.
+    """
+    if default_level is None:
+        # Make sure we have a log levle to make the default
+        default_level = DEFAULT_LOGLEVEL
+    default_level_name = logging.getLevelName(default_level)
+
     group = parser.add_argument_group("Logging Options")
-    default_loglevel = logging.getLevelName(DEFAULT_LOGLEVEL)
 
     levels = ['Critical', 'Error', 'Warning', 'Debug', 'Info']
     for level in levels:
-        group.add_argument(f"--log{level}", dest="logLevel", default=default_loglevel, action="store_const",
-                           const=level, help=f"Turn on loglevel {level}.  Default: {default_loglevel}.")
+        group.add_argument(f"--log{level}", dest="logLevel", default=default_level_name, action="store_const",
+                           const=level, help=f"Turn on loglevel {level}.  Default: {default_level_name}.")
 
     levels += [l.lower() for l in levels] + [l.upper() for l in levels]
-    group.add_argument("--logOff", dest="logLevel", default=default_loglevel,
+    group.add_argument("--logOff", dest="logLevel", default=default_level_name,
                        action="store_const", const="CRITICAL", help="Same as --logCRITICAL.")
     # Maybe deprecate the above in favor of --logLevel?
 
-    group.add_argument("--logLevel", dest="logLevel", default=default_loglevel, choices=levels,
-                       help=f"Set the log level. Default: {default_loglevel}.  Options: {levels}.")
+    group.add_argument("--logLevel", dest="logLevel", default=default_level_name, choices=levels,
+                       help=f"Set the log level. Default: {default_level_name}.  Options: {levels}.")
     group.add_argument("--logFile", dest="logFile", help="File to log in.")
     group.add_argument("--rotatingLogging", dest="logRotating", action="store_true", default=False,
                        help="Turn on rotating logging, which prevents log files from getting too big.")
+    group.add_argument("--logColors", dest="colored_logs", default=True, type=strtobool, metavar="BOOL",
+                       help="Enable or disable colored logging. Default: %(default)s")
 
 
 def configure_root_logger() -> None:
@@ -264,6 +332,8 @@ def set_logging_from_options(options: Union["Config", Namespace]) -> None:
     configure_root_logger()
     options.logLevel = options.logLevel or logging.getLevelName(root_logger.getEffectiveLevel())
     set_log_level(options.logLevel)
+    if options.colored_logs:
+        install_log_color()
     logger.debug(f"Root logger is at level '{logging.getLevelName(root_logger.getEffectiveLevel())}', "
                  f"'toil' logger at level '{logging.getLevelName(toil_logger.getEffectiveLevel())}'.")
 

toil/test/__init__.py

@@ -36,6 +36,7 @@ from typing import (Any,
                     Dict,
                     Generator,
                     List,
+                    Literal,
                     Optional,
                     Tuple,
                     Type,
@@ -46,17 +47,15 @@ from unittest.util import strclass
 from urllib.error import HTTPError, URLError
 from urllib.request import urlopen
 
-import pytz
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
+if sys.version_info >= (3, 9):
+    import zoneinfo
 else:
-    from typing_extensions import Literal
+    from backports import zoneinfo
 
 from toil import ApplianceImageNotFound, applianceSelf, toilPackageDirPath
 from toil.lib.accelerators import (have_working_nvidia_docker_runtime,
                                    have_working_nvidia_smi)
-from toil.lib.aws import running_on_ec2
 from toil.lib.io import mkdtemp
 from toil.lib.iterables import concat
 from toil.lib.memoize import memoize
@@ -86,8 +85,8 @@ class ToilTest(unittest.TestCase):
     _tempDirs: List[str] = []
 
     def setup_method(self, method: Any) -> None:
-        western = pytz.timezone('America/Los_Angeles')
-        california_time = western.localize(datetime.datetime.now())
+        western = zoneinfo.ZoneInfo("America/Los_Angeles")
+        california_time = datetime.datetime.now(tz=western)
         timestamp = california_time.strftime("%b %d %Y %H:%M:%S:%f %Z")
         print(f"\n\n[TEST] {strclass(self.__class__)}:{self._testMethodName} ({timestamp})\n\n")
 
@@ -127,6 +126,7 @@ class ToilTest(unittest.TestCase):
         Use us-west-2 unless running on EC2, in which case use the region in which
         the instance is located
         """
+        from toil.lib.aws import running_on_ec2
         return cls._region() if running_on_ec2() else 'us-west-2'
 
     @classmethod
@@ -372,14 +372,15 @@ def needs_aws_s3(test_item: MT) -> MT:
     # TODO: we just check for generic access to the AWS account
     test_item = _mark_test('aws-s3', needs_online(test_item))
     try:
-        from boto import config
-        boto_credentials = config.get('Credentials', 'aws_access_key_id')
+        from boto3 import Session
+        session = Session()
+        boto3_credentials = session.get_credentials()
     except ImportError:
         return unittest.skip("Install Toil with the 'aws' extra to include this test.")(
             test_item
         )
-
-    if not (boto_credentials or os.path.exists(os.path.expanduser('~/.aws/credentials')) or running_on_ec2()):
+    from toil.lib.aws import running_on_ec2
+    if not (boto3_credentials or os.path.exists(os.path.expanduser('~/.aws/credentials')) or running_on_ec2()):
         return unittest.skip("Configure AWS credentials to include this test.")(test_item)
     return test_item
 
@@ -632,6 +633,20 @@ def needs_cwl(test_item: MT) -> MT:
     else:
         return test_item
 
+def needs_wdl(test_item: MT) -> MT:
+    """
+    Use as a decorator before test classes or methods to only run them if miniwdl is installed
+    and configured.
+    """
+    test_item = _mark_test('wdl', test_item)
+    try:
+        # noinspection PyUnresolvedReferences
+        import WDL  # noqa
+    except ImportError:
+        return unittest.skip("Install Toil with the 'wdl' extra to include this test.")(test_item)
+    else:
+        return test_item
+
 
 def needs_server(test_item: MT) -> MT:
     """
@@ -747,7 +762,7 @@ def integrative(test_item: MT) -> MT:
         return test_item
     else:
         return unittest.skip(
-            'Set TOIL_TEST_INTEGRATIVE="True" to include this integration test, '
+            'Set TOIL_TEST_INTEGRATIVE=True to include this integration test, '
             "or run `make integration_test_local` to run all integration tests."
         )(test_item)
 

toil/test/batchSystems/batchSystemTest.py

@@ -140,19 +140,16 @@ class hidden:
             """
             return self.createConfig()
 
-        def _mockJobDescription(self, jobStoreID=None, command=None, **kwargs):
+        def _mockJobDescription(self, jobStoreID=None, **kwargs):
             """
-            Create a mock-up JobDescription with the given ID, command, and other parameters.
+            Create a mock-up JobDescription with the given ID and other parameters.
             """
 
             # TODO: Use a real unittest.Mock? For now we make a real instance and just hack it up.
 
             desc = JobDescription(**kwargs)
-            # Normally we can't pass in a command or ID, and the job
-            # serialization logic takes care of filling them in. We set them
-            # here.
-            if command is not None:
-                desc.command = command
+            # Normally we can't pass in an ID, and the job serialization logic
+            # takes care of filling it in. We set it here.
             if jobStoreID is not None:
                 desc.jobStoreID = jobStoreID
 
@@ -185,12 +182,12 @@ class hidden:
 
         @retry_flaky_test(prepare=[tearDown, setUp])
         def test_run_jobs(self):
-            jobDesc1 = self._mockJobDescription(command='sleep 1000', jobName='test1', unitName=None,
+            jobDesc1 = self._mockJobDescription(jobName='test1', unitName=None,
                                                 jobStoreID='1', requirements=defaultRequirements)
-            jobDesc2 = self._mockJobDescription(command='sleep 1000', jobName='test2', unitName=None,
+            jobDesc2 = self._mockJobDescription(jobName='test2', unitName=None,
                                                 jobStoreID='2', requirements=defaultRequirements)
-            job1 = self.batchSystem.issueBatchJob(jobDesc1)
-            job2 = self.batchSystem.issueBatchJob(jobDesc2)
+            job1 = self.batchSystem.issueBatchJob('sleep 1000', jobDesc1)
+            job2 = self.batchSystem.issueBatchJob('sleep 1000', jobDesc2)
 
             issuedIDs = self._waitForJobsToIssue(2)
             self.assertEqual(set(issuedIDs), {job1, job2})
@@ -219,9 +216,9 @@ class hidden:
             # then check for it having happened, but we can't guarantee that
             # the batch system will run against the same filesystem we are
             # looking at.
-            jobDesc3 = self._mockJobDescription(command="mktemp -d", jobName='test3', unitName=None,
+            jobDesc3 = self._mockJobDescription(jobName='test3', unitName=None,
                                                 jobStoreID='3', requirements=defaultRequirements)
-            job3 = self.batchSystem.issueBatchJob(jobDesc3)
+            job3 = self.batchSystem.issueBatchJob("mktemp -d", jobDesc3)
 
             jobUpdateInfo = self.batchSystem.getUpdatedBatchJob(maxWait=1000)
             jobID, exitStatus, wallTime = jobUpdateInfo.jobID, jobUpdateInfo.exitStatus, jobUpdateInfo.wallTime
@@ -252,18 +249,18 @@ class hidden:
 
             # Turn into a string which convinces bash to take all args and paste them back together and run them
             command = "bash -c \"\\${@}\" bash eval " + script_protected
-            jobDesc4 = self._mockJobDescription(command=command, jobName='test4', unitName=None,
+            jobDesc4 = self._mockJobDescription(jobName='test4', unitName=None,
                                                 jobStoreID='4', requirements=defaultRequirements)
-            job4 = self.batchSystem.issueBatchJob(jobDesc4)
+            job4 = self.batchSystem.issueBatchJob(command, jobDesc4)
             jobUpdateInfo = self.batchSystem.getUpdatedBatchJob(maxWait=1000)
             jobID, exitStatus, wallTime = jobUpdateInfo.jobID, jobUpdateInfo.exitStatus, jobUpdateInfo.wallTime
             self.assertEqual(exitStatus, 42)
             self.assertEqual(jobID, job4)
             # Now set the variable and ensure that it is present
             self.batchSystem.setEnv('FOO', 'bar')
-            jobDesc5 = self._mockJobDescription(command=command, jobName='test5', unitName=None,
+            jobDesc5 = self._mockJobDescription(jobName='test5', unitName=None,
                                                 jobStoreID='5', requirements=defaultRequirements)
-            job5 = self.batchSystem.issueBatchJob(jobDesc5)
+            job5 = self.batchSystem.issueBatchJob(command, jobDesc5)
             jobUpdateInfo = self.batchSystem.getUpdatedBatchJob(maxWait=1000)
             self.assertEqual(jobUpdateInfo.exitStatus, 23)
             self.assertEqual(jobUpdateInfo.jobID, job5)
@@ -274,18 +271,18 @@ class hidden:
             command = "bash -c \"\\${@}\" bash eval " + script.replace(';', r'\;')
 
             # Issue a job with a job environment variable
-            job_desc_6 = self._mockJobDescription(command=command, jobName='test6', unitName=None,
+            job_desc_6 = self._mockJobDescription(jobName='test6', unitName=None,
                                                   jobStoreID='6', requirements=defaultRequirements)
-            job6 = self.batchSystem.issueBatchJob(job_desc_6, job_environment={
+            job6 = self.batchSystem.issueBatchJob(command, job_desc_6, job_environment={
                 'FOO': 'bar'
             })
             job_update_info = self.batchSystem.getUpdatedBatchJob(maxWait=1000)
             self.assertEqual(job_update_info.exitStatus, 23)  # this should succeed
             self.assertEqual(job_update_info.jobID, job6)
             # Now check that the environment variable doesn't exist for other jobs
-            job_desc_7 = self._mockJobDescription(command=command, jobName='test7', unitName=None,
+            job_desc_7 = self._mockJobDescription(jobName='test7', unitName=None,
                                                   jobStoreID='7', requirements=defaultRequirements)
-            job7 = self.batchSystem.issueBatchJob(job_desc_7)
+            job7 = self.batchSystem.issueBatchJob(command, job_desc_7)
             job_update_info = self.batchSystem.getUpdatedBatchJob(maxWait=1000)
             self.assertEqual(job_update_info.exitStatus, 42)
             self.assertEqual(job_update_info.jobID, job7)
@@ -619,9 +616,9 @@ class MesosBatchSystemTest(hidden.AbstractBatchSystemTest, MesosTestSupport):
 
     def testIgnoreNode(self):
         self.batchSystem.ignoreNode('localhost')
-        jobDesc = self._mockJobDescription(command='sleep 1000', jobName='test2', unitName=None,
+        jobDesc = self._mockJobDescription(jobName='test2', unitName=None,
                                            jobStoreID='1', requirements=defaultRequirements)
-        job = self.batchSystem.issueBatchJob(jobDesc)
+        job = self.batchSystem.issueBatchJob('sleep 1000', jobDesc)
 
         issuedID = self._waitForJobsToIssue(1)
         self.assertEqual(set(issuedID), {job})
@@ -731,8 +728,13 @@ class SingleMachineBatchSystemTest(hidden.AbstractBatchSystemTest):
                 command += ' hide'
 
             # Start the job
-            self.batchSystem.issueBatchJob(self._mockJobDescription(command=command, jobName='fork',
-                                                                    jobStoreID='1', requirements=defaultRequirements))
+            self.batchSystem.issueBatchJob(
+                command, 
+                self._mockJobDescription(
+                    jobName='fork',
+                    jobStoreID='1',
+                    requirements=defaultRequirements)
+            )
             # Wait
             time.sleep(10)
 
@@ -863,13 +865,18 @@ class MaxCoresSingleMachineBatchSystemTest(ToilTest):
                         try:
                             jobIds = set()
                             for i in range(0, int(jobs)):
-                                jobIds.add(bs.issueBatchJob(JobDescription(command=self.scriptCommand(),
-                                                                           requirements=dict(
-                                                                               cores=float(coresPerJob),
-                                                                               memory=1, disk=1,
-                                                                               accelerators=[],
-                                                                               preemptible=preemptible),
-                                                                           jobName=str(i), unitName='')))
+                                desc = JobDescription(
+                                    requirements=dict(
+                                        cores=float(coresPerJob),
+                                        memory=1,
+                                        disk=1,
+                                        accelerators=[],
+                                        preemptible=preemptible
+                                    ),
+                                    jobName=str(i),
+                                    unitName=''
+                                )
+                                jobIds.add(bs.issueBatchJob(self.scriptCommand(), desc))
                             self.assertEqual(len(jobIds), jobs)
                             while jobIds:
                                 job = bs.getUpdatedBatchJob(maxWait=10)
@@ -894,7 +901,7 @@ class MaxCoresSingleMachineBatchSystemTest(ToilTest):
     @skipIf(SingleMachineBatchSystem.numCores < 3, 'Need at least three cores to run this test')
     def testServices(self):
         options = Job.Runner.getDefaultOptions(self._getTestJobStorePath())
-        options.logDebug = True
+        options.logLevel = "DEBUG"
         options.maxCores = 3
         self.assertTrue(options.maxCores <= SingleMachineBatchSystem.numCores)
         Job.Runner.startToil(Job.wrapJobFn(parentJob, self.scriptCommand()), options)

toil/test/batchSystems/batch_system_plugin_test.py

@@ -0,0 +1,79 @@
+# 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.
+import logging
+from typing import Optional, Dict, List, Type
+from configargparse import ArgParser, ArgumentParser
+
+from toil.batchSystems.abstractBatchSystem import (AbstractBatchSystem, UpdatedBatchJobInfo)
+from toil.batchSystems.cleanup_support import BatchSystemCleanupSupport
+from toil.batchSystems.options import OptionSetter
+from toil.batchSystems.registry import add_batch_system_factory
+from toil.common import Toil, addOptions
+from toil.job import JobDescription
+from toil.test import ToilTest
+
+logger = logging.getLogger(__name__)
+
+
+class FakeBatchSystem(BatchSystemCleanupSupport):
+    @classmethod
+    def supportsAutoDeployment(cls) -> bool:
+        pass
+
+    def issueBatchJob(self, command: str, job_desc: JobDescription, job_environment: Optional[Dict[str, str]] = None) -> int:
+        pass
+
+    def killBatchJobs(self, jobIDs: List[int]) -> None:
+        pass
+
+    def getIssuedBatchJobIDs(self) -> List[int]:
+        pass
+
+    def getRunningBatchJobIDs(self) -> Dict[int, float]:
+        pass
+
+    def getUpdatedBatchJob(self, maxWait: int) -> Optional[UpdatedBatchJobInfo]:
+        pass
+
+    def shutdown(self) -> None:
+        pass
+
+    @classmethod
+    def add_options(cls, parser: ArgumentParser) -> None:
+        parser.add_argument("--fake_argument", default="exists")
+
+    @classmethod
+    def setOptions(cls, setOption: OptionSetter) -> None:
+        setOption("fake_argument")
+
+class BatchSystemPluginTest(ToilTest):
+    def test_batchsystem_plugin_installable(self):
+        """
+        Test that installing a batch system plugin works.
+        :return:
+        """
+        def fake_batch_system_factory() -> Type[AbstractBatchSystem]:
+            return FakeBatchSystem
+
+        add_batch_system_factory("fake", fake_batch_system_factory)
+
+        parser = ArgParser()
+        addOptions(parser)
+
+        options = parser.parse_args(["test-jobstore", "--clean=always"])
+
+        # try to install a batchsystem plugin with some arguments
+        # if the arguments exists, the values should also exist in the config
+        with Toil(options) as toil:
+            self.assertEqual(toil.config.fake_argument == "exists", True)