Update HTTPRoutePolicy status on resource deletion

Add logic to update HTTPRoutePolicy status when associated Ingress or HTTPRoute resources are deleted. Introduce new methods to handle status updates and remove ancestor references, along with corresponding e2e tests for ingress and gateway API scenarios.

Author: dspo

internal/controller/httproute_controller.go

@@ -97,6 +97,9 @@ func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	hr := new(gatewayv1.HTTPRoute)
 	if err := r.Get(ctx, req.NamespacedName, hr); err != nil {
 		if client.IgnoreNotFound(err) == nil {
+			if err := r.updateHTTPRouteStatusOnDeleting(req.NamespacedName); err != nil {
+				return ctrl.Result{}, err
+			}
 			hr.Namespace = req.Namespace
 			hr.Name = req.Name
 

internal/controller/httproutepolicy.go

@@ -2,8 +2,9 @@ package controller
 
 import (
 	"context"
-	"encoding/json"
+	"slices"
 
+	"github.com/go-logr/logr"
 	networkingv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -41,8 +42,6 @@ func (r *HTTPRouteReconciler) processHTTPRoutePolicies(tctx *provider.TranslateC
 			}
 		}
 	}
-	data, _ := json.MarshalIndent(conflicts, "", "  ")
-	r.Log.Info("conflicts policies", "data", string(data))
 
 	for i := range list.Items {
 		var (
@@ -67,6 +66,39 @@ func (r *HTTPRouteReconciler) processHTTPRoutePolicies(tctx *provider.TranslateC
 	return nil
 }
 
+func (r *HTTPRouteReconciler) updateHTTPRouteStatusOnDeleting(nn types.NamespacedName) error {
+	var (
+		list v1alpha1.HTTPRoutePolicyList
+		key  = indexer.GenIndexKeyWithGK(gatewayv1.GroupName, "HTTPRoute", nn.Namespace, nn.Name)
+	)
+	if err := r.List(context.Background(), &list, client.MatchingFields{indexer.PolicyTargetRefs: key}); err != nil {
+		return err
+	}
+	var (
+		objs       = make(map[types.NamespacedName]struct{})
+		parentRefs []gatewayv1.ParentReference
+	)
+	// collect all parentRefs
+	for _, policy := range list.Items {
+		for _, ref := range policy.Spec.TargetRefs {
+			var obj = types.NamespacedName{Namespace: policy.GetNamespace(), Name: string(ref.Name)}
+			if _, ok := objs[obj]; !ok {
+				objs[obj] = struct{}{}
+
+				var httpRoute gatewayv1.HTTPRoute
+				if err := r.Get(context.Background(), obj, &httpRoute); err != nil {
+					continue
+				}
+				parentRefs = append(parentRefs, httpRoute.Spec.ParentRefs...)
+			}
+		}
+	}
+	// delete AncestorRef which is not exist in the all parentRefs for each policy
+	updateDeleteAncestors(r.Client, r.Log, list.Items, parentRefs)
+
+	return nil
+}
+
 func (r *IngressReconciler) processHTTPRoutePolicies(tctx *provider.TranslateContext, ingress *networkingv1.Ingress) error {
 	var (
 		list v1alpha1.HTTPRoutePolicyList
@@ -102,6 +134,47 @@ func (r *IngressReconciler) processHTTPRoutePolicies(tctx *provider.TranslateCon
 	return nil
 }
 
+func (r *IngressReconciler) updateHTTPRoutePolicyStatusOnDeleting(nn types.NamespacedName) error {
+	var (
+		list v1alpha1.HTTPRoutePolicyList
+		key  = indexer.GenIndexKeyWithGK(networkingv1.GroupName, "Ingress", nn.Namespace, nn.Name)
+	)
+	if err := r.List(context.Background(), &list, client.MatchingFields{indexer.PolicyTargetRefs: key}); err != nil {
+		return err
+	}
+	var (
+		objs       = make(map[types.NamespacedName]struct{})
+		parentRefs []gatewayv1.ParentReference
+	)
+	// collect all parentRefs
+	for _, policy := range list.Items {
+		for _, ref := range policy.Spec.TargetRefs {
+			var obj = types.NamespacedName{Namespace: policy.GetNamespace(), Name: string(ref.Name)}
+			if _, ok := objs[obj]; !ok {
+				objs[obj] = struct{}{}
+
+				var ingress networkingv1.Ingress
+				if err := r.Get(context.Background(), obj, &ingress); err != nil {
+					continue
+				}
+				ingressClass, err := r.getIngressClass(&ingress)
+				if err != nil {
+					continue
+				}
+				parentRefs = append(parentRefs, gatewayv1.ParentReference{
+					Group: ptr.To(gatewayv1.Group(ingressClass.GroupVersionKind().Group)),
+					Kind:  ptr.To(gatewayv1.Kind("IngressClass")),
+					Name:  gatewayv1.ObjectName(ingressClass.Name),
+				})
+			}
+		}
+	}
+	// delete AncestorRef which is not exist in the all parentRefs
+	updateDeleteAncestors(r.Client, r.Log, list.Items, parentRefs)
+
+	return nil
+}
+
 func modifyHTTPRoutePolicyStatus(parentRefs []gatewayv1.ParentReference, policy *v1alpha1.HTTPRoutePolicy, status bool, reason, message string) {
 	condition := metav1.Condition{
 		Type:               string(v1alpha2.PolicyConditionAccepted),
@@ -141,3 +214,20 @@ func findPolicyWhichTargetRefTheRule(ruleName *gatewayv1.SectionName, kind strin
 	}
 	return
 }
+
+func updateDeleteAncestors(client client.Client, logger logr.Logger, policies []v1alpha1.HTTPRoutePolicy, parentRefs []gatewayv1.ParentReference) {
+	for i := range policies {
+		policy := policies[i]
+		length := len(policy.Status.Ancestors)
+		policy.Status.Ancestors = slices.DeleteFunc(policy.Status.Ancestors, func(status v1alpha2.PolicyAncestorStatus) bool {
+			return !slices.ContainsFunc(parentRefs, func(ref gatewayv1.ParentReference) bool {
+				return parentRefValueEqual(status.AncestorRef, ref)
+			})
+		})
+		if length != len(policy.Status.Ancestors) {
+			if err := client.Status().Update(context.Background(), &policy); err != nil {
+				logger.Error(err, "failed to update HTTPRoutePolicy status")
+			}
+		}
+	}
+}

internal/controller/ingress_controller.go

@@ -97,6 +97,10 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	ingress := new(networkingv1.Ingress)
 	if err := r.Get(ctx, req.NamespacedName, ingress); err != nil {
 		if client.IgnoreNotFound(err) == nil {
+			if err := r.updateHTTPRoutePolicyStatusOnDeleting(req.NamespacedName); err != nil {
+				return ctrl.Result{}, err
+			}
+
 			// Ingress was deleted, clean up corresponding resources
 			ingress.Namespace = req.Namespace
 			ingress.Name = req.Name

internal/controller/policies.go

@@ -2,20 +2,18 @@ package controller
 
 import (
 	"fmt"
-	"slices"
-
-	"k8s.io/utils/ptr"
-	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
-	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
+	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 
 	"github.com/api7/api7-ingress-controller/api/v1alpha1"
 	"github.com/api7/api7-ingress-controller/internal/controller/config"
@@ -192,16 +190,6 @@ func SetAncestorStatus(status *v1alpha1.PolicyStatus, ancestorStatus gatewayv1al
 	return true
 }
 
-func DeleteAncestors(status *v1alpha1.PolicyStatus, parentRefs []gatewayv1.ParentReference) bool {
-	var length = len(status.Ancestors)
-	for _, parentRef := range parentRefs {
-		status.Ancestors = slices.DeleteFunc(status.Ancestors, func(status gatewayv1alpha2.PolicyAncestorStatus) bool {
-			return parentRefValueEqual(parentRef, status.AncestorRef)
-		})
-	}
-	return length != len(status.Ancestors)
-}
-
 func parentRefValueEqual(a, b gatewayv1.ParentReference) bool {
 	return ptr.Equal(a.Group, b.Group) &&
 		ptr.Equal(a.Kind, b.Kind) &&

test/e2e/gatewayapi/httproute.go

@@ -843,13 +843,19 @@ spec:
 			}).WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(Equal(http.StatusOK))
 		})
 
-		PIt("HTTPRoutePolicy status changes on HTTPRoute deleting", func() {
+		It("HTTPRoutePolicy status changes on HTTPRoute deleting", func() {
 			By("create HTTPRoute")
 			ResourceApplied("HTTPRoute", "httpbin", varsRoute, 1)
 
 			By("create HTTPRoutePolicy")
 			ResourceApplied("HTTPRoutePolicy", "http-route-policy-0", httpRoutePolicy, 1)
 
+			Eventually(func() string {
+				spec, err := s.GetResourceYaml("HTTPRoutePolicy", "http-route-policy-0")
+				Expect(err).NotTo(HaveOccurred(), "getting HTTPRoutePolicy")
+				return spec
+			}).WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(ContainSubstring("type: Accepted"))
+
 			By("access dataplane to check the HTTPRoutePolicy")
 			s.NewAPISIXClient().
 				GET("/get").

test/e2e/ingress/ingress.go

@@ -637,5 +637,46 @@ spec:
 			}).
 				WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(Equal(http.StatusOK))
 		})
+
+		It("HTTPRoutePolicy status changes on Ingress deleting", func() {
+			By("create Ingress")
+			err := s.CreateResourceFromString(ingressSpec)
+			Expect(err).NotTo(HaveOccurred(), "creating Ingress")
+
+			By("create HTTPRoutePolicy")
+			err = s.CreateResourceFromString(httpRoutePolicySpec0)
+			Expect(err).NotTo(HaveOccurred(), "creating HTTPRoutePolicy")
+			Eventually(func() string {
+				spec, err := s.GetResourceYaml("HTTPRoutePolicy", "http-route-policy-0")
+				Expect(err).NotTo(HaveOccurred(), "HTTPRoutePolicy status should be True")
+				return spec
+			}).
+				WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(ContainSubstring(`status: "True"`))
+
+			By("request the route without vars should be Not Found")
+			Eventually(func() int {
+				return s.NewAPISIXClient().GET("/get").WithHost("example.com").Expect().Raw().StatusCode
+			}).
+				WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(Equal(http.StatusNotFound))
+
+			By("request the route with the correct vars should be OK")
+			s.NewAPISIXClient().GET("/get").WithHost("example.com").
+				WithHeader("X-HRP-Name", "http-route-policy-0").Expect().Status(http.StatusOK)
+
+			By("delete ingress")
+			err = s.DeleteResource("Ingress", "default")
+			Expect(err).NotTo(HaveOccurred(), "delete Ingress")
+			Eventually(func() int {
+				return s.NewAPISIXClient().GET("/get").WithHost("example.com").
+					WithHeader("X-HRP-Name", "http-route-policy-0").Expect().Raw().StatusCode
+			}).
+				WithTimeout(8 * time.Second).ProbeEvery(time.Second).Should(Equal(http.StatusNotFound))
+
+			Eventually(func() string {
+				spec, err := s.GetResourceYaml("HTTPRoutePolicy", "http-route-policy-0")
+				Expect(err).NotTo(HaveOccurred(), "getting HTTPRoutePolicy")
+				return spec
+			}).WithTimeout(8 * time.Second).ProbeEvery(time.Second).ShouldNot(ContainSubstring("ancestorRef:"))
+		})
 	})
 })