feat: create new ttr for tiertemplate updates

controllers/nstemplatetier/mapper.go

@@ -0,0 +1,50 @@
+package nstemplatetier
+
+import (
+	"context"
+
+	toolchainv1alpha1 "github.com/codeready-toolchain/api/api/v1alpha1"
+
+	"k8s.io/apimachinery/pkg/types"
+	ctrl "sigs.k8s.io/controller-runtime"
+	runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+var mapperLog = ctrl.Log.WithName("MapTierTemplateToNSTemplateTier")
+
+// MapTierTemplateToNSTemplateTier maps the TierTemplate to all the NSTemplateTiers that are referencing it.
+func MapTierTemplateToNSTemplateTier(cl runtimeclient.Client) func(ctx context.Context, object runtimeclient.Object) []reconcile.Request {
+	return func(ctx context.Context, obj runtimeclient.Object) []reconcile.Request {
+		logger := mapperLog.WithValues("object-name", obj.GetName(), "object-kind", obj.GetObjectKind())
+		nsTmplTierList := &toolchainv1alpha1.NSTemplateTierList{}
+		err := cl.List(context.TODO(), nsTmplTierList,
+			runtimeclient.InNamespace(obj.GetNamespace()))
+		if err != nil {
+			logger.Error(err, "unable to list NSTemplateTier")
+			return []reconcile.Request{}
+		}
+		if len(nsTmplTierList.Items) == 0 {
+			logger.Info("no NSTemplateTier found for an object")
+			return []reconcile.Request{}
+		}
+
+		req := make([]reconcile.Request, 0, len(nsTmplTierList.Items))
+		for _, item := range nsTmplTierList.Items {
+			if len(item.Status.Revisions) == 0 {
+				// this tier doesn't use the template
+				continue
+			}
+			if _, inUse := item.Status.Revisions[obj.GetName()]; inUse {
+				// the tier uses this template
+				req = append(req, reconcile.Request{
+					NamespacedName: types.NamespacedName{
+						Namespace: item.Namespace,
+						Name:      item.Name,
+					},
+				})
+			}
+		}
+		return req
+	}
+}

controllers/nstemplatetier/mapper_test.go

@@ -0,0 +1,95 @@
+package nstemplatetier_test
+
+import (
+	"context"
+	"testing"
+
+	toolchainv1alpha1 "github.com/codeready-toolchain/api/api/v1alpha1"
+	"github.com/codeready-toolchain/host-operator/controllers/nstemplatetier"
+	tiertest "github.com/codeready-toolchain/host-operator/test/nstemplatetier"
+	"github.com/codeready-toolchain/toolchain-common/pkg/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+func TestMapTierTemplateToNSTemplateTier(t *testing.T) {
+	t.Run("should return the only NSTemplateTier referencing the TierTemplate", func(t *testing.T) {
+		// given
+		base1nsTier := tiertest.Base1nsTier(t, tiertest.CurrentBase1nsTemplates)
+		prepareTierWithRevisions(base1nsTier)
+		// and we have a tier without the revisions
+		otherTier := tiertest.AppStudioEnvTier(t, tiertest.AppStudioEnvTemplates)
+		cl := test.NewFakeClient(t, base1nsTier, otherTier)
+
+		// when
+		// for the simplicity of the test, we only try to map one tiertemplate
+		clusterResourceTierTemplate := createTierTemplate(t, "clusterresources", nil, base1nsTier.Name)
+		requests := nstemplatetier.MapTierTemplateToNSTemplateTier(cl)(context.TODO(), clusterResourceTierTemplate)
+
+		// then
+		require.Len(t, requests, 1)
+		assert.Contains(t, requests, newRequest(base1nsTier.Name))
+	})
+
+	t.Run("should return two NSTemplateTier when both are referencing the same TierTemplate", func(t *testing.T) {
+		// given
+		base1nsTier := tiertest.Base1nsTier(t, tiertest.CurrentBase1nsTemplates)
+		prepareTierWithRevisions(base1nsTier)
+		// we update the other tier to use the same revisions
+		otherTier := tiertest.AppStudioEnvTier(t, tiertest.AppStudioEnvTemplates)
+		prepareTierWithRevisions(otherTier)
+		cl := test.NewFakeClient(t, base1nsTier, otherTier)
+
+		// when
+		// for the simplicity of the test we only try to map one tiertemplate
+		clusterResourceTierTemplate := createTierTemplate(t, "clusterresources", nil, base1nsTier.Name)
+		requests := nstemplatetier.MapTierTemplateToNSTemplateTier(cl)(context.TODO(), clusterResourceTierTemplate)
+
+		// then
+		require.Len(t, requests, 2)
+		assert.Contains(t, requests, newRequest(base1nsTier.Name))
+		assert.Contains(t, requests, newRequest(otherTier.Name))
+	})
+
+	t.Run("should return no NSTemplateTier when they don't use the TierTemplate", func(t *testing.T) {
+		// given
+		// both tiers are without revisions
+		base1nsTier := tiertest.Base1nsTier(t, tiertest.CurrentBase1nsTemplates)
+		otherTier := tiertest.AppStudioEnvTier(t, tiertest.AppStudioEnvTemplates)
+		prepareTierWithRevisions(otherTier)
+		delete(otherTier.Status.Revisions, "base1ns-clusterresources-123456new")
+		cl := test.NewFakeClient(t, base1nsTier, otherTier)
+
+		// when
+		// for the simplicity of the test, we only try to map one tiertemplate
+		clusterResourceTierTemplate := createTierTemplate(t, "clusterresources", nil, base1nsTier.Name)
+		requests := nstemplatetier.MapTierTemplateToNSTemplateTier(cl)(context.TODO(), clusterResourceTierTemplate)
+
+		// then
+		require.Empty(t, requests)
+	})
+}
+
+func prepareTierWithRevisions(tier *toolchainv1alpha1.NSTemplateTier) {
+	initialRevisions := map[string]string{
+		"base1ns-admin-123456new":            "base1ns-admin-123456new-abcd",
+		"base1ns-clusterresources-123456new": "base1ns-clusterresources-123456new-abcd",
+		"base1ns-code-123456new":             "base1ns-code-123456new-abcd",
+		"base1ns-dev-123456new":              "base1ns-dev-123456new-abcd",
+		"base1ns-edit-123456new":             "`base1ns-edit-123456new-abcd",
+		"base1ns-stage-123456new":            "base1ns-stage-123456new-abcd",
+		"base1ns-viewer-123456new":           "base1ns-viewer-123456new-abcd",
+	}
+	tier.Status.Revisions = initialRevisions
+}
+
+func newRequest(name string) reconcile.Request {
+	return reconcile.Request{
+		NamespacedName: types.NamespacedName{
+			Namespace: test.HostOperatorNs,
+			Name:      name,
+		},
+	}
+}

controllers/nstemplatetier/nstemplatetier_controller.go

@@ -3,13 +3,15 @@ package nstemplatetier
 import (
 	"context"
 	"fmt"
+	"reflect"
 	"time"
 
 	toolchainv1alpha1 "github.com/codeready-toolchain/api/api/v1alpha1"
 	"github.com/codeready-toolchain/host-operator/controllers/toolchainconfig"
 	"github.com/redhat-cop/operator-utils/pkg/util"
 	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/builder"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -26,6 +28,8 @@ import (
 func (r *Reconciler) SetupWithManager(mgr manager.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&toolchainv1alpha1.NSTemplateTier{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})).
+		Watches(&toolchainv1alpha1.TierTemplate{},
+			handler.EnqueueRequestsFromMapFunc(MapTierTemplateToNSTemplateTier(r.Client))).
 		Complete(r)
 }
 
@@ -136,30 +140,42 @@ func (r *Reconciler) ensureTTRforTemplate(ctx context.Context, nsTmplTier *toolc
 		return false, "", nil
 	}
 
-	if tierTemplateRevisionName, found := nsTmplTier.Status.Revisions[tierTemplate.GetName()]; found {
-		logger.Info("TTR set in the status.revisions for tiertemplate", "tierTemplate.Name", tierTemplate.GetName(), "ttr.Name", tierTemplateRevisionName)
-		var tierTemplateRevision toolchainv1alpha1.TierTemplateRevision
-		if err := r.Client.Get(ctx, types.NamespacedName{Namespace: nsTmplTier.GetNamespace(), Name: tierTemplateRevisionName}, &tierTemplateRevision); err != nil {
-			if errors.IsNotFound(err) {
-				// no tierTemplateRevision CR was found,
-				logger.Info("TTR CR not found", "tierTemplateRevision.Name", tierTemplateRevisionName)
-				// let's create one
-				ttrName, err := r.createNewTierTemplateRevision(ctx, nsTmplTier, tierTemplate)
-				return true, ttrName, err
-			} else {
-				// something wrong happened
-				return false, "", err
-			}
-		}
-		// TODO compare TierTemplate content with TTR content
-		// if the TierTemplate has changes we need to create new TTR
-	} else {
+	tierTemplateRevisionName, found := nsTmplTier.Status.Revisions[tierTemplate.GetName()]
+	if !found {
 		// no revision was set for this TierTemplate CR, let's create a TTR for it
 		ttrName, err := r.createNewTierTemplateRevision(ctx, nsTmplTier, tierTemplate)
 		return true, ttrName, err
 	}
-	// nothing changed
-	return false, "", nil
+
+	logger.Info("TTR set in the status.revisions for tiertemplate", "tierTemplate.Name", tierTemplate.GetName(), "ttr.Name", tierTemplateRevisionName)
+	var tierTemplateRevision toolchainv1alpha1.TierTemplateRevision
+	if err := r.Client.Get(ctx, types.NamespacedName{Namespace: nsTmplTier.GetNamespace(), Name: tierTemplateRevisionName}, &tierTemplateRevision); err != nil {
+		if errors.IsNotFound(err) {
+			// no tierTemplateRevision CR was found,
+			logger.Info("TTR CR not found", "tierTemplateRevision.Name", tierTemplateRevisionName)
+			// let's create one
+			ttrName, err := r.createNewTierTemplateRevision(ctx, nsTmplTier, tierTemplate)
+			return true, ttrName, err
+		} else {
+			// something wrong happened
+			return false, "", err
+		}
+	}
+	// if the TierTemplate has changes we need to create new TTR
+	// if the TierTemplate objects are the same as they are in the TTR
+	// and the parameters are the same, too, we don't have to create
+	// a new revision.
+	if reflect.DeepEqual(tierTemplate.Spec.TemplateObjects, tierTemplateRevision.Spec.TemplateObjects) && reflect.DeepEqual(nsTmplTier.Spec.Parameters, tierTemplateRevision.Spec.Parameters) {
+		return false, tierTemplateRevisionName, nil
+	}
+
+	// there are some changes, a new TTR is needed
+	ttrName, err := r.createNewTierTemplateRevision(ctx, nsTmplTier, tierTemplate)
+	if err != nil {
+		return false, "", err
+	}
+	return true, ttrName, nil
+
 }
 
 func (r *Reconciler) createNewTierTemplateRevision(ctx context.Context, nsTmplTier *toolchainv1alpha1.NSTemplateTier, tierTemplate *toolchainv1alpha1.TierTemplate) (string, error) {