Adjust PipelineRun's StartTime based on TaskRun state.

pkg/reconciler/pipelinerun/pipelinerun.go

@@ -528,6 +528,7 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1beta1.PipelineRun, get
 	}
 	// Read the condition the way it was set by the Mark* helpers
 	after = pr.Status.GetCondition(apis.ConditionSucceeded)
+	pr.Status.StartTime = pipelineRunFacts.State.AdjustStartTime(pr.Status.StartTime)
 	pr.Status.TaskRuns = pipelineRunFacts.State.GetTaskRunsStatus(pr)
 	pr.Status.SkippedTasks = pipelineRunFacts.GetSkippedTasks()
 	logger.Infof("PipelineRun %s status is being set to %s", pr.Name, after)

pkg/reconciler/pipelinerun/resources/pipelinerunstate.go

@@ -23,6 +23,7 @@ import (
 	"github.com/tektoncd/pipeline/pkg/reconciler/pipeline/dag"
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"knative.dev/pkg/apis"
 )
@@ -71,6 +72,27 @@ func (state PipelineRunState) IsBeforeFirstTaskRun() bool {
 	return true
 }
 
+// AdjustStartTime adjusts potential drift in the PipelineRun's start time.
+//
+// The StartTime will only adjust earlier, so that the PipelineRun's StartTime
+// is no later than any of its constituent TaskRuns.
+//
+// This drift could be due to us either failing to record the Run's start time
+// previously, or our own failure to observe a prior update before reconciling
+// the resource again.
+func (state PipelineRunState) AdjustStartTime(unadjustedStartTime *metav1.Time) *metav1.Time {
+	adjustedStartTime := unadjustedStartTime
+	for _, rprt := range state {
+		if rprt.TaskRun == nil {
+			continue
+		}
+		if rprt.TaskRun.CreationTimestamp.Time.Before(adjustedStartTime.Time) {
+			adjustedStartTime = &rprt.TaskRun.CreationTimestamp
+		}
+	}
+	return adjustedStartTime.DeepCopy()
+}
+
 // GetTaskRunsStatus returns a map of taskrun name and the taskrun
 // ignore a nil taskrun in pipelineRunState, otherwise, capture taskrun object from PipelineRun Status
 // update taskrun status based on the pipelineRunState before returning it in the map

pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go

@@ -1049,3 +1049,85 @@ func TestGetPipelineConditionStatus_PipelineTimeouts(t *testing.T) {
 		t.Fatalf("Expected to get status %s but got %s for state %v", corev1.ConditionFalse, c.Status, oneFinishedState)
 	}
 }
+
+func TestAdjustStartTime(t *testing.T) {
+	baseline := metav1.Time{Time: time.Now()}
+
+	tests := []struct {
+		name string
+		prs  PipelineRunState
+		want time.Time
+	}{{
+		name: "same times",
+		prs: PipelineRunState{{
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah",
+					CreationTimestamp: baseline,
+				},
+			},
+		}},
+		want: baseline.Time,
+	}, {
+		name: "taskrun starts later",
+		prs: PipelineRunState{{
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(1 * time.Second)},
+				},
+			},
+		}},
+		// Stay where you are, you are before the TaskRun.
+		want: baseline.Time,
+	}, {
+		name: "taskrun starts earlier",
+		prs: PipelineRunState{{
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-1 * time.Second)},
+				},
+			},
+		}},
+		// We expect this to adjust to the earlier time.
+		want: baseline.Time.Add(-1 * time.Second),
+	}, {
+		name: "multiple taskruns, some earlier",
+		prs: PipelineRunState{{
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah1",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-1 * time.Second)},
+				},
+			},
+		}, {
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah2",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-2 * time.Second)},
+				},
+			},
+		}, {
+			TaskRun: nil,
+		}, {
+			TaskRun: &v1beta1.TaskRun{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah3",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(2 * time.Second)},
+				},
+			},
+		}},
+		// We expect this to adjust to the earlier time.
+		want: baseline.Time.Add(-2 * time.Second),
+	}}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got := test.prs.AdjustStartTime(&baseline)
+			if got.Time != test.want {
+				t.Errorf("AdjustStartTime() = %v, wanted %v", got.Time, test.want)
+			}
+		})
+	}
+}