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

toil/test/src/busTest.py

@@ -17,10 +17,12 @@ import os
 from threading import Thread, current_thread
 
 from toil.batchSystems.abstractBatchSystem import BatchJobExitReason
-from toil.bus import (JobCompletedMessage,
-                      JobIssuedMessage,
-                      MessageBus,
-                      replay_message_bus)
+from toil.bus import (
+    JobCompletedMessage,
+    JobIssuedMessage,
+    MessageBus,
+    replay_message_bus,
+)
 from toil.common import Toil
 from toil.exceptions import FailedJobsException
 from toil.job import Job
@@ -28,8 +30,9 @@ from toil.test import ToilTest, get_temp_file
 
 logger = logging.getLogger(__name__)
 
+
 class MessageBusTest(ToilTest):
-    
+
     def test_enum_ints_in_file(self) -> None:
         """
         Make sure writing bus messages to files works with enums.
@@ -44,7 +47,7 @@ class MessageBusTest(ToilTest):
         # Make sure stuff goes away in the right order
         del handler_to_keep_alive
         del bus
-        
+
         for line in open(bus_file):
             logger.debug("Bus line: %s", line)
 
@@ -107,17 +110,19 @@ class MessageBusTest(ToilTest):
         Test the ability to restart a workflow when the message bus path used
         by the previous attempt is gone.
         """
-        temp_dir = self._createTempDir(purpose='tempDir')
+        temp_dir = self._createTempDir(purpose="tempDir")
         job_store = self._getTestJobStorePath()
 
-        bus_holder_dir = os.path.join(temp_dir, 'bus_holder')
+        bus_holder_dir = os.path.join(temp_dir, "bus_holder")
         os.mkdir(bus_holder_dir)
 
         start_options = Job.Runner.getDefaultOptions(job_store)
-        start_options.logLevel = 'DEBUG'
+        start_options.logLevel = "DEBUG"
         start_options.retryCount = 0
         start_options.clean = "never"
-        start_options.write_messages = os.path.abspath(os.path.join(bus_holder_dir, 'messagebus.txt'))
+        start_options.write_messages = os.path.abspath(
+            os.path.join(bus_holder_dir, "messagebus.txt")
+        )
 
         root = Job.wrapJobFn(failing_job_fn)
 
@@ -128,17 +133,17 @@ class MessageBusTest(ToilTest):
         except FailedJobsException:
             pass
 
-        logger.info('First attempt successfully failed, removing message bus log')
+        logger.info("First attempt successfully failed, removing message bus log")
 
         # Get rid of the bus
         os.unlink(start_options.write_messages)
         os.rmdir(bus_holder_dir)
 
-        logger.info('Making second attempt')
+        logger.info("Making second attempt")
 
         # Set up options without a specific bus path
         restart_options = Job.Runner.getDefaultOptions(job_store)
-        restart_options.logLevel = 'DEBUG'
+        restart_options.logLevel = "DEBUG"
         restart_options.retryCount = 0
         restart_options.clean = "never"
         restart_options.restart = True
@@ -150,14 +155,11 @@ class MessageBusTest(ToilTest):
         except FailedJobsException:
             pass
 
-        logger.info('Second attempt successfully failed')
+        logger.info("Second attempt successfully failed")
 
 
 def failing_job_fn(job: Job) -> None:
     """
     This function is guaranteed to fail.
     """
-    raise RuntimeError('Job attempted to run but failed')
-
-
-
+    raise RuntimeError("Job attempted to run but failed")

toil/test/src/checkpointTest.py

@@ -63,8 +63,10 @@ class CheckpointTest(ToilTest):
         except FailedJobsException:
             self.fail("Checkpointed workflow restart doesn't clean failures.")
 
+
 class CheckRetryCount(Job):
     """Fail N times, succeed on the next try."""
+
     def __init__(self, numFailuresBeforeSuccess):
         super().__init__(checkpoint=True)
         self.numFailuresBeforeSuccess = numFailuresBeforeSuccess
@@ -73,11 +75,11 @@ class CheckRetryCount(Job):
         """Mark a retry in the fileStore, and return the number of retries so far."""
         try:
             with fileStore.jobStore.read_shared_file_stream("checkpointRun") as f:
-                timesRun = int(f.read().decode('utf-8'))
+                timesRun = int(f.read().decode("utf-8"))
         except NoSuchFileException:
             timesRun = 0
         with fileStore.jobStore.write_shared_file_stream("checkpointRun") as f:
-            f.write(str(timesRun + 1).encode('utf-8'))
+            f.write(str(timesRun + 1).encode("utf-8"))
         return timesRun
 
     def run(self, fileStore):
@@ -86,10 +88,12 @@ class CheckRetryCount(Job):
         if retryCount < self.numFailuresBeforeSuccess:
             self.addChild(AlwaysFail())
 
+
 class AlwaysFail(Job):
     def run(self, fileStore):
         raise RuntimeError(":(")
 
+
 class CheckpointFailsFirstTime(Job):
     def __init__(self):
         super().__init__(checkpoint=True)
@@ -97,8 +101,10 @@ class CheckpointFailsFirstTime(Job):
     def run(self, fileStore):
         self.addChild(FailOnce())
 
+
 class FailOnce(Job):
     """Fail the first time the workflow is run, but succeed thereafter."""
+
     def run(self, fileStore):
         if fileStore.jobStore.config.workflowAttemptNumber < 1:
             raise RuntimeError("first time around")

toil/test/src/deferredFunctionTest.py

@@ -30,28 +30,29 @@ logger = logging.getLogger(__name__)
 
 class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
     """Test the deferred function system."""
+
     # This determines what job store type to use.
-    jobStoreType = 'file'
+    jobStoreType = "file"
 
     def _getTestJobStore(self):
-        if self.jobStoreType == 'file':
+        if self.jobStoreType == "file":
             return self._getTestJobStorePath()
-        elif self.jobStoreType == 'aws':
-            return f'aws:{self.awsRegion()}:cache-tests-{uuid4()}'
-        elif self.jobStoreType == 'google':
-            projectID = os.getenv('TOIL_GOOGLE_PROJECTID')
-            return f'google:{projectID}:cache-tests-{str(uuid4())}'
+        elif self.jobStoreType == "aws":
+            return f"aws:{self.awsRegion()}:cache-tests-{uuid4()}"
+        elif self.jobStoreType == "google":
+            projectID = os.getenv("TOIL_GOOGLE_PROJECTID")
+            return f"google:{projectID}:cache-tests-{str(uuid4())}"
         else:
-            raise RuntimeError('Illegal job store type.')
+            raise RuntimeError("Illegal job store type.")
 
     def setUp(self):
         super().setUp()
         testDir = self._createTempDir()
         self.options = Job.Runner.getDefaultOptions(self._getTestJobStore())
-        self.options.logLevel = 'INFO'
+        self.options.logLevel = "INFO"
         self.options.workDir = testDir
-        self.options.clean = 'always'
-        self.options.logFile = os.path.join(testDir, 'logFile')
+        self.options.clean = "always"
+        self.options.logFile = os.path.join(testDir, "logFile")
 
     # Tests for the various defer possibilities
     def testDeferredFunctionRunsWithMethod(self):
@@ -84,11 +85,11 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
         :param function callableFn: The function to use in the test.
         :return: None
         """
-        workdir = self._createTempDir(purpose='nonLocalDir')
+        workdir = self._createTempDir(purpose="nonLocalDir")
         nonLocalFile1 = os.path.join(workdir, str(uuid4()))
         nonLocalFile2 = os.path.join(workdir, str(uuid4()))
-        open(nonLocalFile1, 'w').close()
-        open(nonLocalFile2, 'w').close()
+        open(nonLocalFile1, "w").close()
+        open(nonLocalFile2, "w").close()
         assert os.path.exists(nonLocalFile1)
         assert os.path.exists(nonLocalFile2)
         A = Job.wrapJobFn(callableFn, files=(nonLocalFile1, nonLocalFile2))
@@ -114,15 +115,16 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
         where a deferred function fails (since the first file doesn't exist on the retry).
         """
         self.options.retryCount = 1
-        workdir = self._createTempDir(purpose='nonLocalDir')
+        workdir = self._createTempDir(purpose="nonLocalDir")
         nonLocalFile1 = os.path.join(workdir, str(uuid4()))
         nonLocalFile2 = os.path.join(workdir, str(uuid4()))
-        open(nonLocalFile1, 'w').close()
-        open(nonLocalFile2, 'w').close()
+        open(nonLocalFile1, "w").close()
+        open(nonLocalFile2, "w").close()
         assert os.path.exists(nonLocalFile1)
         assert os.path.exists(nonLocalFile2)
-        A = Job.wrapJobFn(_deferredFunctionRunsWithFailuresFn,
-                          files=(nonLocalFile1, nonLocalFile2))
+        A = Job.wrapJobFn(
+            _deferredFunctionRunsWithFailuresFn, files=(nonLocalFile1, nonLocalFile2)
+        )
         Job.Runner.startToil(A, self.options)
         assert not os.path.exists(nonLocalFile1)
         assert not os.path.exists(nonLocalFile2)
@@ -145,11 +147,11 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
 
         # There can be no retries
         self.options.retryCount = 0
-        workdir = self._createTempDir(purpose='nonLocalDir')
+        workdir = self._createTempDir(purpose="nonLocalDir")
         nonLocalFile1 = os.path.join(workdir, str(uuid4()))
         nonLocalFile2 = os.path.join(workdir, str(uuid4()))
-        open(nonLocalFile1, 'w').close()
-        open(nonLocalFile2, 'w').close()
+        open(nonLocalFile1, "w").close()
+        open(nonLocalFile2, "w").close()
         assert os.path.exists(nonLocalFile1)
         assert os.path.exists(nonLocalFile2)
         files = [nonLocalFile1, nonLocalFile2]
@@ -157,8 +159,12 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
         # A and B here must run in parallel for this to work
         A = Job.wrapJobFn(_testNewJobsCanHandleOtherJobDeaths_A, files=files, cores=1)
         B = Job.wrapJobFn(_testNewJobsCanHandleOtherJobDeaths_B, files=files, cores=1)
-        C = Job.wrapJobFn(_testNewJobsCanHandleOtherJobDeaths_C, files=files,
-                          expectedResult=False, cores=1)
+        C = Job.wrapJobFn(
+            _testNewJobsCanHandleOtherJobDeaths_C,
+            files=files,
+            expectedResult=False,
+            cores=1,
+        )
         root.addChild(A)
         root.addChild(B)
         B.addChild(C)
@@ -179,21 +185,22 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
 
         # There can be no retries
         self.options.retryCount = 0
-        workdir = self._createTempDir(purpose='nonLocalDir')
+        workdir = self._createTempDir(purpose="nonLocalDir")
         nonLocalFile1 = os.path.join(workdir, str(uuid4()))
         nonLocalFile2 = os.path.join(workdir, str(uuid4()))
         # The first file has to be non zero or meseeks will go into an infinite sleep
-        file1 = open(nonLocalFile1, 'w')
-        file1.write('test')
+        file1 = open(nonLocalFile1, "w")
+        file1.write("test")
         file1.close()
-        open(nonLocalFile2, 'w').close()
+        open(nonLocalFile2, "w").close()
         assert os.path.exists(nonLocalFile1)
         assert os.path.exists(nonLocalFile2)
         # We only use the "A" job here, and we fill in the first file, so all
         # it will do is defer deleting the second file, delete the first file,
         # and die.
-        A = Job.wrapJobFn(_testNewJobsCanHandleOtherJobDeaths_A,
-                          files=(nonLocalFile1, nonLocalFile2))
+        A = Job.wrapJobFn(
+            _testNewJobsCanHandleOtherJobDeaths_A, files=(nonLocalFile1, nonLocalFile2)
+        )
         try:
             Job.Runner.startToil(A, self.options)
         except FailedJobsException:
@@ -201,6 +208,7 @@ class DeferredFunctionTest(ToilTest, metaclass=ABCMeta):
         assert not os.path.exists(nonLocalFile1)
         assert not os.path.exists(nonLocalFile2)
 
+
 def _writeNonLocalFilesMethod(job, files):
     """
     Write some data to 2 files.  Pass them to a registered deferred method.
@@ -209,11 +217,12 @@ def _writeNonLocalFilesMethod(job, files):
     :return: None
     """
     for nlf in files:
-        with open(nlf, 'wb') as nonLocalFileHandle:
+        with open(nlf, "wb") as nonLocalFileHandle:
             nonLocalFileHandle.write(os.urandom(1 * 1024 * 1024))
     job.defer(_deleteMethods._deleteFileMethod, files[0], nlf=files[1])
     return None
 
+
 def _writeNonLocalFilesClassMethod(job, files):
     """
     Write some data to 2 files.  Pass them to a registered deferred class method.
@@ -222,11 +231,12 @@ def _writeNonLocalFilesClassMethod(job, files):
     :return: None
     """
     for nlf in files:
-        with open(nlf, 'wb') as nonLocalFileHandle:
+        with open(nlf, "wb") as nonLocalFileHandle:
             nonLocalFileHandle.write(os.urandom(1 * 1024 * 1024))
     job.defer(_deleteMethods._deleteFileClassMethod, files[0], nlf=files[1])
     return None
 
+
 def _writeNonLocalFilesLambda(job, files):
     """
     Write some data to 2 files.  Pass them to a registered deferred Lambda.
@@ -236,11 +246,12 @@ def _writeNonLocalFilesLambda(job, files):
     """
     lmd = lambda x, nlf: [os.remove(x), os.remove(nlf)]
     for nlf in files:
-        with open(nlf, 'wb') as nonLocalFileHandle:
+        with open(nlf, "wb") as nonLocalFileHandle:
             nonLocalFileHandle.write(os.urandom(1 * 1024 * 1024))
     job.defer(lmd, files[0], nlf=files[1])
     return None
 
+
 def _deferredFunctionRunsWithFailuresFn(job, files):
     """
     Refer testDeferredFunctionRunsWithFailures
@@ -255,6 +266,7 @@ def _deferredFunctionRunsWithFailuresFn(job, files):
         assert os.path.exists(files[1])
         job.defer(_deleteFile, files[1])
 
+
 def _deleteFile(nonLocalFile, nlf=None):
     """
     Delete nonLocalFile and nlf
@@ -270,6 +282,7 @@ def _deleteFile(nonLocalFile, nlf=None):
         os.remove(nlf)
         logger.debug("Successfully removed file: %s", nlf)
 
+
 def _testNewJobsCanHandleOtherJobDeaths_A(job, files):
     """
     Defer deletion of files[1], then wait for _testNewJobsCanHandleOtherJobDeaths_B to
@@ -281,7 +294,7 @@ def _testNewJobsCanHandleOtherJobDeaths_A(job, files):
 
     # Write the pid to files[1] such that we can be sure that this process has died before
     # we spawn the next job that will do the cleanup.
-    with open(files[1], 'w') as fileHandle:
+    with open(files[1], "w") as fileHandle:
         fileHandle.write(str(os.getpid()))
     job.defer(_deleteFile, files[1])
     logger.info("Deferred delete of %s", files[1])
@@ -290,10 +303,11 @@ def _testNewJobsCanHandleOtherJobDeaths_A(job, files):
     os.remove(files[0])
     os.kill(os.getpid(), signal.SIGKILL)
 
+
 def _testNewJobsCanHandleOtherJobDeaths_B(job, files):
     # Write something to files[0] such that we can be sure that this process has started
     # before _testNewJobsCanHandleOtherJobDeaths_A kills itself.
-    with open(files[0], 'w') as fileHandle:
+    with open(files[0], "w") as fileHandle:
         fileHandle.write(str(os.getpid()))
     while os.path.exists(files[0]):
         time.sleep(0.5)

toil/test/src/dockerCheckTest.py

@@ -15,6 +15,7 @@ import unittest
 
 from docker.errors import ImageNotFound
 from toil import checkDockerImageExists, parseDockerAppliance
+from toil.lib.retry import retry
 from toil.test import ToilTest, needs_docker
 
 
@@ -22,80 +23,87 @@ from toil.test import ToilTest, needs_docker
 class DockerCheckTest(ToilTest):
     """Tests checking whether a docker image exists or not."""
 
-    @unittest.skip('Consumes unauthenticated Docker Hub pulls if run')
+    @unittest.skip("Consumes unauthenticated Docker Hub pulls if run")
     def testOfficialUbuntuRepo(self):
         """Image exists.  This should pass."""
-        ubuntu_repo = 'ubuntu:latest'
+        ubuntu_repo = "ubuntu:latest"
         assert checkDockerImageExists(ubuntu_repo)
 
-    @unittest.skip('Consumes unauthenticated Docker Hub pulls if run')
+    @unittest.skip("Consumes unauthenticated Docker Hub pulls if run")
     def testBroadDockerRepo(self):
         """Image exists.  This should pass."""
-        broad_repo = 'broadinstitute/genomes-in-the-cloud:2.0.0'
+        broad_repo = "broadinstitute/genomes-in-the-cloud:2.0.0"
         assert checkDockerImageExists(broad_repo)
 
-    @unittest.skip('Consumes unauthenticated Docker Hub pulls if run')
+    @unittest.skip("Consumes unauthenticated Docker Hub pulls if run")
     def testBroadDockerRepoBadTag(self):
         """Bad tag.  This should raise."""
-        broad_repo = 'broadinstitute/genomes-in-the-cloud:-----'
+        broad_repo = "broadinstitute/genomes-in-the-cloud:-----"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(broad_repo)
 
-    @unittest.skip('Consumes unauthenticated Docker Hub pulls if run')
+    @unittest.skip("Consumes unauthenticated Docker Hub pulls if run")
     def testNonexistentRepo(self):
         """Bad image.  This should raise."""
-        nonexistent_repo = '------:-----'
+        nonexistent_repo = "------:-----"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(nonexistent_repo)
 
     def testToilQuayRepo(self):
         """Image exists.  Should pass."""
-        toil_repo = 'quay.io/ucsc_cgl/toil:latest'
+        toil_repo = "quay.io/ucsc_cgl/toil:latest"
         assert checkDockerImageExists(toil_repo)
 
     def testBadQuayRepoNTag(self):
         """Bad repo and tag.  This should raise."""
-        nonexistent_quay_repo = 'quay.io/--------:---'
+        nonexistent_quay_repo = "quay.io/--------:---"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(nonexistent_quay_repo)
 
     def testBadQuayRepo(self):
         """Bad repo.  This should raise."""
-        nonexistent_quay_repo = 'quay.io/--------:latest'
+        nonexistent_quay_repo = "quay.io/--------:latest"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(nonexistent_quay_repo)
 
     def testBadQuayTag(self):
         """Bad tag.  This should raise."""
-        nonexistent_quay_repo = 'quay.io/ucsc_cgl/toil:---'
+        nonexistent_quay_repo = "quay.io/ucsc_cgl/toil:---"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(nonexistent_quay_repo)
 
     def testGoogleRepo(self):
         """Image exists.  Should pass."""
-        google_repo = 'gcr.io/google-containers/busybox:latest'
+        google_repo = "gcr.io/google-containers/busybox:latest"
         assert checkDockerImageExists(google_repo)
 
+    @retry(
+        errors=[TimeoutError]
+    )  # see: https://github.com/DataBiosphere/toil/issues/4902
     def testBadGoogleRepo(self):
         """Bad repo and tag.  This should raise."""
-        nonexistent_google_repo = 'gcr.io/google-containers/--------:---'
+        nonexistent_google_repo = "gcr.io/google-containers/--------:---"
         with self.assertRaises(ImageNotFound):
             checkDockerImageExists(nonexistent_google_repo)
 
     def testApplianceParser(self):
         """Test that a specified appliance is parsed correctly."""
-        docker_list = ['ubuntu:latest',
-                       'ubuntu',
-                       'broadinstitute/genomes-in-the-cloud:2.0.0',
-                       'quay.io/ucsc_cgl/toil:latest',
-                       'gcr.io/google-containers/busybox:latest']
+        docker_list = [
+            "ubuntu:latest",
+            "ubuntu",
+            "broadinstitute/genomes-in-the-cloud:2.0.0",
+            "quay.io/ucsc_cgl/toil:latest",
+            "gcr.io/google-containers/busybox:latest",
+        ]
         parsings = []
         for image in docker_list:
             registryName, imageName, tag = parseDockerAppliance(image)
             parsings.append([registryName, imageName, tag])
-        expected_parsings = [['docker.io', 'ubuntu', 'latest'],
-                             ['docker.io', 'ubuntu', 'latest'],
-                             ['docker.io', 'broadinstitute/genomes-in-the-cloud', '2.0.0'],
-                             ['quay.io', 'ucsc_cgl/toil', 'latest'],
-                             ['gcr.io', 'google-containers/busybox', 'latest']]
+        expected_parsings = [
+            ["docker.io", "ubuntu", "latest"],
+            ["docker.io", "ubuntu", "latest"],
+            ["docker.io", "broadinstitute/genomes-in-the-cloud", "2.0.0"],
+            ["quay.io", "ucsc_cgl/toil", "latest"],
+            ["gcr.io", "google-containers/busybox", "latest"],
+        ]
         assert parsings == expected_parsings

toil/test/src/environmentTest.py

@@ -0,0 +1,135 @@
+# Copyright (C) 2015-2024 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
+import os
+import time
+from argparse import Namespace
+from threading import Thread
+from typing import Optional
+
+from toil.common import Toil
+from toil.job import Job
+from toil.jobStores.abstractJobStore import NoSuchFileException
+from toil.test import ToilTest
+
+logger = logging.getLogger(__name__)
+
+
+class EnvironmentTest(ToilTest):
+    """
+    Test to make sure that Toil's environment variable save and restore system
+    (environment.pickle) works.
+
+    The environment should be captured once at the start of the workflow and
+    should be sent through based on that, not base don the leader's current
+    environment when the job is launched.
+    """
+
+    def test_environment(self):
+        options = Job.Runner.getDefaultOptions(self._getTestJobStorePath())
+        options.logLevel = "DEBUG"
+        options.retryCount = 0
+
+        main(options)
+
+
+def signal_leader(job):
+    """
+    Make a file in the file store that the leader can see.
+    """
+    with job.fileStore.jobStore.write_shared_file_stream(
+        "jobstarted.txt", encoding="utf-8"
+    ) as stream:
+        stream.write("Job has run")
+
+
+def check_environment(job, try_name: str):
+    """
+    Fail if the test environment is wrong.
+    """
+
+    job.fileStore.log_to_leader(f"Try {try_name} checking environment")
+    value = os.environ["MAGIC_ENV_VAR_123"]
+    job.fileStore.log_to_leader(f"Try {try_name} got: {value}")
+    if value != "Value1":
+        raise RuntimeError("Environment variable is wrong!")
+
+
+def wait_a_bit(job):
+    """
+    Toil job that waits.
+    """
+    time.sleep(10)
+
+
+def check_environment_repeatedly(job):
+    """
+    Toil job that checks the environment, waits, and checks it again, as
+    separate invocations.
+    """
+
+    signal = job.addChildJobFn(signal_leader)
+    check1 = signal.addFollowOnJobFn(check_environment, "try1")
+    waiter = check1.addFollowOnJobFn(wait_a_bit)
+    check2 = waiter.addFollowOnJobFn(check_environment, "try2")
+    # Add another one to make sure we don't chain
+    check3 = waiter.addFollowOnJobFn(check_environment, "try3")
+
+
+def main(options: Optional[Namespace] = None):
+    """
+    Run the actual workflow with the given options.
+    """
+    if not options:
+        # deal with command line arguments
+        parser = Job.Runner.getDefaultArgumentParser()
+        options = parser.parse_args()
+        logging.basicConfig()
+
+    # Set something that should be seen by Toil jobs
+    os.environ["MAGIC_ENV_VAR_123"] = "Value1"
+
+    with Toil(options) as toil:
+
+        # Get a tthe job store so we can use shared files.
+        jobStore = toil._jobStore
+
+        # Once the workflow has started, change the environment
+        def change_environment_later():
+            """
+            After waiting, modify the environment.
+            """
+            while True:
+                # Wait for the workflow to say it ran something
+                time.sleep(5)
+                try:
+                    with jobStore.read_shared_file_stream(
+                        "jobstarted.txt", encoding="utf-8"
+                    ) as stream:
+                        logger.info("Got signal from job: %s", stream.read().strip())
+                        break
+                except NoSuchFileException:
+                    pass
+            # Change the environment variable
+            logger.info("Changing environment variable")
+            os.environ["MAGIC_ENV_VAR_123"] = "Value2"
+
+        changer_thread = Thread(target=change_environment_later)
+        changer_thread.start()
+
+        toil.start(Job.wrapJobFn(check_environment_repeatedly))
+
+
+if __name__ == "__main__":
+    main()