def main(): parser = parser_with_common_options(jobstore_option=True) parser.add_argument( "jobID", nargs=1, help= "The job store id of a job within the provided jobstore to run by itself." ) parser.add_argument( "--printJobInfo", nargs=1, help= "Return information about this job to the user including preceding jobs, " "inputs, outputs, and runtime from the last known run.") options = parser.parse_args() set_logging_from_options(options) config = Config() config.setOptions(options) jobStore = Toil.resumeJobStore(config.jobStore) if options.printJobInfo: printContentsOfJobStore(jobStorePath=config.jobStore, nameOfJob=options.printJobInfo) # TODO: Option to print list of successor jobs # TODO: Option to run job within python debugger, allowing step through of arguments # idea would be to have option to import pdb and set breakpoint at the start of the user's code jobID = options.jobID[0] logger.debug(f"Running the following job locally: {jobID}") workerScript(jobStore, config, jobID, jobID, redirectOutputToLogFile=False) logger.debug(f"Finished running: {jobID}")
def _runDebugJob(self, jobCommand, jobID, environment): """ Run the jobCommand right now, in the current thread. May only be called in debug-worker mode. Assumes resources are available. """ assert self.debugWorker # TODO: It is not possible to kill running jobs in forkless mode, # because they are run immediately in the main thread. info = Info(time.time(), None, None, killIntended=False) self.runningJobs[jobID] = info if jobCommand.startswith("_toil_worker "): # We can actually run in this thread jobName, jobStoreLocator, jobStoreID = jobCommand.split()[ 1:] # Parse command jobStore = Toil.resumeJobStore(jobStoreLocator) toil_worker.workerScript( jobStore, jobStore.config, jobName, jobStoreID, redirectOutputToLogFile=not self.debugWorker ) # Call the worker else: # Run synchronously. If starting or running the command fails, let the exception stop us. subprocess.check_call(jobCommand, shell=True, env=dict(os.environ, **environment)) self.runningJobs.pop(jobID) if not info.killIntended: self.outputQueue.put((jobID, 0, time.time() - info.time))
def _runWorker(self, jobCommand, jobID, environment): """ Run the jobCommand using the worker and wait for it to finish. The worker is forked unless it is a '_toil_worker' job and debugWorker is True. """ startTime = time.time() # Time job is started if self.debugWorker and "_toil_worker" in jobCommand: # Run the worker without forking jobName, jobStoreLocator, jobStoreID = jobCommand.split()[ 1:] # Parse command jobStore = Toil.resumeJobStore(jobStoreLocator) # TODO: The following does not yet properly populate self.runningJobs so it is not possible to kill # running jobs in forkless mode - see the "None" value in place of popen info = Info(time.time(), None, killIntended=False) try: self.runningJobs[jobID] = info try: toil_worker.workerScript( jobStore, jobStore.config, jobName, jobStoreID, redirectOutputToLogFile=not self.debugWorker ) # Call the worker finally: self.runningJobs.pop(jobID) finally: if not info.killIntended: self.outputQueue.put((jobID, 0, time.time() - startTime)) else: with self.popenLock: popen = subprocess.Popen(jobCommand, shell=True, env=dict(os.environ, **environment)) info = Info(time.time(), popen, killIntended=False) try: self.runningJobs[jobID] = info try: statusCode = popen.wait() if statusCode != 0 and not info.killIntended: log.error( "Got exit code %i (indicating failure) " "from job %s.", statusCode, self.jobs[jobID]) finally: self.runningJobs.pop(jobID) finally: if not info.killIntended: self.outputQueue.put( (jobID, statusCode, time.time() - startTime))
def main(): parser = getBasicOptionParser() parser.add_argument( "jobStore", type=str, help="The location of the job store used by the workflow." + jobStoreLocatorHelp) parser.add_argument("jobID", nargs=1, help="The job store id of a job " "within the provided jobstore to run by itself.") parser.add_argument( "--printJobInfo", nargs=1, help="Return information about this job to the user" " including preceding jobs, inputs, outputs, and runtime" " from the last known run.") parser.add_argument("--version", action='version', version=version) # Parse options options = parseBasicOptions(parser) config = Config() config.setOptions(options) # Load the job store jobStore = Toil.resumeJobStore(config.jobStore) if options.printJobInfo: printContentsOfJobStore(jobStorePath=options.jobStore, nameOfJob=options.printJobInfo) # TODO: Option to print list of successor jobs # TODO: Option to run job within python debugger, allowing step through of arguments # idea would be to have option to import pdb and set breakpoint at the start of the user's code # Run the job locally jobID = options.jobID[0] logger.debug("Going to run the following job locally: %s", jobID) workerScript(jobStore, config, jobID, jobID, redirectOutputToLogFile=False) logger.debug("Ran the following job locally: %s", jobID)