Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/cwltool/schemas/v1.2/Workflow.yml @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 saladVersion: v1.1 | |
2 $base: "https://w3id.org/cwl/cwl#" | |
3 | |
4 $namespaces: | |
5 cwl: "https://w3id.org/cwl/cwl#" | |
6 rdfs: "http://www.w3.org/2000/01/rdf-schema#" | |
7 | |
8 $graph: | |
9 | |
10 - name: "WorkflowDoc" | |
11 type: documentation | |
12 doc: | |
13 - | | |
14 # Common Workflow Language (CWL) Workflow Description, v1.2 | |
15 | |
16 This version: | |
17 * https://w3id.org/cwl/v1.2/ | |
18 | |
19 Latest stable version: | |
20 * https://w3id.org/cwl/ | |
21 - "\n\n" | |
22 - {$include: contrib.md} | |
23 - "\n\n" | |
24 - | | |
25 # Abstract | |
26 | |
27 This specification defines the Common Workflow Language (CWL) | |
28 Workflow description, a vendor-neutral standard for representing | |
29 analysis tasks where a sequence of operations are described | |
30 using a directed graph of operations to transform input to | |
31 output. CWL is portable across a variety of computing | |
32 platforms. | |
33 | |
34 - {$include: intro.md} | |
35 | |
36 - | | |
37 | |
38 ## Introduction to CWL Workflow standard v1.2 | |
39 | |
40 This specification represents the latest stable release from the | |
41 CWL group. Since the v1.1 release, v1.2 introduces the | |
42 following updates to the CWL Workflow standard. | |
43 Documents should to use `cwlVersion: v1.2` to make use of new | |
44 syntax and features introduced in v1.2. Existing v1.1 documents | |
45 should be trivially updatable by changing `cwlVersion`, however | |
46 CWL documents that relied on previously undefined or | |
47 underspecified behavior may have slightly different behavior in | |
48 v1.2. | |
49 | |
50 ## Changelog | |
51 | |
52 * Adds `when` field to [WorkflowStep](#WorkflowStep) for conditional | |
53 execution | |
54 * Adds `pickValue` field to [WorkflowStepInput](#WorkflowStepInput) and | |
55 [WorkflowOutputParameter](#WorkflowOutputParameter) for selecting among null and | |
56 non-null source values | |
57 * Add abstract [Operation](#Operation) that can be used as a | |
58 no-op stand-in to describe abstract workflows. | |
59 * [Workflow](#Workflow), [ExpressionTool](#ExpressionTool) and | |
60 [Operation](#Operation) can now express `intent` with an | |
61 identifier for the type of computational operation. | |
62 * Clarify there are no limits on the size of file literal `contents`. | |
63 * When using `loadContents` it now must fail when attempting to | |
64 load a file greater than 64 KiB instead of silently truncating | |
65 the data. | |
66 * Note that only enum and record types can be typedef-ed | |
67 * Escaping in [string interpolation](#String_Interpolation) has | |
68 been added to the specification along with conformance tests. | |
69 * Added discussion of [packed documents](#Packed_documents). | |
70 * Specify behavior when `source` is a single-item list and no | |
71 linkMerge is set. | |
72 * Added discussion about handling different document versions. | |
73 * Added definition of **data link** | |
74 | |
75 See also the [CWL Command Line Tool Description, v1.2 changelog](CommandLineTool.html#Changelog). | |
76 For other changes since CWL v1.0, see the | |
77 [CWL Workflow Description, v1.1 changelog](https://www.commonwl.org/v1.1/Workflow.html#Changelog) | |
78 | |
79 ## Purpose | |
80 | |
81 The Common Workflow Language Command Line Tool Description | |
82 express workflows for data-intensive science, such as | |
83 bioinformatics, physics, astronomy, geoscience, and machine | |
84 learning. This specification is intended to define a data and | |
85 execution model for Workflows that can be implemented on top of | |
86 a variety of computing platforms, ranging from an individual | |
87 workstation to cluster, grid, cloud, and high performance | |
88 computing systems. Details related to execution of these | |
89 workflow not laid out in this specification are open to | |
90 interpretation by the computing platform implementing this | |
91 specification. | |
92 | |
93 - {$include: concepts.md} | |
94 | |
95 - name: ExpressionToolOutputParameter | |
96 type: record | |
97 extends: OutputParameter | |
98 fields: | |
99 - name: type | |
100 type: | |
101 - CWLType | |
102 - OutputRecordSchema | |
103 - OutputEnumSchema | |
104 - OutputArraySchema | |
105 - string | |
106 - type: array | |
107 items: | |
108 - CWLType | |
109 - OutputRecordSchema | |
110 - OutputEnumSchema | |
111 - OutputArraySchema | |
112 - string | |
113 jsonldPredicate: | |
114 "_id": "sld:type" | |
115 "_type": "@vocab" | |
116 refScope: 2 | |
117 typeDSL: True | |
118 doc: | | |
119 Specify valid types of data that may be assigned to this parameter. | |
120 | |
121 | |
122 - name: WorkflowInputParameter | |
123 type: record | |
124 extends: InputParameter | |
125 docParent: "#Workflow" | |
126 fields: | |
127 - name: type | |
128 type: | |
129 - CWLType | |
130 - InputRecordSchema | |
131 - InputEnumSchema | |
132 - InputArraySchema | |
133 - string | |
134 - type: array | |
135 items: | |
136 - CWLType | |
137 - InputRecordSchema | |
138 - InputEnumSchema | |
139 - InputArraySchema | |
140 - string | |
141 jsonldPredicate: | |
142 "_id": "sld:type" | |
143 "_type": "@vocab" | |
144 refScope: 2 | |
145 typeDSL: True | |
146 doc: | | |
147 Specify valid types of data that may be assigned to this parameter. | |
148 - name: inputBinding | |
149 type: InputBinding? | |
150 doc: | | |
151 Deprecated. Preserved for v1.0 backwards compatability. Will be removed in | |
152 CWL v2.0. Use `WorkflowInputParameter.loadContents` instead. | |
153 jsonldPredicate: "cwl:inputBinding" | |
154 | |
155 | |
156 - type: record | |
157 name: ExpressionTool | |
158 extends: Process | |
159 specialize: | |
160 - specializeFrom: InputParameter | |
161 specializeTo: WorkflowInputParameter | |
162 - specializeFrom: OutputParameter | |
163 specializeTo: ExpressionToolOutputParameter | |
164 documentRoot: true | |
165 doc: | | |
166 An ExpressionTool is a type of Process object that can be run by itself | |
167 or as a Workflow step. It executes a pure Javascript expression that has | |
168 access to the same input parameters as a workflow. It is meant to be used | |
169 sparingly as a way to isolate complex Javascript expressions that need to | |
170 operate on input data and produce some result; perhaps just a | |
171 rearrangement of the inputs. No Docker software container is required | |
172 or allowed. | |
173 fields: | |
174 - name: class | |
175 jsonldPredicate: | |
176 "_id": "@type" | |
177 "_type": "@vocab" | |
178 type: string | |
179 - name: expression | |
180 type: Expression | |
181 doc: | | |
182 The expression to execute. The expression must return a plain | |
183 Javascript object which matches the output parameters of the | |
184 ExpressionTool. | |
185 | |
186 - name: LinkMergeMethod | |
187 type: enum | |
188 docParent: "#WorkflowStepInput" | |
189 doc: The input link merge method, described in [WorkflowStepInput](#WorkflowStepInput). | |
190 symbols: | |
191 - merge_nested | |
192 - merge_flattened | |
193 | |
194 | |
195 - name: PickValueMethod | |
196 type: enum | |
197 docParent: "#WorkflowStepInput" | |
198 doc: | | |
199 Picking non-null values among inbound data links, described in [WorkflowStepInput](#WorkflowStepInput). | |
200 symbols: | |
201 - first_non_null | |
202 - the_only_non_null | |
203 - all_non_null | |
204 | |
205 | |
206 - name: WorkflowOutputParameter | |
207 type: record | |
208 extends: OutputParameter | |
209 docParent: "#Workflow" | |
210 doc: | | |
211 Describe an output parameter of a workflow. The parameter must be | |
212 connected to one or more parameters defined in the workflow that | |
213 will provide the value of the output parameter. It is legal to | |
214 connect a WorkflowInputParameter to a WorkflowOutputParameter. | |
215 | |
216 See [WorkflowStepInput](#WorkflowStepInput) for discussion of | |
217 `linkMerge` and `pickValue`. | |
218 fields: | |
219 - name: outputSource | |
220 doc: | | |
221 Specifies one or more workflow parameters that supply the value of to | |
222 the output parameter. | |
223 jsonldPredicate: | |
224 "_id": "cwl:outputSource" | |
225 "_type": "@id" | |
226 refScope: 0 | |
227 type: | |
228 - string? | |
229 - string[]? | |
230 - name: linkMerge | |
231 type: ["null", LinkMergeMethod] | |
232 jsonldPredicate: "cwl:linkMerge" | |
233 default: merge_nested | |
234 doc: | | |
235 The method to use to merge multiple sources into a single array. | |
236 If not specified, the default method is "merge_nested". | |
237 | |
238 - name: pickValue | |
239 type: ["null", PickValueMethod] | |
240 jsonldPredicate: "cwl:pickValue" | |
241 doc: | | |
242 The method to use to choose non-null elements among multiple sources. | |
243 | |
244 - name: type | |
245 type: | |
246 - CWLType | |
247 - OutputRecordSchema | |
248 - OutputEnumSchema | |
249 - OutputArraySchema | |
250 - string | |
251 - type: array | |
252 items: | |
253 - CWLType | |
254 - OutputRecordSchema | |
255 - OutputEnumSchema | |
256 - OutputArraySchema | |
257 - string | |
258 jsonldPredicate: | |
259 "_id": "sld:type" | |
260 "_type": "@vocab" | |
261 refScope: 2 | |
262 typeDSL: True | |
263 doc: | | |
264 Specify valid types of data that may be assigned to this parameter. | |
265 | |
266 | |
267 - name: Sink | |
268 type: record | |
269 abstract: true | |
270 fields: | |
271 - name: source | |
272 doc: | | |
273 Specifies one or more workflow parameters that will provide input to | |
274 the underlying step parameter. | |
275 jsonldPredicate: | |
276 "_id": "cwl:source" | |
277 "_type": "@id" | |
278 refScope: 2 | |
279 type: | |
280 - string? | |
281 - string[]? | |
282 - name: linkMerge | |
283 type: LinkMergeMethod? | |
284 jsonldPredicate: "cwl:linkMerge" | |
285 default: merge_nested | |
286 doc: | | |
287 The method to use to merge multiple inbound links into a single array. | |
288 If not specified, the default method is "merge_nested". | |
289 - name: pickValue | |
290 type: ["null", PickValueMethod] | |
291 jsonldPredicate: "cwl:pickValue" | |
292 doc: | | |
293 The method to use to choose non-null elements among multiple sources. | |
294 | |
295 | |
296 - type: record | |
297 name: WorkflowStepInput | |
298 extends: [Identified, Sink, LoadContents, Labeled] | |
299 docParent: "#WorkflowStep" | |
300 doc: | | |
301 The input of a workflow step connects an upstream parameter (from the | |
302 workflow inputs, or the outputs of other workflows steps) with the input | |
303 parameters of the process specified by the `run` field. Only input parameters | |
304 declared by the target process will be passed through at runtime to the process | |
305 though additonal parameters may be specified (for use within `valueFrom` | |
306 expressions for instance) - unconnected or unused parameters do not represent an | |
307 error condition. | |
308 | |
309 # Input object | |
310 | |
311 A WorkflowStepInput object must contain an `id` field in the form | |
312 `#fieldname` or `#prefix/fieldname`. When the `id` field contains a slash | |
313 `/` the field name consists of the characters following the final slash | |
314 (the prefix portion may contain one or more slashes to indicate scope). | |
315 This defines a field of the workflow step input object with the value of | |
316 the `source` parameter(s). | |
317 | |
318 # Merging multiple inbound data links | |
319 | |
320 To merge multiple inbound data links, | |
321 [MultipleInputFeatureRequirement](#MultipleInputFeatureRequirement) must be specified | |
322 in the workflow or workflow step requirements. | |
323 | |
324 If the sink parameter is an array, or named in a [workflow | |
325 scatter](#WorkflowStep) operation, there may be multiple inbound | |
326 data links listed in the `source` field. The values from the | |
327 input links are merged depending on the method specified in the | |
328 `linkMerge` field. If both `linkMerge` and `pickValue` are null | |
329 or not specified, and there is more than one element in the | |
330 `source` array, the default method is "merge_nested". | |
331 | |
332 If both `linkMerge` and `pickValue` are null or not specified, and | |
333 there is only a single element in the `source`, then the input | |
334 parameter takes the scalar value from the single input link (it is | |
335 *not* wrapped in a single-list). | |
336 | |
337 * **merge_nested** | |
338 | |
339 The input must be an array consisting of exactly one entry for each | |
340 input link. If "merge_nested" is specified with a single link, the value | |
341 from the link must be wrapped in a single-item list. | |
342 | |
343 * **merge_flattened** | |
344 | |
345 1. The source and sink parameters must be compatible types, or the source | |
346 type must be compatible with single element from the "items" type of | |
347 the destination array parameter. | |
348 2. Source parameters which are arrays are concatenated. | |
349 Source parameters which are single element types are appended as | |
350 single elements. | |
351 | |
352 # Picking non-null values among inbound data links | |
353 | |
354 If present, `pickValue` specifies how to picking non-null values among inbound data links. | |
355 | |
356 `pickValue` is evaluated | |
357 1. Once all source values from upstream step or parameters are available. | |
358 2. After `linkMerge`. | |
359 3. Before `scatter` or `valueFrom`. | |
360 | |
361 This is specifically intended to be useful in combination with | |
362 [conditional execution](#WorkflowStep), where several upstream | |
363 steps may be connected to a single input (`source` is a list), and | |
364 skipped steps produce null values. | |
365 | |
366 Static type checkers should check for type consistency after infering what the type | |
367 will be after `pickValue` is applied, just as they do currently for `linkMerge`. | |
368 | |
369 * **first_non_null** | |
370 | |
371 For the first level of a list input, pick the first non-null element. The result is a scalar. | |
372 It is an error if there is no non-null element. Examples: | |
373 * `[null, x, null, y] -> x` | |
374 * `[null, [null], null, y] -> [null]` | |
375 * `[null, null, null] -> Runtime Error` | |
376 | |
377 *Intended use case*: If-else pattern where the | |
378 value comes either from a conditional step or from a default or | |
379 fallback value. The conditional step(s) should be placed first in | |
380 the list. | |
381 | |
382 * **the_only_non_null** | |
383 | |
384 For the first level of a list input, pick the single non-null element. The result is a scalar. | |
385 It is an error if there is more than one non-null element. Examples: | |
386 | |
387 * `[null, x, null] -> x` | |
388 * `[null, x, null, y] -> Runtime Error` | |
389 * `[null, [null], null] -> [null]` | |
390 * `[null, null, null] -> Runtime Error` | |
391 | |
392 *Intended use case*: Switch type patterns where developer considers | |
393 more than one active code path as a workflow error | |
394 (possibly indicating an error in writing `when` condition expressions). | |
395 | |
396 * **all_non_null** | |
397 | |
398 For the first level of a list input, pick all non-null values. | |
399 The result is a list, which may be empty. Examples: | |
400 | |
401 * `[null, x, null] -> [x]` | |
402 * `[x, null, y] -> [x, y]` | |
403 * `[null, [x], [null]] -> [[x], [null]]` | |
404 * `[null, null, null] -> []` | |
405 | |
406 *Intended use case*: It is valid to have more than one source, but | |
407 sources are conditional, so null sources (from skipped steps) | |
408 should be filtered out. | |
409 | |
410 fields: | |
411 - name: default | |
412 type: ["null", Any] | |
413 doc: | | |
414 The default value for this parameter to use if either there is no | |
415 `source` field, or the value produced by the `source` is `null`. The | |
416 default must be applied prior to scattering or evaluating `valueFrom`. | |
417 jsonldPredicate: | |
418 _id: "sld:default" | |
419 noLinkCheck: true | |
420 - name: valueFrom | |
421 type: | |
422 - "null" | |
423 - string | |
424 - Expression | |
425 jsonldPredicate: "cwl:valueFrom" | |
426 doc: | | |
427 To use valueFrom, [StepInputExpressionRequirement](#StepInputExpressionRequirement) must | |
428 be specified in the workflow or workflow step requirements. | |
429 | |
430 If `valueFrom` is a constant string value, use this as the value for | |
431 this input parameter. | |
432 | |
433 If `valueFrom` is a parameter reference or expression, it must be | |
434 evaluated to yield the actual value to be assiged to the input field. | |
435 | |
436 The `self` value in the parameter reference or expression must be | |
437 1. `null` if there is no `source` field | |
438 2. the value of the parameter(s) specified in the `source` field when this | |
439 workflow input parameter **is not** specified in this workflow step's `scatter` field. | |
440 3. an element of the parameter specified in the `source` field when this workflow input | |
441 parameter **is** specified in this workflow step's `scatter` field. | |
442 | |
443 The value of `inputs` in the parameter reference or expression must be | |
444 the input object to the workflow step after assigning the `source` | |
445 values, applying `default`, and then scattering. The order of | |
446 evaluating `valueFrom` among step input parameters is undefined and the | |
447 result of evaluating `valueFrom` on a parameter must not be visible to | |
448 evaluation of `valueFrom` on other parameters. | |
449 | |
450 | |
451 - type: record | |
452 name: WorkflowStepOutput | |
453 docParent: "#WorkflowStep" | |
454 extends: Identified | |
455 doc: | | |
456 Associate an output parameter of the underlying process with a workflow | |
457 parameter. The workflow parameter (given in the `id` field) be may be used | |
458 as a `source` to connect with input parameters of other workflow steps, or | |
459 with an output parameter of the process. | |
460 | |
461 A unique identifier for this workflow output parameter. This is | |
462 the identifier to use in the `source` field of `WorkflowStepInput` | |
463 to connect the output value to downstream parameters. | |
464 | |
465 | |
466 - name: ScatterMethod | |
467 type: enum | |
468 docParent: "#WorkflowStep" | |
469 doc: The scatter method, as described in [workflow step scatter](#WorkflowStep). | |
470 symbols: | |
471 - dotproduct | |
472 - nested_crossproduct | |
473 - flat_crossproduct | |
474 | |
475 | |
476 - name: WorkflowStep | |
477 type: record | |
478 extends: [Identified, Labeled, sld:Documented] | |
479 docParent: "#Workflow" | |
480 doc: | | |
481 A workflow step is an executable element of a workflow. It specifies the | |
482 underlying process implementation (such as `CommandLineTool` or another | |
483 `Workflow`) in the `run` field and connects the input and output parameters | |
484 of the underlying process to workflow parameters. | |
485 | |
486 # Scatter/gather | |
487 | |
488 To use scatter/gather, | |
489 [ScatterFeatureRequirement](#ScatterFeatureRequirement) must be specified | |
490 in the workflow or workflow step requirements. | |
491 | |
492 A "scatter" operation specifies that the associated workflow step or | |
493 subworkflow should execute separately over a list of input elements. Each | |
494 job making up a scatter operation is independent and may be executed | |
495 concurrently. | |
496 | |
497 The `scatter` field specifies one or more input parameters which will be | |
498 scattered. An input parameter may be listed more than once. The declared | |
499 type of each input parameter is implicitly becomes an array of items of the | |
500 input parameter type. If a parameter is listed more than once, it becomes | |
501 a nested array. As a result, upstream parameters which are connected to | |
502 scattered parameters must be arrays. | |
503 | |
504 All output parameter types are also implicitly wrapped in arrays. Each job | |
505 in the scatter results in an entry in the output array. | |
506 | |
507 If any scattered parameter runtime value is an empty array, all outputs are | |
508 set to empty arrays and no work is done for the step, according to | |
509 applicable scattering rules. | |
510 | |
511 If `scatter` declares more than one input parameter, `scatterMethod` | |
512 describes how to decompose the input into a discrete set of jobs. | |
513 | |
514 * **dotproduct** specifies that each of the input arrays are aligned and one | |
515 element taken from each array to construct each job. It is an error | |
516 if all input arrays are not the same length. | |
517 | |
518 * **nested_crossproduct** specifies the Cartesian product of the inputs, | |
519 producing a job for every combination of the scattered inputs. The | |
520 output must be nested arrays for each level of scattering, in the | |
521 order that the input arrays are listed in the `scatter` field. | |
522 | |
523 * **flat_crossproduct** specifies the Cartesian product of the inputs, | |
524 producing a job for every combination of the scattered inputs. The | |
525 output arrays must be flattened to a single level, but otherwise listed in the | |
526 order that the input arrays are listed in the `scatter` field. | |
527 | |
528 # Conditional execution (Optional) | |
529 | |
530 Conditional execution makes execution of a step conditional on an | |
531 expression. A step that is not executed is "skipped". A skipped | |
532 step produces `null` for all output parameters. | |
533 | |
534 The condition is evaluated after `scatter`, using the input object | |
535 of each individual scatter job. This means over a set of scatter | |
536 jobs, some may be executed and some may be skipped. When the | |
537 results are gathered, skipped steps must be `null` in the output | |
538 arrays. | |
539 | |
540 The `when` field controls conditional execution. This is an | |
541 expression that must be evaluated with `inputs` bound to the step | |
542 input object (or individual scatter job), and returns a boolean | |
543 value. It is an error if this expression returns a value other | |
544 than `true` or `false`. | |
545 | |
546 Conditionals in CWL are an optional feature and are not required | |
547 to be implemented by all consumers of CWL documents. An | |
548 implementation that does not support conditionals must return a | |
549 fatal error when attempting execute a workflow that uses | |
550 conditional constructs the implementation does not support. | |
551 | |
552 # Subworkflows | |
553 | |
554 To specify a nested workflow as part of a workflow step, | |
555 [SubworkflowFeatureRequirement](#SubworkflowFeatureRequirement) must be | |
556 specified in the workflow or workflow step requirements. | |
557 | |
558 It is a fatal error if a workflow directly or indirectly invokes itself as | |
559 a subworkflow (recursive workflows are not allowed). | |
560 | |
561 fields: | |
562 - name: in | |
563 type: WorkflowStepInput[] | |
564 jsonldPredicate: | |
565 _id: "cwl:in" | |
566 mapSubject: id | |
567 mapPredicate: source | |
568 doc: | | |
569 Defines the input parameters of the workflow step. The process is ready to | |
570 run when all required input parameters are associated with concrete | |
571 values. Input parameters include a schema for each parameter which is | |
572 used to validate the input object. It may also be used build a user | |
573 interface for constructing the input object. | |
574 - name: out | |
575 type: | |
576 - type: array | |
577 items: [string, WorkflowStepOutput] | |
578 jsonldPredicate: | |
579 _id: "cwl:out" | |
580 _type: "@id" | |
581 identity: true | |
582 doc: | | |
583 Defines the parameters representing the output of the process. May be | |
584 used to generate and/or validate the output object. | |
585 - name: requirements | |
586 type: ProcessRequirement[]? | |
587 jsonldPredicate: | |
588 _id: "cwl:requirements" | |
589 mapSubject: class | |
590 doc: | | |
591 Declares requirements that apply to either the runtime environment or the | |
592 workflow engine that must be met in order to execute this workflow step. If | |
593 an implementation cannot satisfy all requirements, or a requirement is | |
594 listed which is not recognized by the implementation, it is a fatal | |
595 error and the implementation must not attempt to run the process, | |
596 unless overridden at user option. | |
597 - name: hints | |
598 type: Any[]? | |
599 jsonldPredicate: | |
600 _id: "cwl:hints" | |
601 noLinkCheck: true | |
602 mapSubject: class | |
603 doc: | | |
604 Declares hints applying to either the runtime environment or the | |
605 workflow engine that may be helpful in executing this workflow step. It is | |
606 not an error if an implementation cannot satisfy all hints, however | |
607 the implementation may report a warning. | |
608 - name: run | |
609 type: [string, Process] | |
610 jsonldPredicate: | |
611 _id: "cwl:run" | |
612 _type: "@id" | |
613 subscope: run | |
614 doc: | | |
615 Specifies the process to run. | |
616 - name: when | |
617 type: | |
618 - "null" | |
619 - Expression | |
620 jsonldPredicate: "cwl:when" | |
621 doc: | | |
622 If defined, only run the step when the expression evaluates to | |
623 `true`. If `false` the step is skipped. A skipped step | |
624 produces a `null` on each output. | |
625 - name: scatter | |
626 type: | |
627 - string? | |
628 - string[]? | |
629 jsonldPredicate: | |
630 "_id": "cwl:scatter" | |
631 "_type": "@id" | |
632 "_container": "@list" | |
633 refScope: 0 | |
634 - name: scatterMethod | |
635 doc: | | |
636 Required if `scatter` is an array of more than one element. | |
637 type: ScatterMethod? | |
638 jsonldPredicate: | |
639 "_id": "cwl:scatterMethod" | |
640 "_type": "@vocab" | |
641 | |
642 | |
643 - name: Workflow | |
644 type: record | |
645 extends: "#Process" | |
646 documentRoot: true | |
647 specialize: | |
648 - specializeFrom: InputParameter | |
649 specializeTo: WorkflowInputParameter | |
650 - specializeFrom: OutputParameter | |
651 specializeTo: WorkflowOutputParameter | |
652 doc: | | |
653 A workflow describes a set of **steps** and the **dependencies** between | |
654 those steps. When a step produces output that will be consumed by a | |
655 second step, the first step is a dependency of the second step. | |
656 | |
657 When there is a dependency, the workflow engine must execute the preceeding | |
658 step and wait for it to successfully produce output before executing the | |
659 dependent step. If two steps are defined in the workflow graph that | |
660 are not directly or indirectly dependent, these steps are **independent**, | |
661 and may execute in any order or execute concurrently. A workflow is | |
662 complete when all steps have been executed. | |
663 | |
664 Dependencies between parameters are expressed using the `source` | |
665 field on [workflow step input parameters](#WorkflowStepInput) and | |
666 `outputSource` field on [workflow output | |
667 parameters](#WorkflowOutputParameter). | |
668 | |
669 The `source` field on each workflow step input parameter expresses | |
670 the data links that contribute to the value of the step input | |
671 parameter (the "sink"). A workflow step can only begin execution | |
672 when every data link connected to a step has been fulfilled. | |
673 | |
674 The `outputSource` field on each workflow step input parameter | |
675 expresses the data links that contribute to the value of the | |
676 workflow output parameter (the "sink"). Workflow execution cannot | |
677 complete successfully until every data link connected to an output | |
678 parameter has been fulfilled. | |
679 | |
680 ## Workflow success and failure | |
681 | |
682 A completed step must result in one of `success`, `temporaryFailure` or | |
683 `permanentFailure` states. An implementation may choose to retry a step | |
684 execution which resulted in `temporaryFailure`. An implementation may | |
685 choose to either continue running other steps of a workflow, or terminate | |
686 immediately upon `permanentFailure`. | |
687 | |
688 * If any step of a workflow execution results in `permanentFailure`, then | |
689 the workflow status is `permanentFailure`. | |
690 | |
691 * If one or more steps result in `temporaryFailure` and all other steps | |
692 complete `success` or are not executed, then the workflow status is | |
693 `temporaryFailure`. | |
694 | |
695 * If all workflow steps are executed and complete with `success`, then the | |
696 workflow status is `success`. | |
697 | |
698 # Extensions | |
699 | |
700 [ScatterFeatureRequirement](#ScatterFeatureRequirement) and | |
701 [SubworkflowFeatureRequirement](#SubworkflowFeatureRequirement) are | |
702 available as standard [extensions](#Extensions_and_Metadata) to core | |
703 workflow semantics. | |
704 | |
705 fields: | |
706 - name: "class" | |
707 jsonldPredicate: | |
708 "_id": "@type" | |
709 "_type": "@vocab" | |
710 type: string | |
711 - name: steps | |
712 doc: | | |
713 The individual steps that make up the workflow. Each step is executed when all of its | |
714 input data links are fufilled. An implementation may choose to execute | |
715 the steps in a different order than listed and/or execute steps | |
716 concurrently, provided that dependencies between steps are met. | |
717 type: | |
718 - type: array | |
719 items: "#WorkflowStep" | |
720 jsonldPredicate: | |
721 mapSubject: id | |
722 | |
723 | |
724 - type: record | |
725 name: SubworkflowFeatureRequirement | |
726 extends: ProcessRequirement | |
727 doc: | | |
728 Indicates that the workflow platform must support nested workflows in | |
729 the `run` field of [WorkflowStep](#WorkflowStep). | |
730 fields: | |
731 - name: "class" | |
732 type: "string" | |
733 doc: "Always 'SubworkflowFeatureRequirement'" | |
734 jsonldPredicate: | |
735 "_id": "@type" | |
736 "_type": "@vocab" | |
737 | |
738 - name: ScatterFeatureRequirement | |
739 type: record | |
740 extends: ProcessRequirement | |
741 doc: | | |
742 Indicates that the workflow platform must support the `scatter` and | |
743 `scatterMethod` fields of [WorkflowStep](#WorkflowStep). | |
744 fields: | |
745 - name: "class" | |
746 type: "string" | |
747 doc: "Always 'ScatterFeatureRequirement'" | |
748 jsonldPredicate: | |
749 "_id": "@type" | |
750 "_type": "@vocab" | |
751 | |
752 - name: MultipleInputFeatureRequirement | |
753 type: record | |
754 extends: ProcessRequirement | |
755 doc: | | |
756 Indicates that the workflow platform must support multiple inbound data links | |
757 listed in the `source` field of [WorkflowStepInput](#WorkflowStepInput). | |
758 fields: | |
759 - name: "class" | |
760 type: "string" | |
761 doc: "Always 'MultipleInputFeatureRequirement'" | |
762 jsonldPredicate: | |
763 "_id": "@type" | |
764 "_type": "@vocab" | |
765 | |
766 - type: record | |
767 name: StepInputExpressionRequirement | |
768 extends: ProcessRequirement | |
769 doc: | | |
770 Indicate that the workflow platform must support the `valueFrom` field | |
771 of [WorkflowStepInput](#WorkflowStepInput). | |
772 fields: | |
773 - name: "class" | |
774 type: "string" | |
775 doc: "Always 'StepInputExpressionRequirement'" | |
776 jsonldPredicate: | |
777 "_id": "@type" | |
778 "_type": "@vocab" | |
779 | |
780 - {$import: Operation.yml} |