Add Task to v1alpha2 🎋

This modify how `TaskSpec` looks from v1alpha1:
- params is now directly under spec
- no more inputs and outputs, get replaced by resources
- resource has input and output resource declaration fields, similar
  to how it is used in Pipeline

The next step are :
- Add more types (Pipeline, TaskRun, PipelineRun, Condition)
- Refactor v1alpha1 to embedded v1alpha2 (for storage purpose)
- Auto-conversion from v1alpha1

Signed-off-by: Vincent Demeester <vdemeest@redhat.com>

pkg/apis/pipeline/v1alpha1/merge.go

@@ -17,74 +17,14 @@ limitations under the License.
 package v1alpha1
 
 import (
-	"encoding/json"
-
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha2"
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/strategicpatch"
 )
 
 // MergeStepsWithStepTemplate takes a possibly nil container template and a
 // list of steps, merging each of the steps with the container template, if
 // it's not nil, and returning the resulting list.
+// Deprecated
 func MergeStepsWithStepTemplate(template *v1.Container, steps []Step) ([]Step, error) {
-	if template == nil {
-		return steps, nil
-	}
-
-	// We need JSON bytes to generate a patch to merge the step containers
-	// onto the template container, so marshal the template.
-	templateAsJSON, err := json.Marshal(template)
-	if err != nil {
-		return nil, err
-	}
-	// We need to do a three-way merge to actually merge the template and
-	// step containers, so we need an empty container as the "original"
-	emptyAsJSON, err := json.Marshal(&v1.Container{})
-	if err != nil {
-		return nil, err
-	}
-
-	for i, s := range steps {
-		// Marshal the step's to JSON
-		stepAsJSON, err := json.Marshal(s.Container)
-		if err != nil {
-			return nil, err
-		}
-
-		// Get the patch meta for Container, which is needed for generating and applying the merge patch.
-		patchSchema, err := strategicpatch.NewPatchMetaFromStruct(template)
-
-		if err != nil {
-			return nil, err
-		}
-
-		// Create a merge patch, with the empty JSON as the original, the step JSON as the modified, and the template
-		// JSON as the current - this lets us do a deep merge of the template and step containers, with awareness of
-		// the "patchMerge" tags.
-		patch, err := strategicpatch.CreateThreeWayMergePatch(emptyAsJSON, stepAsJSON, templateAsJSON, patchSchema, true)
-		if err != nil {
-			return nil, err
-		}
-
-		// Actually apply the merge patch to the template JSON.
-		mergedAsJSON, err := strategicpatch.StrategicMergePatchUsingLookupPatchMeta(templateAsJSON, patch, patchSchema)
-		if err != nil {
-			return nil, err
-		}
-
-		// Unmarshal the merged JSON to a Container pointer, and return it.
-		merged := &v1.Container{}
-		err = json.Unmarshal(mergedAsJSON, merged)
-		if err != nil {
-			return nil, err
-		}
-
-		// If the container's args is nil, reset it to empty instead
-		if merged.Args == nil && s.Args != nil {
-			merged.Args = []string{}
-		}
-
-		steps[i] = Step{Container: *merged}
-	}
-	return steps, nil
+	return v1alpha2.MergeStepsWithStepTemplate(template, steps)
 }

pkg/apis/pipeline/v1alpha1/param_types.go

@@ -17,113 +17,37 @@ limitations under the License.
 package v1alpha1
 
 import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/tektoncd/pipeline/pkg/substitution"
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha2"
 )
 
 // ParamSpec defines arbitrary parameters needed beyond typed inputs (such as
 // resources). Parameter values are provided by users as inputs on a TaskRun
 // or PipelineRun.
-type ParamSpec struct {
-	// Name declares the name by which a parameter is referenced.
-	Name string `json:"name"`
-	// Type is the user-specified type of the parameter. The possible types
-	// are currently "string" and "array", and "string" is the default.
-	// +optional
-	Type ParamType `json:"type,omitempty"`
-	// Description is a user-facing description of the parameter that may be
-	// used to populate a UI.
-	// +optional
-	Description string `json:"description,omitempty"`
-	// Default is the value a parameter takes if no input value is supplied. If
-	// default is set, a Task may be executed without a supplied value for the
-	// parameter.
-	// +optional
-	Default *ArrayOrString `json:"default,omitempty"`
-}
-
-func (pp *ParamSpec) SetDefaults(ctx context.Context) {
-	if pp != nil && pp.Type == "" {
-		if pp.Default != nil {
-			// propagate the parsed ArrayOrString's type to the parent ParamSpec's type
-			pp.Type = pp.Default.Type
-		} else {
-			// ParamTypeString is the default value (when no type can be inferred from the default value)
-			pp.Type = ParamTypeString
-		}
-	}
-}
+type ParamSpec = v1alpha2.ParamSpec
 
 // ResourceParam declares a string value to use for the parameter called Name, and is used in
 // the specific context of PipelineResources.
-type ResourceParam struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
-}
+type ResourceParam = v1alpha2.ResourceParam
 
 // Param declares an ArrayOrString to use for the parameter called name.
-type Param struct {
-	Name  string        `json:"name"`
-	Value ArrayOrString `json:"value"`
-}
+type Param = v1alpha2.Param
 
 // ParamType indicates the type of an input parameter;
 // Used to distinguish between a single string and an array of strings.
-type ParamType string
+type ParamType = v1alpha2.ParamType
 
 // Valid ParamTypes:
 const (
-	ParamTypeString ParamType = "string"
-	ParamTypeArray  ParamType = "array"
+	ParamTypeString ParamType = v1alpha2.ParamTypeString
+	ParamTypeArray  ParamType = v1alpha2.ParamTypeArray
 )
 
 // AllParamTypes can be used for ParamType validation.
-var AllParamTypes = []ParamType{ParamTypeString, ParamTypeArray}
+var AllParamTypes = v1alpha2.AllParamTypes
 
 // ArrayOrString is modeled after IntOrString in kubernetes/apimachinery:
 
 // ArrayOrString is a type that can hold a single string or string array.
 // Used in JSON unmarshalling so that a single JSON field can accept
 // either an individual string or an array of strings.
-type ArrayOrString struct {
-	Type      ParamType // Represents the stored type of ArrayOrString.
-	StringVal string
-	ArrayVal  []string
-}
-
-// UnmarshalJSON implements the json.Unmarshaller interface.
-func (arrayOrString *ArrayOrString) UnmarshalJSON(value []byte) error {
-	if value[0] == '"' {
-		arrayOrString.Type = ParamTypeString
-		return json.Unmarshal(value, &arrayOrString.StringVal)
-	}
-	arrayOrString.Type = ParamTypeArray
-	return json.Unmarshal(value, &arrayOrString.ArrayVal)
-}
-
-// MarshalJSON implements the json.Marshaller interface.
-func (arrayOrString ArrayOrString) MarshalJSON() ([]byte, error) {
-	switch arrayOrString.Type {
-	case ParamTypeString:
-		return json.Marshal(arrayOrString.StringVal)
-	case ParamTypeArray:
-		return json.Marshal(arrayOrString.ArrayVal)
-	default:
-		return []byte{}, fmt.Errorf("impossible ArrayOrString.Type: %q", arrayOrString.Type)
-	}
-}
-
-func (arrayOrString *ArrayOrString) ApplyReplacements(stringReplacements map[string]string, arrayReplacements map[string][]string) {
-	if arrayOrString.Type == ParamTypeString {
-		arrayOrString.StringVal = substitution.ApplyReplacements(arrayOrString.StringVal, stringReplacements)
-	} else {
-		var newArrayVal []string
-		for _, v := range arrayOrString.ArrayVal {
-			newArrayVal = append(newArrayVal, substitution.ApplyArrayReplacements(v, stringReplacements, arrayReplacements)...)
-		}
-		arrayOrString.ArrayVal = newArrayVal
-	}
-}
+type ArrayOrString = v1alpha2.ArrayOrString

pkg/apis/pipeline/v1alpha1/resource_types.go

@@ -19,45 +19,42 @@ package v1alpha1
 import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha2"
 	"golang.org/x/xerrors"
-	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 // PipelineResourceType represents the type of endpoint the pipelineResource is, so that the
 // controller will know this pipelineResource should be fetched and optionally what
 // additional metatdata should be provided for it.
-type PipelineResourceType string
+type PipelineResourceType = v1alpha2.PipelineResourceType
 
 var (
-	AllowedOutputResources = map[PipelineResourceType]bool{
-		PipelineResourceTypeStorage: true,
-		PipelineResourceTypeGit:     true,
-	}
+	AllowedOutputResources = v1alpha2.AllowedOutputResources
 )
 
 const (
 	// PipelineResourceTypeGit indicates that this source is a GitHub repo.
-	PipelineResourceTypeGit PipelineResourceType = "git"
+	PipelineResourceTypeGit PipelineResourceType = v1alpha2.PipelineResourceTypeGit
 
 	// PipelineResourceTypeStorage indicates that this source is a storage blob resource.
-	PipelineResourceTypeStorage PipelineResourceType = "storage"
+	PipelineResourceTypeStorage PipelineResourceType = v1alpha2.PipelineResourceTypeStorage
 
 	// PipelineResourceTypeImage indicates that this source is a docker Image.
-	PipelineResourceTypeImage PipelineResourceType = "image"
+	PipelineResourceTypeImage PipelineResourceType = v1alpha2.PipelineResourceTypeImage
 
 	// PipelineResourceTypeCluster indicates that this source is a k8s cluster Image.
-	PipelineResourceTypeCluster PipelineResourceType = "cluster"
+	PipelineResourceTypeCluster PipelineResourceType = v1alpha2.PipelineResourceTypeCluster
 
 	// PipelineResourceTypePullRequest indicates that this source is a SCM Pull Request.
-	PipelineResourceTypePullRequest PipelineResourceType = "pullRequest"
+	PipelineResourceTypePullRequest PipelineResourceType = v1alpha2.PipelineResourceTypePullRequest
 
 	// PipelineResourceTypeCloudEvent indicates that this source is a cloud event URI
-	PipelineResourceTypeCloudEvent PipelineResourceType = "cloudEvent"
+	PipelineResourceTypeCloudEvent PipelineResourceType = v1alpha2.PipelineResourceTypeCloudEvent
 )
 
 // AllResourceTypes can be used for validation to check if a provided Resource type is one of the known types.
-var AllResourceTypes = []PipelineResourceType{PipelineResourceTypeGit, PipelineResourceTypeStorage, PipelineResourceTypeImage, PipelineResourceTypeCluster, PipelineResourceTypePullRequest, PipelineResourceTypeCloudEvent}
+var AllResourceTypes = v1alpha2.AllResourceTypes
 
 // PipelineResourceInterface interface to be implemented by different PipelineResource types
 type PipelineResourceInterface interface {
@@ -77,33 +74,10 @@ type PipelineResourceInterface interface {
 }
 
 // TaskModifier is an interface to be implemented by different PipelineResources
-type TaskModifier interface {
-	GetStepsToPrepend() []Step
-	GetStepsToAppend() []Step
-	GetVolumes() []v1.Volume
-}
+type TaskModifier = v1alpha2.TaskModifier
 
 // InternalTaskModifier implements TaskModifier for resources that are built-in to Tekton Pipelines.
-type InternalTaskModifier struct {
-	StepsToPrepend []Step
-	StepsToAppend  []Step
-	Volumes        []v1.Volume
-}
-
-// GetStepsToPrepend returns a set of Steps to prepend to the Task.
-func (tm *InternalTaskModifier) GetStepsToPrepend() []Step {
-	return tm.StepsToPrepend
-}
-
-// GetStepsToAppend returns a set of Steps to append to the Task.
-func (tm *InternalTaskModifier) GetStepsToAppend() []Step {
-	return tm.StepsToAppend
-}
-
-// GetVolumes returns a set of Volumes to prepend to the Task pod.
-func (tm *InternalTaskModifier) GetVolumes() []v1.Volume {
-	return tm.Volumes
-}
+type InternalTaskModifier = v1alpha2.InternalTaskModifier
 
 func checkStepNotAlreadyAdded(s Step, steps []Step) error {
 	for _, step := range steps {
@@ -118,6 +92,7 @@ func checkStepNotAlreadyAdded(s Step, steps []Step) error {
 // If steps with the same name exist in ts an error will be returned. If identical Volumes have
 // been added, they will not be added again. If Volumes with the same name but different contents
 // have been added, an error will be returned.
+// FIXME(vdemeester) de-duplicate this
 func ApplyTaskModifier(ts *TaskSpec, tm TaskModifier) error {
 	steps := tm.GetStepsToPrepend()
 	for _, step := range steps {
@@ -238,18 +213,7 @@ type PipelineResourceList struct {
 // PipelineResources within the type's definition, and when provided as an Input, the Name will be the
 // path to the volume mounted containing this PipelineResource as an input (e.g.
 // an input Resource named `workspace` will be mounted at `/workspace`).
-type ResourceDeclaration struct {
-	// Name declares the name by which a resource is referenced in the
-	// definition. Resources may be referenced by name in the definition of a
-	// Task's steps.
-	Name string `json:"name"`
-	// Type is the type of this resource;
-	Type PipelineResourceType `json:"type"`
-	// TargetPath is the path in workspace directory where the resource
-	// will be copied.
-	// +optional
-	TargetPath string `json:"targetPath,omitempty"`
-}
+type ResourceDeclaration = v1alpha2.ResourceDeclaration
 
 // ResourceFromType returns an instance of the correct PipelineResource object type which can be
 // used to add input and ouput containers as well as volumes to a TaskRun's pod in order to realize

pkg/apis/pipeline/v1alpha1/task_types.go

@@ -19,6 +19,8 @@ package v1alpha1
 import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha2"
 )
 
 func (t *Task) TaskSpec() TaskSpec {
@@ -63,14 +65,7 @@ type TaskSpec struct {
 
 // Step embeds the Container type, which allows it to include fields not
 // provided by Container.
-type Step struct {
-	corev1.Container
-
-	// Script is the contents of an executable file to execute.
-	//
-	// If Script is not empty, the Step cannot have an Command or Args.
-	Script string `json:"script,omitempty"`
-}
+type Step = v1alpha2.Step
 
 // +genclient
 // +genclient:noStatus
@@ -111,9 +106,7 @@ type Inputs struct {
 // the Task definition, and when provided as an Input, the Name will be the
 // path to the volume mounted containing this Resource as an input (e.g.
 // an input Resource named `workspace` will be mounted at `/workspace`).
-type TaskResource struct {
-	ResourceDeclaration `json:",inline"`
-}
+type TaskResource = v1alpha2.TaskResource
 
 // Outputs allow a task to declare what data the Build/Task will be producing,
 // i.e. results such as logs and artifacts such as images.