refactor patrially enforced condition for dnspolicy

controllers/dnspolicy_status.go

@@ -19,6 +19,7 @@ package controllers
 import (
 	"context"
 	"errors"
+	"fmt"
 	"slices"
 	"strings"
 
@@ -34,6 +35,7 @@ import (
 
 	"github.com/kuadrant/kuadrant-operator/api/v1alpha1"
 	"github.com/kuadrant/kuadrant-operator/pkg/library/kuadrant"
+	"github.com/kuadrant/kuadrant-operator/pkg/library/utils"
 )
 
 var NegativePolarityConditions []string
@@ -82,55 +84,63 @@ func (r *DNSPolicyReconciler) calculateStatus(ctx context.Context, dnsPolicy *v1
 	}
 
 	recordsList := &kuadrantdnsv1alpha1.DNSRecordList{}
-	controlledRecords := &kuadrantdnsv1alpha1.DNSRecordList{}
 
 	var enforcedCondition *metav1.Condition
 	if err := r.Client().List(ctx, recordsList); err != nil {
 		enforcedCondition = kuadrant.EnforcedCondition(dnsPolicy, kuadrant.NewErrUnknown(dnsPolicy.Kind(), err), false)
 	} else {
+		// leave only records controlled by the policy
+		recordsList.Items = utils.Filter(recordsList.Items, func(record kuadrantdnsv1alpha1.DNSRecord) bool {
+			for _, reference := range record.GetOwnerReferences() {
+				if reference.Controller != nil && *reference.Controller && reference.Name == dnsPolicy.Name && reference.UID == dnsPolicy.UID {
+					return true
+				}
+			}
+			return false
+		})
+
 		enforcedCondition = r.enforcedCondition(recordsList, dnsPolicy)
 	}
 
 	meta.SetStatusCondition(&newStatus.Conditions, *enforcedCondition)
-
-	for _, record := range recordsList.Items {
-		for _, reference := range record.GetOwnerReferences() {
-			if reference.Controller != nil && *reference.Controller && reference.Name == dnsPolicy.Name && reference.UID == dnsPolicy.UID {
-				controlledRecords.Items = append(controlledRecords.Items, record)
-			}
-		}
-	}
-
-	propagateRecordConditions(controlledRecords, newStatus)
+	propagateRecordConditions(recordsList, newStatus)
 
 	return newStatus
 }
 
 func (r *DNSPolicyReconciler) enforcedCondition(recordsList *kuadrantdnsv1alpha1.DNSRecordList, dnsPolicy *v1alpha1.DNSPolicy) *metav1.Condition {
-	var controlled bool
-	for _, record := range recordsList.Items {
-		// check that DNS record is controller by this policy
-		for _, reference := range record.GetOwnerReferences() {
-			if reference.Controller != nil && *reference.Controller && reference.Name == dnsPolicy.Name && reference.UID == dnsPolicy.UID {
-				controlled = true
-				// if at least one record not ready the policy is not enforced
-				for _, condition := range record.Status.Conditions {
-					if condition.Type == string(kuadrantdnsv1alpha1.ConditionTypeReady) && condition.Status == metav1.ConditionFalse {
-						return kuadrant.EnforcedCondition(dnsPolicy, nil, false)
-					}
-				}
-				break
+	// there are no controlled DNS records present
+	if len(recordsList.Items) == 0 {
+		return kuadrant.EnforcedCondition(dnsPolicy, kuadrant.NewErrUnknown(dnsPolicy.Kind(), errors.New("policy is not enforced on any DNSRecord: no routes attached for listeners")), false)
+	}
+
+	// filter not ready records
+	notReadyRecords := utils.Filter(recordsList.Items, func(record kuadrantdnsv1alpha1.DNSRecord) bool {
+		for _, condition := range record.Status.Conditions {
+			if condition.Type == string(kuadrantdnsv1alpha1.ConditionTypeReady) && condition.Status == metav1.ConditionFalse {
+				return true
 			}
 		}
+		return false
+	})
+
+	// none of the records are ready
+	if len(notReadyRecords) == len(recordsList.Items) {
+		return kuadrant.EnforcedCondition(dnsPolicy, kuadrant.NewErrUnknown(dnsPolicy.Kind(), errors.New("policy is not enforced on any DNSRecord: not a single DNSRecord is ready")), false)
 	}
 
-	// at least one DNS record is controlled by the policy
-	// and all controlled records are accepted
-	if controlled {
-		return kuadrant.EnforcedCondition(dnsPolicy, nil, true)
+	// some of the records are not ready
+	if len(notReadyRecords) > 0 {
+		additionalMessage := ". Not ready DNSRecords are: "
+		for _, record := range notReadyRecords {
+			additionalMessage += fmt.Sprintf("%s ", record.Name)
+		}
+		cond := kuadrant.EnforcedCondition(dnsPolicy, nil, false)
+		cond.Message += additionalMessage
+		return cond
 	}
-	// there are no controlled DNS records present
-	return kuadrant.EnforcedCondition(dnsPolicy, kuadrant.NewErrUnknown(dnsPolicy.Kind(), errors.New("policy is not enforced on any dns record: no routes attached for listeners")), false)
+	// all records are ready
+	return kuadrant.EnforcedCondition(dnsPolicy, nil, true)
 }
 
 func propagateRecordConditions(records *kuadrantdnsv1alpha1.DNSRecordList, policyStatus *v1alpha1.DNSPolicyStatus) {

tests/common/dnspolicy/dnspolicy_controller_single_cluster_test.go

@@ -24,7 +24,6 @@ import (
 
 	"github.com/kuadrant/kuadrant-operator/api/v1alpha1"
 	"github.com/kuadrant/kuadrant-operator/pkg/common"
-	"github.com/kuadrant/kuadrant-operator/pkg/library/kuadrant"
 	"github.com/kuadrant/kuadrant-operator/pkg/library/utils"
 	"github.com/kuadrant/kuadrant-operator/tests"
 )
@@ -170,21 +169,6 @@ var _ = Describe("DNSPolicy Single Cluster", func() {
 		})
 
 		It("should create dns records", func(ctx SpecContext) {
-
-			Eventually(func(g Gomega, ctx context.Context) {
-
-				g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(dnsPolicy), dnsPolicy)).To(Succeed())
-				g.Expect(dnsPolicy.Status.Conditions).To(
-					ContainElement(MatchFields(IgnoreExtras, Fields{
-						"Type":    Equal(string(kuadrant.PolicyConditionEnforced)),
-						"Status":  Equal(metav1.ConditionTrue),
-						"Reason":  Equal(string(kuadrant.PolicyReasonEnforced)),
-						"Message": Equal("DNSPolicy has been partially enforced"),
-					})),
-				)
-
-			}, tests.TimeoutMedium, tests.RetryIntervalMedium, ctx).Should(Succeed())
-
 			Eventually(func(g Gomega, ctx context.Context) {
 				recordList := &kuadrantdnsv1alpha1.DNSRecordList{}
 				err := k8sClient.List(ctx, recordList, &client.ListOptions{Namespace: testNamespace})