TEP-0090: Resolve PipelineTask with Custom Task

[TEP-0090: Matrix][tep-0090] proposed executing a `PipelineTask` in
parallel `TaskRuns` and `Runs` with substitutions from combinations
of `Parameters` in a `Matrix`.

This change resolves a `PipelineTask` with a matrixed `Custom Task`.

[tep-0090]: https://github.com/tektoncd/community/blob/main/teps/0090-matrix.md

Author: jerop

pkg/reconciler/pipelinerun/resources/pipelinerunresolution.go

@@ -66,6 +66,7 @@ type ResolvedPipelineTask struct {
 	CustomTask            bool
 	RunName               string
 	Run                   *v1alpha1.Run
+	RunNames              []string
 	Runs                  []*v1alpha1.Run
 	PipelineTask          *v1beta1.PipelineTask
 	ResolvedTaskResources *resources.ResolvedTaskResources
@@ -525,6 +526,15 @@ func ResolvePipelineTask(
 	}
 	rpt.CustomTask = isCustomTask(ctx, rpt)
 	switch {
+	case rpt.IsCustomTask() && rpt.IsMatrixed():
+		rpt.RunNames = getNamesOfRuns(pipelineRun.Status.ChildReferences, pipelineTask.Name, pipelineRun.Name, pipelineTask.GetMatrixCombinationsCount())
+		for _, runName := range rpt.RunNames {
+			run, err := getRun(runName)
+			if err != nil && !kerrors.IsNotFound(err) {
+				return nil, fmt.Errorf("error retrieving Run %s: %w", runName, err)
+			}
+			rpt.Runs = append(rpt.Runs, run)
+		}
 	case rpt.IsCustomTask():
 		rpt.RunName = getRunName(pipelineRun.Status.Runs, pipelineRun.Status.ChildReferences, pipelineTask.Name, pipelineRun.Name)
 		run, err := getRun(rpt.RunName)

pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go

@@ -3201,6 +3201,113 @@ func TestResolvePipelineRunTask_WithMatrix(t *testing.T) {
 	}
 }
 
+func TestResolvePipelineRunTask_WithMatrixedCustomTask(t *testing.T) {
+	pipelineRunName := "pipelinerun"
+	pipelineTaskName := "pipelinetask"
+
+	pr := v1beta1.PipelineRun{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: pipelineRunName,
+		},
+	}
+
+	var runs []*v1alpha1.Run
+	var runNames []string
+	runsMap := map[string]*v1alpha1.Run{}
+	for i := 0; i < 9; i++ {
+		runName := fmt.Sprintf("%s-%s-%d", pipelineRunName, pipelineTaskName, i)
+		run := &v1alpha1.Run{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: runName,
+			},
+		}
+		runs = append(runs, run)
+		runNames = append(runNames, runName)
+		runsMap[runName] = run
+	}
+
+	pts := []v1beta1.PipelineTask{{
+		Name: "pipelinetask",
+		TaskRef: &v1beta1.TaskRef{
+			APIVersion: "example.dev/v0",
+			Kind:       "Example",
+			Name:       "my-task",
+		},
+		Matrix: []v1beta1.Param{{
+			Name:  "platform",
+			Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{"linux", "mac", "windows"}},
+		}},
+	}, {
+		Name: "pipelinetask",
+		TaskRef: &v1beta1.TaskRef{
+			APIVersion: "example.dev/v0",
+			Kind:       "Example",
+			Name:       "my-task",
+		},
+		Matrix: []v1beta1.Param{{
+			Name:  "platform",
+			Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{"linux", "mac", "windows"}},
+		}, {
+			Name:  "browsers",
+			Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{"chrome", "safari", "firefox"}},
+		}},
+	}}
+
+	rtr := &resources.ResolvedTaskResources{
+		TaskName: "task",
+		TaskSpec: &v1beta1.TaskSpec{Steps: []v1beta1.Step{{
+			Name: "step1",
+		}}},
+	}
+
+	getTask := func(ctx context.Context, name string) (v1beta1.TaskObject, error) { return task, nil }
+	getTaskRun := func(name string) (*v1beta1.TaskRun, error) { return &trs[0], nil }
+	getRun := func(name string) (*v1alpha1.Run, error) { return runsMap[name], nil }
+
+	for _, tc := range []struct {
+		name string
+		pt   v1beta1.PipelineTask
+		want *ResolvedPipelineTask
+	}{{
+		name: "custom task with matrix - single parameter",
+		pt:   pts[0],
+		want: &ResolvedPipelineTask{
+			RunNames:              runNames[:3],
+			Runs:                  runs[:3],
+			PipelineTask:          &pts[0],
+			ResolvedTaskResources: rtr,
+		},
+	}, {
+		name: "custom task with matrix - multiple parameters",
+		pt:   pts[1],
+		want: &ResolvedPipelineTask{
+			RunNames:              runNames,
+			Runs:                  runs,
+			PipelineTask:          &pts[1],
+			ResolvedTaskResources: rtr,
+		},
+	}} {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()
+			cfg := config.NewStore(logtesting.TestLogger(t))
+			cfg.OnConfigChanged(&corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{Name: config.GetFeatureFlagsConfigName()},
+				Data: map[string]string{
+					"enable-api-fields": "alpha",
+				},
+			})
+			ctx = cfg.ToContext(ctx)
+			rpt, err := ResolvePipelineTask(ctx, pr, getTask, getTaskRun, getRun, tc.pt, nil)
+			if err != nil {
+				t.Fatalf("Did not expect error when resolving PipelineRun: %v", err)
+			}
+			if d := cmp.Diff(tc.want, rpt); d != "" {
+				t.Errorf("Did not get expected ResolvePipelineTask with Matrix: %s", diff.PrintWantGot(d))
+			}
+		})
+	}
+}
+
 func TestIsSuccessful(t *testing.T) {
 	for _, tc := range []struct {
 		name string