fix: status should not be recorded when ingressclass does not match

Author: AlinsRan

internal/controller/apisixconsumer_controller.go

@@ -89,22 +89,22 @@ func (r *ApisixConsumerReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 		ingressClass *networkingv1.IngressClass
 		err          error
 	)
-	defer func() {
-		r.updateStatus(ac, err)
-	}()
 
-	ingressClass, err = GetIngressClass(tctx, r.Client, r.Log, ac.Spec.IngressClassName, r.ICGV.String())
-	if err != nil {
-		r.Log.Error(err, "failed to get IngressClass")
-		return ctrl.Result{}, err
+	if ingressClass, err = GetIngressClass(tctx, r.Client, r.Log, ac.Spec.IngressClassName, r.ICGV.String()); err != nil {
+		r.Log.V(1).Info("no matching IngressClass available",
+			"ingressClassName", ac.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
 	}
+	defer r.updateStatus(ac, err)
 
 	if err = ProcessIngressClassParameters(tctx, r.Client, r.Log, ac, ingressClass); err != nil {
 		r.Log.Error(err, "failed to process IngressClass parameters", "ingressClass", ingressClass.Name)
 		return ctrl.Result{}, err
 	}
 
 	if err = r.processSpec(ctx, tctx, ac); err != nil {
+		r.Log.Error(err, "failed to process ApisixConsumer spec", "ApisixConsumer", ac)
 		return ctrl.Result{}, err
 	}
 

internal/controller/apisixglobalrule_controller.go

@@ -81,16 +81,18 @@ func (r *ApisixGlobalRuleReconciler) Reconcile(ctx context.Context, req ctrl.Req
 		return ctrl.Result{}, err
 	}
 
-	r.Log.Info("reconciling global rule", "globalrule", globalRule.Name)
+	r.Log.V(1).Info("reconciling ApisixGlobalRule", "obj", globalRule)
 
 	// create a translate context
 	tctx := provider.NewDefaultTranslateContext(ctx)
 
 	// get the ingress class
 	ingressClass, err := GetIngressClass(tctx, r.Client, r.Log, globalRule.Spec.IngressClassName, r.ICGV.String())
 	if err != nil {
-		r.Log.Error(err, "failed to get IngressClass")
-		return ctrl.Result{}, err
+		r.Log.V(1).Info("no matching IngressClass available",
+			"ingressClassName", globalRule.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
 	}
 
 	// process IngressClass parameters if they reference GatewayProxy

internal/controller/apisixpluginconfig_controller.go

@@ -30,6 +30,7 @@ import (
 
 	apiv2 "github.com/apache/apisix-ingress-controller/api/v2"
 	"github.com/apache/apisix-ingress-controller/internal/controller/status"
+	"github.com/apache/apisix-ingress-controller/internal/provider"
 	"github.com/apache/apisix-ingress-controller/internal/utils"
 )
 
@@ -57,6 +58,15 @@ func (r *ApisixPluginConfigReconciler) Reconcile(ctx context.Context, req ctrl.R
 	if err := r.Get(ctx, req.NamespacedName, &pc); err != nil {
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
+	tctx := provider.NewDefaultTranslateContext(ctx)
+
+	_, err := GetIngressClass(tctx, r.Client, r.Log, pc.Spec.IngressClassName, r.ICGV.String())
+	if err != nil {
+		r.Log.V(1).Info("no matching IngressClass available",
+			"ingressClassName", pc.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
+	}
 
 	// Only update status
 	r.updateStatus(&pc, nil)

internal/controller/apisixroute_controller.go

@@ -150,18 +150,20 @@ func (r *ApisixRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		ic   *networkingv1.IngressClass
 		err  error
 	)
-	defer func() {
-		r.updateStatus(&ar, err)
-	}()
 
 	if ic, err = GetIngressClass(tctx, r.Client, r.Log, ar.Spec.IngressClassName, r.ICGV.String()); err != nil {
-		return ctrl.Result{}, err
+		r.Log.V(1).Info("no matching IngressClass available",
+			"ingressClassName", ar.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
 	}
+	defer r.updateStatus(&ar, err)
+
 	if err = ProcessIngressClassParameters(tctx, r.Client, r.Log, &ar, ic); err != nil {
 		return ctrl.Result{}, err
 	}
 	if err = r.processApisixRoute(ctx, tctx, &ar); err != nil {
-		return ctrl.Result{}, err
+		return ctrl.Result{}, nil
 	}
 	if err = r.Provider.Update(ctx, tctx, &ar); err != nil {
 		err = types.ReasonError{

internal/controller/apisixtls_controller.go

@@ -128,16 +128,10 @@ func (r *ApisixTlsReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	// get the ingress class
 	ingressClass, err := GetIngressClass(tctx, r.Client, r.Log, tls.Spec.IngressClassName, r.ICGV.String())
 	if err != nil {
-		r.Log.Error(err, "failed to get IngressClass")
-		r.updateStatus(&tls, metav1.Condition{
-			Type:               string(apiv2.ConditionTypeAccepted),
-			Status:             metav1.ConditionFalse,
-			ObservedGeneration: tls.Generation,
-			LastTransitionTime: metav1.Now(),
-			Reason:             string(apiv2.ConditionReasonInvalidSpec),
-			Message:            err.Error(),
-		})
-		return ctrl.Result{}, err
+		r.Log.V(1).Info("no matching IngressClass available, skip processing",
+			"ingressClassName", tls.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
 	}
 
 	// process IngressClass parameters if they reference GatewayProxy

internal/controller/apisixupstream_controller.go

@@ -29,6 +29,7 @@ import (
 
 	apiv2 "github.com/apache/apisix-ingress-controller/api/v2"
 	"github.com/apache/apisix-ingress-controller/internal/controller/status"
+	"github.com/apache/apisix-ingress-controller/internal/provider"
 	"github.com/apache/apisix-ingress-controller/internal/utils"
 )
 
@@ -57,6 +58,16 @@ func (r *ApisixUpstreamReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 
+	tctx := provider.NewDefaultTranslateContext(ctx)
+
+	_, err := GetIngressClass(tctx, r.Client, r.Log, au.Spec.IngressClassName, r.ICGV.String())
+	if err != nil {
+		r.Log.V(1).Info("no matching IngressClass available, skip processing",
+			"ingressClassName", au.Spec.IngressClassName,
+			"error", err.Error())
+		return ctrl.Result{}, nil
+	}
+
 	// Only update status
 	r.updateStatus(&au, nil)
 	return ctrl.Result{}, nil

test/e2e/crds/v2/status.go

@@ -110,6 +110,25 @@ spec:
     - name: non-existent-plugin
       enable: true
 `
+		const arWithInvalidIngressClass = `
+apiVersion: apisix.apache.org/v2
+kind: ApisixRoute
+metadata:
+  name: ar-with-invalid-ingressclass
+spec:
+  ingressClassName: ar-with-invalid-ingressclass
+  http:
+  - name: rule0
+    match:
+      hosts:
+      - httpbin
+      paths:
+      - /*
+    backends:
+    - serviceName: httpbin-service-e2e-test
+      servicePort: 80
+`
+
 		It("unknown plugin", func() {
 			if os.Getenv("PROVIDER_TYPE") == "apisix-standalone" {
 				Skip("apisix standalone does not validate unknown plugins")
@@ -258,5 +277,20 @@ spec:
 			Expect(route2.Status.Conditions[0].LastTransitionTime).To(Equal(route.Status.Conditions[0].LastTransitionTime),
 				"should not update the same status condition again")
 		})
+
+		It("IngressClass not found", func() {
+			err := s.CreateResourceFromString(arWithInvalidIngressClass)
+			Expect(err).NotTo(HaveOccurred(), "creating ApisixRoute with invalid IngressClass")
+
+			for range 10 {
+				output, _ := s.GetOutputFromString("ar", "default", "-o", "yaml")
+				Expect(output).ShouldNot(
+					Or(
+						ContainSubstring(`status: "True"`),
+						ContainSubstring(`status: "False"`),
+					),
+				)
+			}
+		})
 	})
 })