chore: regenerated

Author: github-actions

go.mod

@@ -57,6 +57,7 @@ require (
 	github.com/go-kit/log v0.2.1 // indirect
 	github.com/go-logfmt/logfmt v0.5.1 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/zapr v1.3.0 // indirect
 	github.com/go-openapi/jsonpointer v0.21.0 // indirect
 	github.com/go-openapi/jsonreference v0.21.0 // indirect
 	github.com/go-openapi/swag v0.23.0 // indirect

pkg/apis/lighthouse/v1alpha1/types.go

@@ -40,6 +40,16 @@ const (
 	ErrorState PipelineState = "error"
 )
 
+// IsTerminalPipelineState reports whether state is a finished pipeline outcome: success, failure,
+// aborted, or error. Triggered, pending, running, and other values are non-terminal.
+func IsTerminalPipelineState(state PipelineState) bool {
+	switch state {
+	case SuccessState, FailureState, AbortedState, ErrorState:
+		return true
+	}
+	return false
+}
+
 // Environment variables to be added to the pipeline we kick off
 const (
 	// BuildIDEnv is an optional unique build ID environment variable that can be used by an engine.

pkg/apis/lighthouse/v1alpha1/types_test.go

@@ -139,3 +139,25 @@ func TestPipelineOptionsSpec_GetEnvVars(t *testing.T) {
 		})
 	}
 }
+
+func TestIsTerminalPipelineState(t *testing.T) {
+	tests := []struct {
+		state v1alpha1.PipelineState
+		want  bool
+	}{
+		{v1alpha1.RunningState, false},
+		{v1alpha1.PendingState, false},
+		{v1alpha1.SuccessState, true},
+		{v1alpha1.FailureState, true},
+		{v1alpha1.AbortedState, true},
+		{v1alpha1.ErrorState, true},
+		{v1alpha1.PipelineState("unknown"), false},
+	}
+	for _, tt := range tests {
+		t.Run(string(tt.state), func(t *testing.T) {
+			if got := v1alpha1.IsTerminalPipelineState(tt.state); got != tt.want {
+				t.Errorf("IsTerminalPipelineState(%q) = %v, want %v", tt.state, got, tt.want)
+			}
+		})
+	}
+}

pkg/engines/tekton/activity.go

@@ -159,3 +159,50 @@ func convertTektonStatus(cond *apis.Condition, start, finished *metav1.Time) v1a
 		return v1alpha1.PendingState
 	}
 }
+
+func timePtrEqual(a, b *metav1.Time) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return a.Equal(b)
+}
+
+// TerminalActivitySyncedWithPipelineRun returns true when the LighthouseJob's Activity already matches
+// the terminal PipelineRun at the level ConvertPipelineRun would set without fetching TaskRuns (top-level
+// record fields, stage count, optional report URL).
+func TerminalActivitySyncedWithPipelineRun(job *v1alpha1.LighthouseJob, pr *pipelinev1.PipelineRun, expectedReportURL string, dashboardConfigured bool) bool {
+	if job == nil || pr == nil {
+		return false
+	}
+	cond := pr.Status.GetCondition(apis.ConditionSucceeded)
+	if cond == nil || (!cond.IsTrue() && !cond.IsFalse()) {
+		return false
+	}
+	act := job.Status.Activity
+	if act == nil {
+		return false
+	}
+	expectedStatus := convertTektonStatus(cond, pr.Status.StartTime, pr.Status.CompletionTime)
+	if act.Status != expectedStatus {
+		return false
+	}
+	if act.Name != pr.Name {
+		return false
+	}
+	if !timePtrEqual(act.StartTime, pr.Status.StartTime) {
+		return false
+	}
+	if !timePtrEqual(act.CompletionTime, pr.Status.CompletionTime) {
+		return false
+	}
+	if len(act.Stages) != len(pr.Status.ChildReferences) {
+		return false
+	}
+	if dashboardConfigured && job.Status.ReportURL != expectedReportURL {
+		return false
+	}
+	return true
+}

pkg/engines/tekton/activity_test.go

@@ -15,7 +15,9 @@ import (
 	pipelinev1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
 	tektonv1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
 	tektonfake "github.com/tektoncd/pipeline/pkg/client/clientset/versioned/fake"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"knative.dev/pkg/apis"
 	"sigs.k8s.io/yaml"
 )
 
@@ -194,6 +196,68 @@ func loadRecord(t *testing.T, dir string) *v1alpha1.ActivityRecord {
 	return nil
 }
 
+func TestTerminalActivitySyncedWithPipelineRun(t *testing.T) {
+	now := metav1.Now()
+	job := &v1alpha1.LighthouseJob{
+		Status: v1alpha1.LighthouseJobStatus{
+			ReportURL: "https://dash/pipeline",
+			Activity: &v1alpha1.ActivityRecord{
+				Name:             "foo-pr",
+				Status:           v1alpha1.SuccessState,
+				StartTime:        &now,
+				CompletionTime:   &now,
+				Stages:           []*v1alpha1.ActivityStageOrStep{{Name: "build"}},
+			},
+		},
+	}
+
+	t.Run("synced when pipeline run is terminal and activity matches", func(t *testing.T) {
+		pr := &pipelinev1.PipelineRun{
+			ObjectMeta: metav1.ObjectMeta{Name: "foo-pr"},
+		}
+		pr.Status.StartTime = &now
+		pr.Status.CompletionTime = &now
+		pr.Status.ChildReferences = []pipelinev1.ChildStatusReference{{Name: "tr-1", PipelineTaskName: "build"}}
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
+		})
+		assert.True(t, tekton.TerminalActivitySyncedWithPipelineRun(job, pr, "https://dash/pipeline", true))
+		assert.False(t, tekton.TerminalActivitySyncedWithPipelineRun(job, pr, "https://other", true))
+		assert.True(t, tekton.TerminalActivitySyncedWithPipelineRun(job, pr, "", false))
+	})
+
+	t.Run("false when pipeline run has no succeeded condition", func(t *testing.T) {
+		pr := &pipelinev1.PipelineRun{ObjectMeta: metav1.ObjectMeta{Name: "foo-pr"}}
+		assert.False(t, tekton.TerminalActivitySyncedWithPipelineRun(job, pr, "", false))
+	})
+
+	t.Run("false when pipeline run is not terminal", func(t *testing.T) {
+		pr := &pipelinev1.PipelineRun{ObjectMeta: metav1.ObjectMeta{Name: "foo-pr"}}
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionUnknown,
+		})
+		assert.False(t, tekton.TerminalActivitySyncedWithPipelineRun(job, pr, "", false))
+	})
+
+	t.Run("false when status cleared", func(t *testing.T) {
+		pr := &pipelinev1.PipelineRun{
+			ObjectMeta: metav1.ObjectMeta{Name: "foo-pr"},
+		}
+		pr.Status.StartTime = &now
+		pr.Status.CompletionTime = &now
+		pr.Status.ChildReferences = []pipelinev1.ChildStatusReference{{Name: "tr-1", PipelineTaskName: "build"}}
+		pr.Status.SetCondition(&apis.Condition{
+			Type:   apis.ConditionSucceeded,
+			Status: corev1.ConditionTrue,
+		})
+		prIncomplete := pr.DeepCopy()
+		prIncomplete.Status = pipelinev1.PipelineRunStatus{}
+		assert.False(t, tekton.TerminalActivitySyncedWithPipelineRun(job, prIncomplete, "", false))
+	})
+}
+
 // assertFileExists asserts that the given file exists
 func assertFileExists(t *testing.T, fileName string) bool {
 	exists, err := util.FileExists(fileName)

pkg/engines/tekton/controller.go

@@ -17,7 +17,9 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 )
 
@@ -27,33 +29,37 @@ var apiGVStr = lighthousev1alpha1.SchemeGroupVersion.String()
 
 // LighthouseJobReconciler reconciles a LighthouseJob object
 type LighthouseJobReconciler struct {
-	client            client.Client
-	tektonclient      tektonversioned.Interface
-	apiReader         client.Reader
-	logger            *logrus.Entry
-	scheme            *runtime.Scheme
-	idGenerator       buildIDGenerator
-	dashboardURL      string
-	dashboardTemplate string
-	namespace         string
-	disableLogging    bool
+	client                   client.Client
+	tektonclient             tektonversioned.Interface
+	apiReader                client.Reader
+	logger                   *logrus.Entry
+	scheme                   *runtime.Scheme
+	idGenerator              buildIDGenerator
+	dashboardURL             string
+	dashboardTemplate        string
+	namespace                string
+	disableLogging           bool
+	skipTerminatedReconciles bool
+	maxConcurrentReconciles  int
 }
 
 // NewLighthouseJobReconciler creates a LighthouseJob reconciler
-func NewLighthouseJobReconciler(client client.Client, apiReader client.Reader, scheme *runtime.Scheme, tektonclient tektonversioned.Interface, dashboardURL string, dashboardTemplate string, namespace string) *LighthouseJobReconciler {
+func NewLighthouseJobReconciler(client client.Client, apiReader client.Reader, scheme *runtime.Scheme, tektonclient tektonversioned.Interface, dashboardURL string, dashboardTemplate string, namespace string, skipTerminatedReconciles bool, maxConcurrentReconciles int) *LighthouseJobReconciler {
 	if dashboardTemplate == "" {
 		dashboardTemplate = os.Getenv("LIGHTHOUSE_DASHBOARD_TEMPLATE")
 	}
 	return &LighthouseJobReconciler{
-		client:            client,
-		apiReader:         apiReader,
-		logger:            logrus.NewEntry(logrus.StandardLogger()).WithField("controller", controllerName),
-		scheme:            scheme,
-		dashboardURL:      dashboardURL,
-		dashboardTemplate: dashboardTemplate,
-		namespace:         namespace,
-		tektonclient:      tektonclient,
-		idGenerator:       &epochBuildIDGenerator{},
+		client:                   client,
+		apiReader:                apiReader,
+		logger:                   logrus.NewEntry(logrus.StandardLogger()).WithField("controller", controllerName),
+		scheme:                   scheme,
+		dashboardURL:             dashboardURL,
+		dashboardTemplate:        dashboardTemplate,
+		namespace:                namespace,
+		tektonclient:             tektonclient,
+		idGenerator:              &epochBuildIDGenerator{},
+		skipTerminatedReconciles: skipTerminatedReconciles,
+		maxConcurrentReconciles:  maxConcurrentReconciles,
 	}
 }
 
@@ -74,11 +80,23 @@ func (r *LighthouseJobReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		return err
 	}
 
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&lighthousev1alpha1.LighthouseJob{}).
-		WithEventFilter(predicate.ResourceVersionChangedPredicate{}).
-		Owns(&pipelinev1.PipelineRun{}).
-		Complete(r)
+	ctrlr := ctrl.NewControllerManagedBy(mgr).
+		For(&lighthousev1alpha1.LighthouseJob{}, builder.WithPredicates(
+			lighthouseJobPredicateFactory(r.skipTerminatedReconciles),
+		)).
+		Owns(&pipelinev1.PipelineRun{}, builder.WithPredicates(
+			predicate.ResourceVersionChangedPredicate{},
+		))
+
+	if r.maxConcurrentReconciles > 1 {
+		ctrlr = ctrlr.WithOptions(
+			controller.Options{
+				MaxConcurrentReconciles: r.maxConcurrentReconciles,
+			},
+		)
+	}
+
+	return ctrlr.Complete(r)
 }
 
 // Reconcile represents an iteration of the reconciliation loop
@@ -180,6 +198,19 @@ func (r *LighthouseJobReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 			}
 		}
 
+		// When terminal shortcut is enabled, skip ConvertPipelineRun + status update if the PipelineRun is
+		// done and Activity already matches (covers Owns(PipelineRun) events; same flag as For() predicate).
+		if r.skipTerminatedReconciles {
+			expectedReportURL := ""
+			if r.dashboardURL != "" {
+				expectedReportURL = r.getPipelingetPipelineTargetURLeTargetURL(pipelineRun)
+			}
+			if TerminalActivitySyncedWithPipelineRun(&job, &pipelineRun, expectedReportURL, r.dashboardURL != "") {
+				r.logger.Debugf("Skipping terminal in-sync LighthouseJob %s", req.Name)
+				return ctrl.Result{}, nil
+			}
+		}
+
 		f := func(job *lighthousev1alpha1.LighthouseJob) error {
 			if r.dashboardURL != "" {
 				job.Status.ReportURL = r.getPipelingetPipelineTargetURLeTargetURL(pipelineRun)
@@ -271,3 +302,25 @@ func (r *LighthouseJobReconciler) retryModifyJob(ctx context.Context, ns client.
 		}
 	}
 }
+
+// lighthouseJobPredicateFactory returns the For(LighthouseJob) predicate set. When skipTerminatedReconciles
+// is false, only ResourceVersionChangedPredicate is used (legacy behavior). When true, it also skips
+// enqueue for LighthouseJobs whose activity is already in a terminal pipeline state (see Reconcile fast path).
+func lighthouseJobPredicateFactory(skipTerminatedReconciles bool) predicate.Predicate {
+	if skipTerminatedReconciles {
+		return predicate.And(
+			predicate.ResourceVersionChangedPredicate{},
+			predicate.NewPredicateFuncs(func(object client.Object) bool {
+				job, ok := object.(*lighthousev1alpha1.LighthouseJob)
+				if !ok {
+					return true
+				}
+				if job.Status.Activity != nil {
+					return !lighthousev1alpha1.IsTerminalPipelineState(job.Status.Activity.Status)
+				}
+				return true
+			}),
+		)
+	}
+	return predicate.ResourceVersionChangedPredicate{}
+}

pkg/engines/tekton/controller_test.go

@@ -98,7 +98,7 @@ func TestReconcile(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithStatusSubresource(observedJob).WithScheme(scheme).WithObjects(state...).Build()
 			fake.AddIndex(c, &pipelinev1.PipelineRun{}, jobOwnerKey, tektonControllerIndexFunc)
-			reconciler := NewLighthouseJobReconciler(c, c, scheme, tektonfakeClient, dashboardBaseURL, dashboardTemplate, ns)
+			reconciler := NewLighthouseJobReconciler(c, c, scheme, tektonfakeClient, dashboardBaseURL, dashboardTemplate, ns, false, 1)
 			reconciler.idGenerator = &seededRandIDGenerator{}
 			reconciler.disableLogging = true