add a check for tektonconfig

Signed-off-by: Hasan Awad <hasan.m.awad94@gmail.com>

Author: hasanawad94

controllers/shipwrightbuild_controller.go

@@ -104,6 +104,44 @@ func deleteObjectsIfPresent(ctx context.Context, k8sClient client.Client, objs [
 	return nil
 }
 
+// Check and fetch TektonConfig
+func (r *ShipwrightBuildReconciler) fetchAndCheckTektonConfig(ctx context.Context, logger logr.Logger, b *v1alpha1.ShipwrightBuild) (bool, error) {
+	tektonConfig, err := r.TektonOperatorClient.TektonConfigs().Get(ctx, "config", metav1.GetOptions{})
+	if err != nil {
+		logger.Error(err, "Failed to fetch TektonConfig")
+		apimeta.SetStatusCondition(&b.Status.Conditions, metav1.Condition{
+			Type:    ConditionReady,
+			Status:  metav1.ConditionFalse,
+			Reason:  "TektonConfigMissing",
+			Message: "Unable to fetch TektonConfig from cluster",
+		})
+		if updateErr := r.Client.Status().Update(ctx, b); updateErr != nil {
+			logger.Error(updateErr, "Failed to update ShipwrightBuild status after TektonConfig fetch failure")
+		}
+		return false, err
+	}
+
+	// Check if TektonConfig is ready
+	for _, condition := range tektonConfig.Status.Conditions {
+		if condition.Type == ConditionReady && condition.Status == corev1.ConditionTrue {
+			return true, nil
+		}
+	}
+
+	// TektonConfig is not ready
+	logger.Info("TektonConfig is not ready yet")
+	apimeta.SetStatusCondition(&b.Status.Conditions, metav1.Condition{
+		Type:    ConditionReady,
+		Status:  metav1.ConditionFalse,
+		Reason:  "TektonNotReady",
+		Message: "Waiting for TektonConfig to become Ready",
+	})
+	if updateErr := r.Client.Status().Update(ctx, b); updateErr != nil {
+		logger.Error(updateErr, "Failed to update ShipwrightBuild status when TektonConfig is not ready")
+	}
+	return false, nil
+}
+
 // Reconcile performs the resource reconciliation steps to deploy or remove Shipwright Build
 // instances. When deletion-timestamp is found, the removal of the previously deploy resources is
 // executed, otherwise the regular deploy workflow takes place.
@@ -143,6 +181,15 @@ func (r *ShipwrightBuildReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 		}
 	}
 
+	// Requeue incase TektonConfig is not ready
+	ready, err := r.fetchAndCheckTektonConfig(ctx, logger, b)
+	if err != nil {
+		return RequeueWithError(err)
+	}
+	if !ready {
+		return Requeue()
+	}
+
 	// selecting the target namespace based on the CRD information, when not informed using the
 	// default namespace instead
 	targetNamespace := b.Spec.TargetNamespace

controllers/shipwrightbuild_controller_test.go

@@ -9,23 +9,25 @@ import (
 
 	o "github.com/onsi/gomega"
 
+	buildv1alpha1 "github.com/shipwright-io/build/pkg/apis/build/v1alpha1"
+	"github.com/shipwright-io/operator/api/v1alpha1"
+	tektonoperatorv1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
+	tektonoperatorv1alpha1client "github.com/tektoncd/operator/pkg/client/clientset/versioned/fake"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
+	crdv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	crdclientv1 "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/fake"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"knative.dev/pkg/apis"
+	duckv1 "knative.dev/pkg/apis/duck/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
-
-	"github.com/shipwright-io/operator/api/v1alpha1"
-	tektonoperatorv1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
-	tektonoperatorv1alpha1client "github.com/tektoncd/operator/pkg/client/clientset/versioned/fake"
-	crdv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 )
 
 // bootstrapShipwrightBuildReconciler start up a new instance of ShipwrightBuildReconciler which is
@@ -44,10 +46,12 @@ func bootstrapShipwrightBuildReconciler(
 	s.AddKnownTypes(v1alpha1.GroupVersion, &v1alpha1.ShipwrightBuild{})
 	s.AddKnownTypes(rbacv1.SchemeGroupVersion, &rbacv1.ClusterRoleBinding{})
 	s.AddKnownTypes(rbacv1.SchemeGroupVersion, &rbacv1.ClusterRole{})
+	s.AddKnownTypes(tektonoperatorv1alpha1.SchemeGroupVersion, &tektonoperatorv1alpha1.TektonConfig{})
+	s.AddKnownTypes(buildv1alpha1.SchemeGroupVersion, &buildv1alpha1.ClusterBuildStrategy{})
 
 	logger := zap.New()
 
-	c := fake.NewClientBuilder().WithScheme(s).WithObjects(b).Build()
+	c := fake.NewClientBuilder().WithScheme(s).WithObjects(b).WithStatusSubresource(&v1alpha1.ShipwrightBuild{}).Build()
 	var crdClient *crdclientv1.Clientset
 	var toClient *tektonoperatorv1alpha1client.Clientset
 	if len(tcrds) > 0 {
@@ -245,3 +249,117 @@ func TestShipwrightBuildReconciler_Reconcile(t *testing.T) {
 		})
 	}
 }
+
+func TestShipwrightBuildReconciler_OperandReadiness(t *testing.T) {
+	g := o.NewGomegaWithT(t)
+
+	// ShipwrightBuild object
+	b := &v1alpha1.ShipwrightBuild{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "name",
+			Namespace: "default",
+		},
+		Spec: v1alpha1.ShipwrightBuildSpec{
+			TargetNamespace: "namespace",
+		},
+		Status: v1alpha1.ShipwrightBuildStatus{
+			Conditions: []metav1.Condition{
+				{
+					Type:   ConditionReady,
+					Status: metav1.ConditionTrue,
+				},
+			},
+		},
+	}
+
+	// Mock TektonConfig to simulate Tekton Operator installation
+	tektonConfig := &tektonoperatorv1alpha1.TektonConfig{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "config",
+		},
+		Status: tektonoperatorv1alpha1.TektonConfigStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{
+					{
+						Type:    ConditionReady,
+						Status:  corev1.ConditionFalse,
+						Reason:  "Installed",
+						Message: "TektonConfig is not ready",
+					},
+				},
+			},
+		},
+	}
+	// Preload the fake client with a valid ClusterBuildStrategy to pass buildstrategy reconciliation
+	cbs := &buildv1alpha1.ClusterBuildStrategy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "buildah",
+		},
+		Spec: buildv1alpha1.BuildStrategySpec{
+			BuildSteps: []buildv1alpha1.BuildStep{
+				{
+					Container: corev1.Container{
+						Name:  "build-step",
+						Image: "quay.io/buildah/stable",
+					},
+				},
+			},
+		},
+	}
+
+	// Prepare cr
+	crd1 := &crdv1.CustomResourceDefinition{}
+	crd1.Name = "taskruns.tekton.dev"
+	crd2 := &crdv1.CustomResourceDefinition{}
+	crd2.Name = "tektonconfigs.operator.tekton.dev"
+	crd2.Labels = map[string]string{"operator.tekton.dev/release": common.TektonOpMinSupportedVersion}
+	crd3 := &crdv1.CustomResourceDefinition{}
+	crd3.Name = "clusterbuildstrategies.shipwright.io"
+	crds := []*crdv1.CustomResourceDefinition{crd1, crd2, crd3}
+
+	// Bootstrap the reconciler with the mock objects
+	c, _, _, r := bootstrapShipwrightBuildReconciler(t, b, nil, crds)
+
+	// Inject a pre-created valid tektonconfig
+	_, err := r.TektonOperatorClient.TektonConfigs().Create(context.TODO(), tektonConfig, metav1.CreateOptions{})
+	g.Expect(err).To(o.BeNil())
+
+	// Verify creation of tektonconfig
+	cfg, err := r.TektonOperatorClient.TektonConfigs().Get(context.TODO(), "config", metav1.GetOptions{})
+	g.Expect(err).To(o.BeNil())
+	g.Expect(cfg.Name).To(o.Equal("config"))
+	g.Expect(cfg.Status.Conditions[0].Type).To(o.Equal(apis.ConditionReady))
+
+	// Simulate reconciliation
+	namespacedName := types.NamespacedName{Namespace: "default", Name: "name"}
+	req := reconcile.Request{NamespacedName: namespacedName}
+	res, err := r.Reconcile(context.TODO(), req)
+	g.Expect(err).To(o.BeNil())
+	g.Expect(res.Requeue).To(o.BeTrue(), "Reconciliation should requeue when TektonConfig is not ready")
+
+	// Verify that the ShipwrightBuild is marked as not ready
+	updated := &v1alpha1.ShipwrightBuild{}
+	err = c.Get(context.TODO(), req.NamespacedName, updated)
+	g.Expect(err).To(o.BeNil())
+	g.Expect(updated.Status.IsReady()).To(o.BeFalse(), "ShipwrightBuild should not be ready when TektonConfig is not ready")
+
+	// Simulate TektonConfig becoming ready
+	tektonConfig.Status.Conditions[0].Status = corev1.ConditionTrue
+	tektonConfig.Status.Conditions[0].Reason = "Installed"
+	tektonConfig.Status.Conditions[0].Message = "TektonConfig is now ready"
+	_, err = r.TektonOperatorClient.TektonConfigs().Update(context.TODO(), tektonConfig, metav1.UpdateOptions{})
+	g.Expect(err).To(o.BeNil())
+
+	// Inject a pre-created valid ClusterBuildStrategy
+	err = c.Create(context.TODO(), cbs)
+	g.Expect(err).To(o.BeNil())
+	// Trigger reconciliation again
+	res, err = r.Reconcile(context.TODO(), req)
+	g.Expect(err).To(o.BeNil())
+	g.Expect(res.Requeue).To(o.BeFalse(), "Should not requeue after TektonConfig is ready")
+
+	// Fetch and verify ShipwrightBuild is now ready
+	err = c.Get(context.TODO(), req.NamespacedName, updated)
+	g.Expect(err).To(o.BeNil())
+	g.Expect(updated.Status.IsReady()).To(o.BeTrue(), "ShipwrightBuild should be ready when TektonConfig is ready")
+}