Define v1alpha1 Run type and generated scaffolding

This defines the basic Run type, which will be used to specify
executions of Custom Tasks and report status of those executions.

This change doesn't wire the new type in to any controllers or
validating webhooks, so that this time nothing will happen when a Run is
created. It also doesn't wire in to PipelineRun execution to enable
Pipelines to specify Custom Tasks.

config/300-run.yaml

@@ -0,0 +1,71 @@
+# Copyright 2020 The Tekton Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: apiextensions.k8s.io/v1beta1
+kind: CustomResourceDefinition
+metadata:
+  name: runs.tekton.dev
+  labels:
+    app.kubernetes.io/instance: default
+    app.kubernetes.io/part-of: tekton-pipelines
+    pipeline.tekton.dev/release: "devel"
+    version: "devel"
+spec:
+  group: tekton.dev
+  preserveUnknownFields: false
+  validation:
+    openAPIV3Schema:
+      type: object
+      # One can use x-kubernetes-preserve-unknown-fields: true
+      # at the root of the schema (and inside any properties, additionalProperties)
+      # to get the traditional CRD behaviour that nothing is pruned, despite
+      # setting spec.preserveUnknownProperties: false.
+      #
+      # See https://kubernetes.io/blog/2019/06/20/crd-structural-schema/
+      # See issue: https://github.com/knative/serving/issues/912
+      x-kubernetes-preserve-unknown-fields: true
+  versions:
+  - name: v1alpha1
+    served: true
+    storage: true
+  names:
+    kind: Run
+    plural: runs
+    categories:
+    - tekton
+    - tekton-pipelines
+  scope: Namespaced
+  additionalPrinterColumns:
+  - name: Succeeded
+    type: string
+    JSONPath: ".status.conditions[?(@.type==\"Succeeded\")].status"
+  - name: Reason
+    type: string
+    JSONPath: ".status.conditions[?(@.type==\"Succeeded\")].reason"
+  - name: StartTime
+    type: date
+    JSONPath: .status.startTime
+  - name: CompletionTime
+    type: date
+    JSONPath: .status.completionTime
+  # Opt into the status subresource so metadata.generation
+  # starts to increment
+  subresources:
+    status: {}
+  conversion:
+    strategy: Webhook
+    webhookClientConfig:
+      service:
+        name: tekton-pipelines-webhook
+        namespace: tekton-pipelines

pkg/apis/pipeline/controller.go

@@ -21,6 +21,9 @@ const (
 	// nolint: golint
 	PipelineRunControllerName = "PipelineRun"
 
-	// TaskRunControllerName holds the name of the PipelineRun controller
+	// TaskRunControllerName holds the name of the TaskRun controller
 	TaskRunControllerName = "TaskRun"
+
+	// TaskRunControllerName holds the name of the PipelineRun controller
+	RunControllerName = "Run"
 )

pkg/apis/pipeline/register.go

@@ -45,6 +45,9 @@ const (
 
 	// ConditionNameKey is used as the label identifier for a Condition
 	ConditionNameKey = "/conditionName"
+
+	// RunKey is used as the label identifier for a Run
+	RunKey = "/run"
 )
 
 var (
@@ -63,6 +66,11 @@ var (
 		Group:    GroupName,
 		Resource: "taskruns",
 	}
+	// RunResource represents a Tekton Run
+	RunResource = schema.GroupResource{
+		Group:    GroupName,
+		Resource: "runs",
+	}
 	// PipelineResource represents a Tekton Pipeline
 	PipelineResource = schema.GroupResource{
 		Group:    GroupName,

pkg/apis/pipeline/v1alpha1/register.go

@@ -60,6 +60,8 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 		&PipelineRunList{},
 		&PipelineResource{},
 		&PipelineResourceList{},
+		&Run{},
+		&RunList{},
 	)
 	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
 	return nil

pkg/apis/pipeline/v1alpha1/run_defaults.go

@@ -0,0 +1,34 @@
+/*
+Copyright 2020 The Tekton Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha1
+
+import (
+	"context"
+
+	"knative.dev/pkg/apis"
+)
+
+var _ apis.Defaultable = (*Run)(nil)
+
+func (r *Run) SetDefaults(ctx context.Context) {
+	ctx = apis.WithinParent(ctx, r.ObjectMeta)
+	r.Spec.SetDefaults(apis.WithinSpec(ctx))
+}
+
+func (rs *RunSpec) SetDefaults(ctx context.Context) {
+	// No defaults to set.
+}

pkg/apis/pipeline/v1alpha1/run_types.go

@@ -0,0 +1,196 @@
+/*
+Copyright 2020 The Tekton Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha1
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/tektoncd/pipeline/pkg/apis/pipeline"
+	v1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"knative.dev/pkg/apis"
+	duckv1 "knative.dev/pkg/apis/duck/v1"
+)
+
+var (
+	runGroupVersionKind = schema.GroupVersionKind{
+		Group:   SchemeGroupVersion.Group,
+		Version: SchemeGroupVersion.Version,
+		Kind:    pipeline.RunControllerName,
+	}
+)
+
+// RunSpec defines the desired state of Run
+type RunSpec struct {
+	// +optional
+	Ref *TaskRef `json:"ref,omitempty"`
+
+	// +optional
+	Params []v1beta1.Param `json:"params,omitempty"`
+
+	// TODO(https://github.com/tektoncd/community/pull/128)
+	// - cancellation
+	// - timeout
+	// - inline task spec
+	// - workspaces ?
+}
+
+// TODO(jasonhall): Move this to a Params type so other code can use it?
+func (rs RunSpec) GetParam(name string) *v1beta1.Param {
+	for _, p := range rs.Params {
+		if p.Name == name {
+			return &p
+		}
+	}
+	return nil
+}
+
+type RunStatus struct {
+	duckv1.Status `json:",inline"`
+
+	// RunStatusFields inlines the status fields.
+	RunStatusFields `json:",inline"`
+}
+
+var runCondSet = apis.NewBatchConditionSet()
+
+// GetCondition returns the Condition matching the given type.
+func (r *RunStatus) GetCondition(t apis.ConditionType) *apis.Condition {
+	return runCondSet.Manage(r).GetCondition(t)
+}
+
+// InitializeConditions will set all conditions in runCondSet to unknown for the PipelineRun
+// and set the started time to the current time
+func (r *RunStatus) InitializeConditions() {
+	started := false
+	if r.StartTime.IsZero() {
+		r.StartTime = &metav1.Time{Time: time.Now()}
+		started = true
+	}
+	conditionManager := runCondSet.Manage(r)
+	conditionManager.InitializeConditions()
+	// Ensure the started reason is set for the "Succeeded" condition
+	if started {
+		initialCondition := conditionManager.GetCondition(apis.ConditionSucceeded)
+		initialCondition.Reason = "Started"
+		conditionManager.SetCondition(*initialCondition)
+	}
+}
+
+// SetCondition sets the condition, unsetting previous conditions with the same
+// type as necessary.
+func (r *RunStatus) SetCondition(newCond *apis.Condition) {
+	if newCond != nil {
+		runCondSet.Manage(r).SetCondition(*newCond)
+	}
+}
+
+// GetConditionSet retrieves the condition set for this resource. Implements
+// the KRShaped interface.
+func (r *Run) GetConditionSet() apis.ConditionSet { return runCondSet }
+
+// GetStatus retrieves the status of the Parallel. Implements the KRShaped
+// interface.
+func (r *Run) GetStatus() *duckv1.Status { return &r.Status.Status }
+
+// RunStatusFields holds the fields of Run's status.  This is defined
+// separately and inlined so that other types can readily consume these fields
+// via duck typing.
+type RunStatusFields struct {
+	// StartTime is the time the build is actually started.
+	// +optional
+	StartTime *metav1.Time `json:"startTime,omitempty"`
+
+	// CompletionTime is the time the build completed.
+	// +optional
+	CompletionTime *metav1.Time `json:"completionTime,omitempty"`
+
+	// Results reports any output result values to be consumed by later
+	// tasks in a pipeline.
+	// +optional
+	Results []v1beta1.TaskRunResult `json:"results,omitempty"`
+
+	// TODO(jasonhall): Add a field to hold additional arbitrary fields as
+	// a map[string]interface{}.
+}
+
+// +genclient
+// +genreconciler
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// Run represents a single execution of a Custom Task.
+//
+// +k8s:openapi-gen=true
+type Run struct {
+	metav1.TypeMeta `json:",inline"`
+	// +optional
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	// +optional
+	Spec RunSpec `json:"spec,omitempty"`
+	// +optional
+	Status RunStatus `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// RunList contains a list of Run
+type RunList struct {
+	metav1.TypeMeta `json:",inline"`
+	// +optional
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Run `json:"items"`
+}
+
+// GetOwnerReference gets the task run as owner reference for any related objects
+func (r *Run) GetOwnerReference() metav1.OwnerReference {
+	return *metav1.NewControllerRef(r, runGroupVersionKind)
+}
+
+// HasPipelineRunOwnerReference returns true of Run has
+// owner reference of type PipelineRun
+func (r *Run) HasPipelineRunOwnerReference() bool {
+	for _, ref := range r.GetOwnerReferences() {
+		if ref.Kind == pipeline.PipelineRunControllerName {
+			return true
+		}
+	}
+	return false
+}
+
+// IsDone returns true if the Run's status indicates that it is done.
+func (r *Run) IsDone() bool {
+	return !r.Status.GetCondition(apis.ConditionSucceeded).IsUnknown()
+}
+
+// HasStarted function check whether taskrun has valid start time set in its status
+func (r *Run) HasStarted() bool {
+	return r.Status.StartTime != nil && !r.Status.StartTime.IsZero()
+}
+
+// IsSuccessful returns true if the Run's status indicates that it is done.
+func (r *Run) IsSuccessful() bool {
+	return r.Status.GetCondition(apis.ConditionSucceeded).IsTrue()
+}
+
+// GetRunKey return the taskrun key for timeout handler map
+func (r *Run) GetRunKey() string {
+	// The address of the pointer is a threadsafe unique identifier for the taskrun
+	return fmt.Sprintf("%s/%p", "Run", r)
+}