X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/a7b09c6956e5a98df99b7fa4322c69e502f430c6..a3d2b8e1de5b8c785846ddc57ae9a4c02bc51adc:/sdk/cwl/arvados_cwl/executor.py diff --git a/sdk/cwl/arvados_cwl/executor.py b/sdk/cwl/arvados_cwl/executor.py index 27e6ad41bc..0bb17e99a2 100644 --- a/sdk/cwl/arvados_cwl/executor.py +++ b/sdk/cwl/arvados_cwl/executor.py @@ -2,6 +2,12 @@ # # SPDX-License-Identifier: Apache-2.0 +from __future__ import division +from builtins import next +from builtins import object +from builtins import str +from future.utils import viewvalues, viewitems + import argparse import logging import os @@ -12,6 +18,7 @@ import json import re from functools import partial import time +import urllib from cwltool.errors import WorkflowException import cwltool.workflow @@ -25,20 +32,20 @@ from arvados.errors import ApiError import arvados_cwl.util from .arvcontainer import RunnerContainer -from .arvjob import RunnerJob, RunnerTemplate from .runner import Runner, upload_docker, upload_job_order, upload_workflow_deps -from .arvtool import ArvadosCommandTool, validate_cluster_target +from .arvtool import ArvadosCommandTool, validate_cluster_target, ArvadosExpressionTool from .arvworkflow import ArvadosWorkflow, upload_workflow from .fsaccess import CollectionFsAccess, CollectionFetcher, collectionResolver, CollectionCache, pdh_size from .perf import Perf from .pathmapper import NoFollowPathMapper -from .task_queue import TaskQueue +from cwltool.task_queue import TaskQueue from .context import ArvLoadingContext, ArvRuntimeContext from ._version import __version__ from cwltool.process import shortname, UnsupportedRequirement, use_custom_schema -from cwltool.pathmapper import adjustFileObjs, adjustDirObjs, get_listing, visit_class +from cwltool.utils import adjustFileObjs, adjustDirObjs, get_listing, visit_class, aslist from cwltool.command_line_tool import compute_checksums +from cwltool.load_tool import load_tool logger = logging.getLogger('arvados.cwl-runner') metrics = logging.getLogger('arvados.cwl-runner.metrics') @@ -53,6 +60,7 @@ class RuntimeStatusLoggingHandler(logging.Handler): def __init__(self, runtime_status_update_func): super(RuntimeStatusLoggingHandler, self).__init__() self.runtime_status_update = runtime_status_update_func + self.updatingRuntimeStatus = False def emit(self, record): kind = None @@ -60,26 +68,31 @@ class RuntimeStatusLoggingHandler(logging.Handler): kind = 'error' elif record.levelno >= logging.WARNING: kind = 'warning' - if kind is not None: - log_msg = record.getMessage() - if '\n' in log_msg: - # If the logged message is multi-line, use its first line as status - # and the rest as detail. - status, detail = log_msg.split('\n', 1) - self.runtime_status_update( - kind, - "%s: %s" % (record.name, status), - detail - ) - else: - self.runtime_status_update( - kind, - "%s: %s" % (record.name, record.getMessage()) - ) + if kind is not None and self.updatingRuntimeStatus is not True: + self.updatingRuntimeStatus = True + try: + log_msg = record.getMessage() + if '\n' in log_msg: + # If the logged message is multi-line, use its first line as status + # and the rest as detail. + status, detail = log_msg.split('\n', 1) + self.runtime_status_update( + kind, + "%s: %s" % (record.name, status), + detail + ) + else: + self.runtime_status_update( + kind, + "%s: %s" % (record.name, record.getMessage()) + ) + finally: + self.updatingRuntimeStatus = False + class ArvCwlExecutor(object): - """Execute a CWL tool or workflow, submit work (using either jobs or - containers API), wait for them to complete, and report output. + """Execute a CWL tool or workflow, submit work (using containers API), + wait for them to complete, and report output. """ @@ -87,7 +100,8 @@ class ArvCwlExecutor(object): arvargs=None, keep_client=None, num_retries=4, - thread_count=4): + thread_count=4, + stdout=sys.stdout): if arvargs is None: arvargs = argparse.Namespace() @@ -118,6 +132,9 @@ class ArvCwlExecutor(object): self.poll_interval = 12 self.loadingContext = None self.should_estimate_cache_size = True + self.fs_access = None + self.secret_store = None + self.stdout = stdout if keep_client is not None: self.keep_client = keep_client @@ -139,7 +156,7 @@ class ArvCwlExecutor(object): num_retries=self.num_retries) self.work_api = None - expected_api = ["jobs", "containers"] + expected_api = ["containers"] for api in expected_api: try: methods = self.api._rootDesc.get('resources')[api]['methods'] @@ -157,19 +174,11 @@ class ArvCwlExecutor(object): raise Exception("Unsupported API '%s', expected one of %s" % (arvargs.work_api, expected_api)) if self.work_api == "jobs": - logger.warn(""" + logger.error(""" ******************************* -Using the deprecated 'jobs' API. - -To get rid of this warning: - -Users: read about migrating at -http://doc.arvados.org/user/cwl/cwl-style.html#migrate -and use the option --api=containers - -Admins: configure the cluster to disable the 'jobs' API as described at: -http://doc.arvados.org/install/install-api-server.html#disable_api_methods +The 'jobs' API is no longer supported. *******************************""") + exit(1) self.loadingContext = ArvLoadingContext(vars(arvargs)) self.loadingContext.fetcher_constructor = self.fetcher_constructor @@ -180,14 +189,19 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods # if running inside a container if arvados_cwl.util.get_current_container(self.api, self.num_retries, logger): root_logger = logging.getLogger('') + + # Remove existing RuntimeStatusLoggingHandlers if they exist + handlers = [h for h in root_logger.handlers if not isinstance(h, RuntimeStatusLoggingHandler)] + root_logger.handlers = handlers + handler = RuntimeStatusLoggingHandler(self.runtime_status_update) root_logger.addHandler(handler) - self.runtimeContext = ArvRuntimeContext(vars(arvargs)) - self.runtimeContext.make_fs_access = partial(CollectionFsAccess, + self.toplevel_runtimeContext = ArvRuntimeContext(vars(arvargs)) + self.toplevel_runtimeContext.make_fs_access = partial(CollectionFsAccess, collection_cache=self.collection_cache) - validate_cluster_target(self, self.runtimeContext) + validate_cluster_target(self, self.toplevel_runtimeContext) def arv_make_tool(self, toolpath_object, loadingContext): @@ -195,8 +209,10 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods return ArvadosCommandTool(self, toolpath_object, loadingContext) elif "class" in toolpath_object and toolpath_object["class"] == "Workflow": return ArvadosWorkflow(self, toolpath_object, loadingContext) + elif "class" in toolpath_object and toolpath_object["class"] == "ExpressionTool": + return ArvadosExpressionTool(self, toolpath_object, loadingContext) else: - return cwltool.workflow.default_make_tool(toolpath_object, loadingContext) + raise Exception("Unknown tool %s" % toolpath_object.get("class")) def output_callback(self, out, processStatus): with self.workflow_eval_lock: @@ -237,50 +253,37 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods activity statuses, for example in the RuntimeStatusLoggingHandler. """ with self.workflow_eval_lock: - current = arvados_cwl.util.get_current_container(self.api, self.num_retries, logger) + current = None + try: + current = arvados_cwl.util.get_current_container(self.api, self.num_retries, logger) + except Exception as e: + logger.info("Couldn't get current container: %s", e) if current is None: return runtime_status = current.get('runtime_status', {}) - # In case of status being an error, only report the first one. - if kind == 'error': - if not runtime_status.get('error'): - runtime_status.update({ - 'error': message - }) - if detail is not None: - runtime_status.update({ - 'errorDetail': detail - }) - # Further errors are only mentioned as a count. - else: - # Get anything before an optional 'and N more' string. - try: - error_msg = re.match( - r'^(.*?)(?=\s*\(and \d+ more\)|$)', runtime_status.get('error')).groups()[0] - more_failures = re.match( - r'.*\(and (\d+) more\)', runtime_status.get('error')) - except TypeError: - # Ignore tests stubbing errors - return - if more_failures: - failure_qty = int(more_failures.groups()[0]) - runtime_status.update({ - 'error': "%s (and %d more)" % (error_msg, failure_qty+1) - }) - else: - runtime_status.update({ - 'error': "%s (and 1 more)" % error_msg - }) - elif kind in ['warning', 'activity']: - # Record the last warning/activity status without regard of - # previous occurences. + if kind in ('error', 'warning'): + updatemessage = runtime_status.get(kind, "") + if not updatemessage: + updatemessage = message + + # Subsequent messages tacked on in detail + updatedetail = runtime_status.get(kind+'Detail', "") + maxlines = 40 + if updatedetail.count("\n") < maxlines: + if updatedetail: + updatedetail += "\n" + updatedetail += message + "\n" + + if detail: + updatedetail += detail + "\n" + + if updatedetail.count("\n") >= maxlines: + updatedetail += "\nSome messages may have been omitted. Check the full log." + runtime_status.update({ - kind: message + kind: updatemessage, + kind+'Detail': updatedetail, }) - if detail is not None: - runtime_status.update({ - kind+"Detail": detail - }) else: # Ignore any other status kind return @@ -317,7 +320,7 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods return "[%s %s]" % (self.work_api[0:-1], obj.name) def poll_states(self): - """Poll status of jobs or containers listed in the processes dict. + """Poll status of containers listed in the processes dict. Runs in a separate thread. """ @@ -330,7 +333,7 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods if self.stop_polling.is_set(): break with self.workflow_eval_lock: - keys = list(self.processes.keys()) + keys = list(self.processes) if not keys: remain_wait = self.poll_interval continue @@ -338,18 +341,15 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods begin_poll = time.time() if self.work_api == "containers": table = self.poll_api.container_requests() - elif self.work_api == "jobs": - table = self.poll_api.jobs() pageSize = self.poll_api._rootDesc.get('maxItemsPerResponse', 1000) while keys: page = keys[:pageSize] - keys = keys[pageSize:] try: proc_states = table.list(filters=[["uuid", "in", page]]).execute(num_retries=self.num_retries) - except Exception as e: - logger.warn("Error checking states on API server: %s", e) + except Exception: + logger.exception("Error checking states on API server: %s") remain_wait = self.poll_interval continue @@ -361,6 +361,8 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods "new_attributes": p } }) + keys = keys[pageSize:] + finish_poll = time.time() remain_wait = self.poll_interval - (finish_poll - begin_poll) except: @@ -380,33 +382,29 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods for i in self.intermediate_output_collections: try: self.api.collections().delete(uuid=i).execute(num_retries=self.num_retries) - except: - logger.warn("Failed to delete intermediate output: %s", sys.exc_info()[1], exc_info=(sys.exc_info()[1] if self.debug else False)) - if sys.exc_info()[0] is KeyboardInterrupt or sys.exc_info()[0] is SystemExit: + except Exception: + logger.warning("Failed to delete intermediate output: %s", sys.exc_info()[1], exc_info=(sys.exc_info()[1] if self.debug else False)) + except (KeyboardInterrupt, SystemExit): break - def check_features(self, obj): + def check_features(self, obj, parentfield=""): if isinstance(obj, dict): - if obj.get("writable") and self.work_api != "containers": - raise SourceLine(obj, "writable", UnsupportedRequirement).makeError("InitialWorkDir feature 'writable: true' not supported with --api=jobs") if obj.get("class") == "DockerRequirement": if obj.get("dockerOutputDirectory"): - if self.work_api != "containers": - raise SourceLine(obj, "dockerOutputDirectory", UnsupportedRequirement).makeError( - "Option 'dockerOutputDirectory' of DockerRequirement not supported with --api=jobs.") if not obj.get("dockerOutputDirectory").startswith('/'): raise SourceLine(obj, "dockerOutputDirectory", validate.ValidationException).makeError( "Option 'dockerOutputDirectory' must be an absolute path.") - if obj.get("class") == "http://commonwl.org/cwltool#Secrets" and self.work_api != "containers": - raise SourceLine(obj, "class", UnsupportedRequirement).makeError("Secrets not supported with --api=jobs") - for v in obj.itervalues(): - self.check_features(v) + if obj.get("class") == "InplaceUpdateRequirement": + if obj["inplaceUpdate"] and parentfield == "requirements": + raise SourceLine(obj, "class", UnsupportedRequirement).makeError("InplaceUpdateRequirement not supported for keep collections.") + for k,v in viewitems(obj): + self.check_features(v, parentfield=k) elif isinstance(obj, list): for i,v in enumerate(obj): with SourceLine(obj, i, UnsupportedRequirement, logger.isEnabledFor(logging.DEBUG)): - self.check_features(v) + self.check_features(v, parentfield=parentfield) - def make_output_collection(self, name, storage_classes, tagsString, outputObj): + def make_output_collection(self, name, storage_classes, tagsString, output_properties, outputObj): outputObj = copy.deepcopy(outputObj) files = [] @@ -423,27 +421,27 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods num_retries=self.num_retries) for k,v in generatemapper.items(): - if k.startswith("_:"): - if v.type == "Directory": + if v.type == "Directory" and v.resolved.startswith("_:"): continue - if v.type == "CreateFile": - with final.open(v.target, "wb") as f: - f.write(v.resolved.encode("utf-8")) + if v.type == "CreateFile" and (k.startswith("_:") or v.resolved.startswith("_:")): + with final.open(v.target, "wb") as f: + f.write(v.resolved.encode("utf-8")) continue - if not k.startswith("keep:"): + if not v.resolved.startswith("keep:"): raise Exception("Output source is not in keep or a literal") - sp = k.split("/") + sp = v.resolved.split("/") srccollection = sp[0][5:] try: reader = self.collection_cache.get(srccollection) - srcpath = "/".join(sp[1:]) if len(sp) > 1 else "." + srcpath = urllib.parse.unquote("/".join(sp[1:]) if len(sp) > 1 else ".") final.copy(srcpath, v.target, source_collection=reader, overwrite=False) except arvados.errors.ArgumentError as e: logger.error("Creating CollectionReader for '%s' '%s': %s", k, v, e) raise except IOError as e: - logger.warn("While preparing output collection: %s", e) + logger.error("While preparing output collection: %s", e) + raise def rewrite(fileobj): fileobj["location"] = generatemapper.mapper(fileobj["location"]).target @@ -455,9 +453,12 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods adjustFileObjs(outputObj, rewrite) with final.open("cwl.output.json", "w") as f: - json.dump(outputObj, f, sort_keys=True, indent=4, separators=(',',': ')) + res = str(json.dumps(outputObj, sort_keys=True, indent=4, separators=(',',': '), ensure_ascii=False)) + f.write(res) - final.save_new(name=name, owner_uuid=self.project_uuid, storage_classes=storage_classes, ensure_unique_name=True) + + final.save_new(name=name, owner_uuid=self.project_uuid, storage_classes=storage_classes, + ensure_unique_name=True, properties=output_properties) logger.info("Final output collection %s \"%s\" (%s)", final.portable_data_hash(), final.api_response()["name"], @@ -487,27 +488,38 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods self.api.containers().update(uuid=current['uuid'], body={ 'output': self.final_output_collection.portable_data_hash(), + 'output_properties': self.final_output_collection.get_properties(), }).execute(num_retries=self.num_retries) self.api.collections().update(uuid=self.final_output_collection.manifest_locator(), body={ 'is_trashed': True }).execute(num_retries=self.num_retries) - except Exception as e: - logger.info("Setting container output: %s", e) - elif self.work_api == "jobs" and "TASK_UUID" in os.environ: - self.api.job_tasks().update(uuid=os.environ["TASK_UUID"], - body={ - 'output': self.final_output_collection.portable_data_hash(), - 'success': self.final_status == "success", - 'progress':1.0 - }).execute(num_retries=self.num_retries) - - def arv_executor(self, tool, job_order, runtimeContext, logger=None): + except Exception: + logger.exception("Setting container output") + raise + + def apply_reqs(self, job_order_object, tool): + if "https://w3id.org/cwl/cwl#requirements" in job_order_object: + if tool.metadata.get("http://commonwl.org/cwltool#original_cwlVersion") == 'v1.0': + raise WorkflowException( + "`cwl:requirements` in the input object is not part of CWL " + "v1.0. You can adjust to use `cwltool:overrides` instead; or you " + "can set the cwlVersion to v1.1 or greater and re-run with " + "--enable-dev.") + job_reqs = job_order_object["https://w3id.org/cwl/cwl#requirements"] + for req in job_reqs: + tool.requirements.append(req) + + def arv_executor(self, updated_tool, job_order, runtimeContext, logger=None): self.debug = runtimeContext.debug - tool.visit(self.check_features) + workbench1 = self.api.config()["Services"]["Workbench1"]["ExternalURL"] + workbench2 = self.api.config()["Services"]["Workbench2"]["ExternalURL"] + controller = self.api.config()["Services"]["Controller"]["ExternalURL"] + logger.info("Using cluster %s (%s)", self.api.config()["ClusterID"], workbench2 or workbench1 or controller) + + updated_tool.visit(self.check_features) - self.project_uuid = runtimeContext.project_uuid self.pipeline = None self.fs_access = runtimeContext.make_fs_access(runtimeContext.basedir) self.secret_store = runtimeContext.secret_store @@ -525,55 +537,92 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods if runtimeContext.submit_request_uuid and self.work_api != "containers": raise Exception("--submit-request-uuid requires containers API, but using '{}' api".format(self.work_api)) + runtimeContext = runtimeContext.copy() + + default_storage_classes = ",".join([k for k,v in self.api.config().get("StorageClasses", {"default": {"Default": True}}).items() if v.get("Default") is True]) + if runtimeContext.storage_classes == "default": + runtimeContext.storage_classes = default_storage_classes + if runtimeContext.intermediate_storage_classes == "default": + runtimeContext.intermediate_storage_classes = default_storage_classes + if not runtimeContext.name: - runtimeContext.name = self.name = tool.tool.get("label") or tool.metadata.get("label") or os.path.basename(tool.tool["id"]) + runtimeContext.name = self.name = updated_tool.tool.get("label") or updated_tool.metadata.get("label") or os.path.basename(updated_tool.tool["id"]) + + if runtimeContext.copy_deps is None and (runtimeContext.create_workflow or runtimeContext.update_workflow): + # When creating or updating workflow record, by default + # always copy dependencies and ensure Docker images are up + # to date. + runtimeContext.copy_deps = True + runtimeContext.match_local_docker = True + + if runtimeContext.update_workflow and self.project_uuid is None: + # If we are updating a workflow, make sure anything that + # gets uploaded goes into the same parent project, unless + # an alternate --project-uuid was provided. + existing_wf = self.api.workflows().get(uuid=runtimeContext.update_workflow).execute() + runtimeContext.project_uuid = existing_wf["owner_uuid"] + + self.project_uuid = runtimeContext.project_uuid + + # Upload local file references in the job order. + job_order = upload_job_order(self, "%s input" % runtimeContext.name, + updated_tool, job_order, runtimeContext) + + # the last clause means: if it is a command line tool, and we + # are going to wait for the result, and always_submit_runner + # is false, then we don't submit a runner process. + + submitting = (runtimeContext.update_workflow or + runtimeContext.create_workflow or + (runtimeContext.submit and not + (updated_tool.tool["class"] == "CommandLineTool" and + runtimeContext.wait and + not runtimeContext.always_submit_runner))) + + loadingContext = self.loadingContext.copy() + loadingContext.do_validate = False + if submitting: + loadingContext.do_update = False + # Document may have been auto-updated. Reload the original + # document with updating disabled because we want to + # submit the document with its original CWL version, not + # the auto-updated one. + tool = load_tool(updated_tool.tool["id"], loadingContext) + else: + tool = updated_tool # Upload direct dependencies of workflow steps, get back mapping of files to keep references. # Also uploads docker images. - merged_map = upload_workflow_deps(self, tool) + merged_map = upload_workflow_deps(self, tool, runtimeContext) - # Reload tool object which may have been updated by - # upload_workflow_deps - # Don't validate this time because it will just print redundant errors. - loadingContext = self.loadingContext.copy() + # Recreate process object (ArvadosWorkflow or + # ArvadosCommandTool) because tool document may have been + # updated by upload_workflow_deps in ways that modify + # inheritance of hints or requirements. loadingContext.loader = tool.doc_loader loadingContext.avsc_names = tool.doc_schema loadingContext.metadata = tool.metadata - loadingContext.do_validate = False - - tool = self.arv_make_tool(tool.doc_loader.idx[tool.tool["id"]], - loadingContext) + tool = load_tool(tool.tool, loadingContext) - # Upload local file references in the job order. - job_order = upload_job_order(self, "%s input" % runtimeContext.name, - tool, job_order) - - existing_uuid = runtimeContext.update_workflow - if existing_uuid or runtimeContext.create_workflow: + if runtimeContext.update_workflow or runtimeContext.create_workflow: # Create a pipeline template or workflow record and exit. - if self.work_api == "jobs": - tmpl = RunnerTemplate(self, tool, job_order, - runtimeContext.enable_reuse, - uuid=existing_uuid, - submit_runner_ram=runtimeContext.submit_runner_ram, - name=runtimeContext.name, - merged_map=merged_map) - tmpl.save() - # cwltool.main will write our return value to stdout. - return (tmpl.uuid, "success") - elif self.work_api == "containers": - return (upload_workflow(self, tool, job_order, - self.project_uuid, - uuid=existing_uuid, - submit_runner_ram=runtimeContext.submit_runner_ram, - name=runtimeContext.name, - merged_map=merged_map), - "success") + if self.work_api == "containers": + uuid = upload_workflow(self, tool, job_order, + runtimeContext.project_uuid, + runtimeContext, + uuid=runtimeContext.update_workflow, + submit_runner_ram=runtimeContext.submit_runner_ram, + name=runtimeContext.name, + merged_map=merged_map, + submit_runner_image=runtimeContext.submit_runner_image) + self.stdout.write(uuid + "\n") + return (None, "success") + + self.apply_reqs(job_order, tool) self.ignore_docker_for_reuse = runtimeContext.ignore_docker_for_reuse self.eval_timeout = runtimeContext.eval_timeout - runtimeContext = runtimeContext.copy() runtimeContext.use_container = True runtimeContext.tmpdir_prefix = "tmp" runtimeContext.work_api = self.work_api @@ -585,12 +634,6 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods runtimeContext.docker_outdir = "/var/spool/cwl" runtimeContext.tmpdir = "/tmp" runtimeContext.docker_tmpdir = "/tmp" - elif self.work_api == "jobs": - if runtimeContext.priority != DEFAULT_PRIORITY: - raise Exception("--priority not implemented for jobs API.") - runtimeContext.outdir = "$(task.outdir)" - runtimeContext.docker_outdir = "$(task.outdir)" - runtimeContext.tmpdir = "$(task.tmpdir)" if runtimeContext.priority < 1 or runtimeContext.priority > 1000: raise Exception("--priority must be in the range 1..1000.") @@ -605,7 +648,7 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods visited.add(m.group(1)) estimated_size[0] += int(m.group(2)) visit_class(job_order, ("File", "Directory"), estimate_collection_cache) - runtimeContext.collection_cache_size = max(((estimated_size[0]*192) / (1024*1024))+1, 256) + runtimeContext.collection_cache_size = max(((estimated_size[0]*192) // (1024*1024))+1, 256) self.collection_cache.set_cap(runtimeContext.collection_cache_size*1024*1024) logger.info("Using collection cache size %s MiB", runtimeContext.collection_cache_size) @@ -614,48 +657,36 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods if runtimeContext.submit: # Submit a runner job to run the workflow for us. if self.work_api == "containers": - if tool.tool["class"] == "CommandLineTool" and runtimeContext.wait and (not runtimeContext.always_submit_runner): - runtimeContext.runnerjob = tool.tool["id"] - runnerjob = tool.job(job_order, - self.output_callback, - runtimeContext).next() + if submitting: + tool = RunnerContainer(self, updated_tool, + tool, loadingContext, runtimeContext.enable_reuse, + self.output_name, + self.output_tags, + submit_runner_ram=runtimeContext.submit_runner_ram, + name=runtimeContext.name, + on_error=runtimeContext.on_error, + submit_runner_image=runtimeContext.submit_runner_image, + intermediate_output_ttl=runtimeContext.intermediate_output_ttl, + merged_map=merged_map, + priority=runtimeContext.priority, + secret_store=self.secret_store, + collection_cache_size=runtimeContext.collection_cache_size, + collection_cache_is_default=self.should_estimate_cache_size) else: - runnerjob = RunnerContainer(self, tool, job_order, runtimeContext.enable_reuse, - self.output_name, - self.output_tags, - submit_runner_ram=runtimeContext.submit_runner_ram, - name=runtimeContext.name, - on_error=runtimeContext.on_error, - submit_runner_image=runtimeContext.submit_runner_image, - intermediate_output_ttl=runtimeContext.intermediate_output_ttl, - merged_map=merged_map, - priority=runtimeContext.priority, - secret_store=self.secret_store, - collection_cache_size=runtimeContext.collection_cache_size) - elif self.work_api == "jobs": - runnerjob = RunnerJob(self, tool, job_order, runtimeContext.enable_reuse, - self.output_name, - self.output_tags, - submit_runner_ram=runtimeContext.submit_runner_ram, - name=runtimeContext.name, - on_error=runtimeContext.on_error, - submit_runner_image=runtimeContext.submit_runner_image, - merged_map=merged_map) - elif runtimeContext.cwl_runner_job is None and self.work_api == "jobs": - # Create pipeline for local run - self.pipeline = self.api.pipeline_instances().create( - body={ - "owner_uuid": self.project_uuid, - "name": runtimeContext.name if runtimeContext.name else shortname(tool.tool["id"]), - "components": {}, - "state": "RunningOnClient"}).execute(num_retries=self.num_retries) - logger.info("Pipeline instance %s", self.pipeline["uuid"]) - - if runnerjob and not runtimeContext.wait: - submitargs = runtimeContext.copy() - submitargs.submit = False - runnerjob.run(submitargs) - return (runnerjob.uuid, "success") + runtimeContext.runnerjob = tool.tool["id"] + + if runtimeContext.cwl_runner_job is not None: + self.uuid = runtimeContext.cwl_runner_job.get('uuid') + + jobiter = tool.job(job_order, + self.output_callback, + runtimeContext) + + if runtimeContext.submit and not runtimeContext.wait: + runnerjob = next(jobiter) + runnerjob.run(runtimeContext) + self.stdout.write(runnerjob.uuid+"\n") + return (None, "success") current_container = arvados_cwl.util.get_current_container(self.api, self.num_retries, logger) if current_container: @@ -669,14 +700,6 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods try: self.workflow_eval_lock.acquire() - if runnerjob: - jobiter = iter((runnerjob,)) - else: - if runtimeContext.cwl_runner_job is not None: - self.uuid = runtimeContext.cwl_runner_job.get('uuid') - jobiter = tool.job(job_order, - self.output_callback, - runtimeContext) # Holds the lock while this code runs and releases it when # it is safe to do so in self.workflow_eval_lock.wait(), @@ -720,14 +743,24 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods except: if sys.exc_info()[0] is KeyboardInterrupt or sys.exc_info()[0] is SystemExit: logger.error("Interrupted, workflow will be cancelled") + elif isinstance(sys.exc_info()[1], WorkflowException): + logger.error("Workflow execution failed:\n%s", sys.exc_info()[1], exc_info=(sys.exc_info()[1] if self.debug else False)) else: - logger.error("Execution failed:\n%s", sys.exc_info()[1], exc_info=(sys.exc_info()[1] if self.debug else False)) + logger.exception("Workflow execution failed") + if self.pipeline: self.api.pipeline_instances().update(uuid=self.pipeline["uuid"], body={"state": "Failed"}).execute(num_retries=self.num_retries) - if runnerjob and runnerjob.uuid and self.work_api == "containers": - self.api.container_requests().update(uuid=runnerjob.uuid, - body={"priority": "0"}).execute(num_retries=self.num_retries) + + if self.work_api == "containers" and not current_container: + # Not running in a crunch container, so cancel any outstanding processes. + for p in self.processes: + try: + self.api.container_requests().update(uuid=p, + body={"priority": "0"} + ).execute(num_retries=self.num_retries) + except Exception: + pass finally: self.workflow_eval_lock.release() self.task_queue.drain() @@ -741,16 +774,32 @@ http://doc.arvados.org/install/install-api-server.html#disable_api_methods if self.final_output is None: raise WorkflowException("Workflow did not return a result.") - if runtimeContext.submit and isinstance(runnerjob, Runner): - logger.info("Final output collection %s", runnerjob.final_output) + if runtimeContext.submit and isinstance(tool, Runner): + logger.info("Final output collection %s", tool.final_output) + if workbench2 or workbench1: + logger.info("Output at %scollections/%s", workbench2 or workbench1, tool.final_output) else: if self.output_name is None: self.output_name = "Output of %s" % (shortname(tool.tool["id"])) if self.output_tags is None: self.output_tags = "" - storage_classes = runtimeContext.storage_classes.strip().split(",") - self.final_output, self.final_output_collection = self.make_output_collection(self.output_name, storage_classes, self.output_tags, self.final_output) + storage_classes = "" + storage_class_req, _ = tool.get_requirement("http://arvados.org/cwl#OutputStorageClass") + if storage_class_req and storage_class_req.get("finalStorageClass"): + storage_classes = aslist(storage_class_req["finalStorageClass"]) + else: + storage_classes = runtimeContext.storage_classes.strip().split(",") + + output_properties = {} + output_properties_req, _ = tool.get_requirement("http://arvados.org/cwl#OutputCollectionProperties") + if output_properties_req: + for pr in output_properties_req["outputProperties"]: + output_properties[pr["propertyName"]] = self.builder.do_eval(pr["propertyValue"]) + + self.final_output, self.final_output_collection = self.make_output_collection(self.output_name, storage_classes, + self.output_tags, output_properties, + self.final_output) self.set_crunch_output() if runtimeContext.compute_checksum: