[TEP-0075] Support Object Results substitution

docs/pipelines.md

@@ -909,9 +909,14 @@ Sharing `Results` between `Tasks` in a `Pipeline` happens via
 [variable substitution](variables.md#variables-available-in-a-pipeline) - one `Task` emits
 a `Result` and another receives it as a `Parameter` with a variable such as
 `$(tasks.<task-name>.results.<result-name>)`. Array `Results` is supported as alpha feature and
-can be referer as `$(tasks.<task-name>.results.<result-name>[*])`.
+can be referred as `$(tasks.<task-name>.results.<result-name>[*])`. Array indexing can be rererred
+as `$(tasks.<task-name>.results.<result-name>[i])` where `i` is the index.
+Object `Results` is supported as alpha feature and can be referred as
+`$(tasks.<task-name>.results.<result-name>[*])`, object elements can be referred as
+`$(tasks.<task-name>.results.<result-name>.key)`.
 
-**Note:** Array `Result` cannot be used in `script`.
+**Note:** Whole Array and Object `Results` cannot be referred in `script` and `args`.
+**Note:** `Matrix` does not support `object` and `array` results.
 
 When one `Task` receives the `Results` of another, there is a dependency created between those
 two `Tasks`. In order for the receiving `Task` to get data from another `Task's` `Result`,
@@ -928,6 +933,12 @@ params:
     value: "$(tasks.checkout-source.results.commit)"
   - name: array-params
     value: "$(tasks.checkout-source.results.array-results[*])"
+  - name: array-indexing-params
+    value: "$(tasks.checkout-source.results.array-results[1])"
+  - name: object-params
+    value: "$(tasks.checkout-source.results.object-results[*])"
+  - name: object-element-params
+    value: "$(tasks.checkout-source.results.object-results.objectkey)"
 ```
 
 **Note:** If `checkout-source` exits successfully without initializing `commit` `Result`,

docs/variables.md

@@ -28,6 +28,9 @@ For instructions on using variable substitutions see the relevant section of [th
 | `tasks.<taskName>.results.<resultName>[*]` | The array value of the `Task's` result. Can alter `Task` execution order within a `Pipeline`. Cannot be used in `script`.) |
 | `tasks.<taskName>.results['<resultName>'][*]` | (see above)) |
 | `tasks.<taskName>.results["<resultName>"][*]` | (see above)) |
+| `tasks.<taskName>.results.<resultName>.key` | The `key` value of the `Task's` object result. Can alter `Task` execution order within a `Pipeline`.) |
+| `tasks.<taskName>.results['<resultName>'][key]` | (see above)) |
+| `tasks.<taskName>.results["<resultName>"][key]` | (see above)) |
 | `workspaces.<workspaceName>.bound` | Whether a `Workspace` has been bound or not. "false" if the `Workspace` declaration has `optional: true` and the Workspace binding was omitted by the PipelineRun. |
 | `context.pipelineRun.name` | The name of the `PipelineRun` that this `Pipeline` is running in. |
 | `context.pipelineRun.namespace` | The namespace of the `PipelineRun` that this `Pipeline` is running in. |

examples/v1beta1/pipelineruns/alpha/pipeline-object-results.yaml

@@ -0,0 +1,67 @@
+apiVersion: tekton.dev/v1beta1
+kind: PipelineRun
+metadata:
+  name: pipelinerun-object-results
+spec:
+  pipelineSpec:
+    tasks:
+      - name: task1
+        taskSpec:
+          results:
+            - name: object-results
+              type: object
+              description: The object results
+              properties:
+                foo:
+                  type: string
+                hello:
+                  type: string
+          steps:
+            - name: write-object
+              image: bash:latest
+              script: |
+                #!/usr/bin/env bash
+                echo -n "{\"foo\":\"bar\",\"hello\":\"world\"}" | tee $(results.object-results.path)
+      - name: task2
+        params:
+          - name: whole-object
+            value: "$(tasks.task1.results.object-results[*])"
+          - name: object-element
+            value: "$(tasks.task1.results.object-results.hello)"
+        taskSpec:
+          params:
+            - name: whole-object
+              type: object
+              properties:
+                foo:
+                  type: string
+                hello:
+                  type: string
+              default: {
+                hello: "",
+                foo: "",
+              }
+            - name: object-element
+              type: string
+              default: "defaultparam1"
+          steps:
+            - name: print-object-foo
+              image: bash:latest
+              args: [
+                "echo",
+                "$(params.whole-object.foo)"
+              ]
+            - name: print-object-hello
+              image: ubuntu
+              script: |
+                #!/bin/bash
+                VALUE=$(params.object-element)
+                EXPECTED="world"
+                diff=$(diff <(printf "%s\n" "${VALUE[@]}") <(printf "%s\n" "${EXPECTED[@]}"))
+                if [[ -z "$diff" ]]; then
+                    echo "Get expected: ${VALUE}"
+                    exit 0
+                else
+                    echo "Want: ${EXPECTED} Got: ${VALUE}"
+                    exit 1
+                fi

pkg/reconciler/pipelinerun/resources/apply.go

@@ -123,11 +123,12 @@ func ApplyPipelineTaskContexts(pt *v1beta1.PipelineTask) *v1beta1.PipelineTask {
 func ApplyTaskResults(targets PipelineRunState, resolvedResultRefs ResolvedResultRefs) {
 	stringReplacements := resolvedResultRefs.getStringReplacements()
 	arrayReplacements := resolvedResultRefs.getArrayReplacements()
+	objectReplacements := resolvedResultRefs.getObjectReplacements()
 	for _, resolvedPipelineRunTask := range targets {
 		if resolvedPipelineRunTask.PipelineTask != nil {
 			pipelineTask := resolvedPipelineRunTask.PipelineTask.DeepCopy()
-			pipelineTask.Params = replaceParamValues(pipelineTask.Params, stringReplacements, arrayReplacements, nil)
-			pipelineTask.Matrix = replaceParamValues(pipelineTask.Matrix, stringReplacements, arrayReplacements, nil)
+			pipelineTask.Params = replaceParamValues(pipelineTask.Params, stringReplacements, arrayReplacements, objectReplacements)
+			pipelineTask.Matrix = replaceParamValues(pipelineTask.Matrix, stringReplacements, nil, nil)
 			pipelineTask.WhenExpressions = pipelineTask.WhenExpressions.ReplaceWhenExpressionsVariables(stringReplacements, arrayReplacements)
 			resolvedPipelineRunTask.PipelineTask = pipelineTask
 		}

pkg/reconciler/pipelinerun/resources/apply_test.go

@@ -1083,6 +1083,77 @@ func TestApplyTaskResults_MinimalExpression(t *testing.T) {
 				}},
 			},
 		}},
+	}, {
+		name: "Test object result as a whole substitution - params",
+		resolvedResultRefs: ResolvedResultRefs{{
+			Value: *v1beta1.NewObject(map[string]string{
+				"key1": "val1",
+				"key2": "val2",
+			}),
+			ResultReference: v1beta1.ResultRef{
+				PipelineTask: "aTask",
+				Result:       "resultName",
+			},
+			FromTaskRun: "aTaskRun",
+		}},
+		targets: PipelineRunState{{
+			PipelineTask: &v1beta1.PipelineTask{
+				Name:    "bTask",
+				TaskRef: &v1beta1.TaskRef{Name: "bTask"},
+				Params: []v1beta1.Param{{
+					Name:  "bParam",
+					Value: *v1beta1.NewArrayOrString(`$(tasks.aTask.results.resultName[*])`),
+				}},
+			},
+		}},
+		want: PipelineRunState{{
+			PipelineTask: &v1beta1.PipelineTask{
+				Name:    "bTask",
+				TaskRef: &v1beta1.TaskRef{Name: "bTask"},
+				Params: []v1beta1.Param{{
+					Name: "bParam",
+					// index validation is done in ResolveResultRefs() before ApplyTaskResults()
+					Value: *v1beta1.NewObject(map[string]string{
+						"key1": "val1",
+						"key2": "val2",
+					}),
+				}},
+			},
+		}},
+	}, {
+		name: "Test object result element substitution - params",
+		resolvedResultRefs: ResolvedResultRefs{{
+			Value: *v1beta1.NewObject(map[string]string{
+				"key1": "val1",
+				"key2": "val2",
+			}),
+			ResultReference: v1beta1.ResultRef{
+				PipelineTask: "aTask",
+				Result:       "resultName",
+			},
+			FromTaskRun: "aTaskRun",
+		}},
+		targets: PipelineRunState{{
+			PipelineTask: &v1beta1.PipelineTask{
+				Name:    "bTask",
+				TaskRef: &v1beta1.TaskRef{Name: "bTask"},
+				Params: []v1beta1.Param{{
+					Name:  "bParam",
+					Value: *v1beta1.NewArrayOrString(`$(tasks.aTask.results.resultName.key1)`),
+				}},
+			},
+		}},
+		want: PipelineRunState{{
+			PipelineTask: &v1beta1.PipelineTask{
+				Name:    "bTask",
+				TaskRef: &v1beta1.TaskRef{Name: "bTask"},
+				Params: []v1beta1.Param{{
+					Name: "bParam",
+					// index validation is done in ResolveResultRefs() before ApplyTaskResults()
+					Value: *v1beta1.NewArrayOrString("val1"),
+				}},
+			},
+		}},
 	}, {
 		name: "Test result substitution on minimal variable substitution expression - matrix",
 		resolvedResultRefs: ResolvedResultRefs{{

pkg/reconciler/pipelinerun/resources/resultrefresolution.go

@@ -206,6 +206,13 @@ func (rs ResolvedResultRefs) getStringReplacements() map[string]string {
 					replacements[target] = r.Value.ArrayVal[i]
 				}
 			}
+		case v1beta1.ParamTypeObject:
+			for key, element := range r.Value.ObjectVal {
+				for _, target := range r.getReplaceTargetfromObjectKey(key) {
+					replacements[target] = element
+				}
+			}
+
 		default:
 			for _, target := range r.getReplaceTarget() {
 				replacements[target] = r.Value.StringVal
@@ -227,6 +234,18 @@ func (rs ResolvedResultRefs) getArrayReplacements() map[string][]string {
 	return replacements
 }
 
+func (rs ResolvedResultRefs) getObjectReplacements() map[string]map[string]string {
+	replacements := map[string]map[string]string{}
+	for _, r := range rs {
+		if r.Value.Type == v1beta1.ParamType(v1beta1.ResultsTypeObject) {
+			for _, target := range r.getReplaceTarget() {
+				replacements[target] = r.Value.ObjectVal
+			}
+		}
+	}
+	return replacements
+}
+
 func (r *ResolvedResultRef) getReplaceTarget() []string {
 	return []string{
 		fmt.Sprintf("%s.%s.%s.%s", v1beta1.ResultTaskPart, r.ResultReference.PipelineTask, v1beta1.ResultResultPart, r.ResultReference.Result),
@@ -242,3 +261,11 @@ func (r *ResolvedResultRef) getReplaceTargetfromArrayIndex(idx int) []string {
 		fmt.Sprintf("%s.%s.%s['%s'][%d]", v1beta1.ResultTaskPart, r.ResultReference.PipelineTask, v1beta1.ResultResultPart, r.ResultReference.Result, idx),
 	}
 }
+
+func (r *ResolvedResultRef) getReplaceTargetfromObjectKey(key string) []string {
+	return []string{
+		fmt.Sprintf("%s.%s.%s.%s.%s", v1beta1.ResultTaskPart, r.ResultReference.PipelineTask, v1beta1.ResultResultPart, r.ResultReference.Result, key),
+		fmt.Sprintf("%s.%s.%s[%q][%s]", v1beta1.ResultTaskPart, r.ResultReference.PipelineTask, v1beta1.ResultResultPart, r.ResultReference.Result, key),
+		fmt.Sprintf("%s.%s.%s['%s'][%s]", v1beta1.ResultTaskPart, r.ResultReference.PipelineTask, v1beta1.ResultResultPart, r.ResultReference.Result, key),
+	}
+}

pkg/reconciler/taskrun/validate_resources.go

@@ -146,7 +146,7 @@ func wrongTypeParamsNames(params []v1beta1.Param, matrix []v1beta1.Param, needed
 		// to pass array result to array param, yet in yaml format this will be
 		// unmarshalled to string for ArrayOrString. So we need to check and skip this validation.
 		// Please refer issue #4879 for more details and examples.
-		if param.Value.Type == v1beta1.ParamTypeString && (neededParamsTypes[param.Name] == v1beta1.ParamTypeArray || (neededParamsTypes[param.Name] == v1beta1.ParamTypeObject)) && v1beta1.VariableSubstitutionRegex.MatchString(param.Value.StringVal) {
+		if param.Value.Type == v1beta1.ParamTypeString && (neededParamsTypes[param.Name] == v1beta1.ParamTypeArray || neededParamsTypes[param.Name] == v1beta1.ParamTypeObject) && v1beta1.VariableSubstitutionRegex.MatchString(param.Value.StringVal) {
 			continue
 		}
 		if param.Value.Type != neededParamsTypes[param.Name] {