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