gatewayclass: Reconcile the oldest gatewayclass

When reconciling gatewayclasses in order to ensure the Istio CR, make sure to
use the oldest gatewayclass that has our controller name.

Before this commit, the controller behaved inconsistently:

- The controller's watch on gatewayclasses reconciled the specific gatewayclass
  that triggered the watch.

- The controller's watches on subscriptions, installplans, and istios reconciled
  the "openshift-default" gatewayclass.

This inconsistency caused several problems:

- If a gatewayclass existed with our controller name but none existed with the
  name "openshift-default", the controller logged spurious reconcile requests
  for, and failures to get, the "openshift-default" gatewayclass.

- If multiple gatewayclasses existed with our controller name, the controller
  tried to update the owner reference on the Istio CR every time the controller
  reconciled a gatewayclass other than the one in the owner reference.

Using the oldest gatewayclass solves these problems.

* pkg/operator/controller/gatewayclass/controller.go
(enqueueRequestForDefaultGatewayClassController): Rename...
(enqueueRequestForSomeGatewayClass): ...to this.  Delete the unused namespace
parameter.  Look up the oldest gatewayclass with our controller name, and return
a reconcile request for that gatewayclass.
(NewUnmanaged, Reconcile): Use enqueueRequestForSomeGatewayClass for all
watches.

Author: Miciah

pkg/operator/controller/gatewayclass/controller.go

@@ -15,6 +15,7 @@ import (
 
 	gatewayapiv1 "sigs.k8s.io/gateway-api/apis/v1"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
 
@@ -57,15 +58,15 @@ func NewUnmanaged(mgr manager.Manager, config Config) (controller.Controller, er
 	notIstioGatewayClass := predicate.NewPredicateFuncs(func(o client.Object) bool {
 		return o.GetName() != "istio"
 	})
-	if err := c.Watch(source.Kind[client.Object](operatorCache, &gatewayapiv1.GatewayClass{}, &handler.EnqueueRequestForObject{}, isOurGatewayClass, notIstioGatewayClass)); err != nil {
+	if err := c.Watch(source.Kind[client.Object](operatorCache, &gatewayapiv1.GatewayClass{}, reconciler.enqueueRequestForSomeGatewayClass(), isOurGatewayClass, notIstioGatewayClass)); err != nil {
 		return nil, err
 	}
 
 	isServiceMeshSubscription := predicate.NewPredicateFuncs(func(o client.Object) bool {
 		return o.GetName() == operatorcontroller.ServiceMeshOperatorSubscriptionName().Name
 	})
 	if err = c.Watch(source.Kind[client.Object](operatorCache, &operatorsv1alpha1.Subscription{},
-		enqueueRequestForDefaultGatewayClassController(config.OperandNamespace), isServiceMeshSubscription)); err != nil {
+		reconciler.enqueueRequestForSomeGatewayClass(), isServiceMeshSubscription)); err != nil {
 		return nil, err
 	}
 
@@ -86,7 +87,7 @@ func NewUnmanaged(mgr manager.Manager, config Config) (controller.Controller, er
 		installPlan := o.(*operatorsv1alpha1.InstallPlan)
 		return installPlan.Spec.Approved
 	})
-	if err := c.Watch(source.Kind[client.Object](operatorCache, &operatorsv1alpha1.InstallPlan{}, enqueueRequestForDefaultGatewayClassController(config.OperatorNamespace), isOurInstallPlan, predicate.Not(isInstallPlanApproved))); err != nil {
+	if err := c.Watch(source.Kind[client.Object](operatorCache, &operatorsv1alpha1.InstallPlan{}, reconciler.enqueueRequestForSomeGatewayClass(), isOurInstallPlan, predicate.Not(isInstallPlanApproved))); err != nil {
 		return nil, err
 	}
 
@@ -119,17 +120,48 @@ type reconciler struct {
 	startIstioWatch sync.Once
 }
 
-func enqueueRequestForDefaultGatewayClassController(namespace string) handler.EventHandler {
+// enqueueRequestForSomeGatewayClass enqueues a reconciliation request for the
+// gatewayclass that has the earliest creation timestamp and that specifies our
+// controller name.
+func (r *reconciler) enqueueRequestForSomeGatewayClass() handler.EventHandler {
 	return handler.EnqueueRequestsFromMapFunc(
-		func(ctx context.Context, a client.Object) []reconcile.Request {
-			return []reconcile.Request{
-				{
+		func(ctx context.Context, _ client.Object) []reconcile.Request {
+			requests := []reconcile.Request{}
+
+			var gatewayClasses gatewayapiv1.GatewayClassList
+			if err := r.cache.List(context.Background(), &gatewayClasses); err != nil {
+				log.Error(err, "Failed to list gatewayclasses")
+
+				return requests
+			}
+
+			var (
+				found  bool
+				oldest metav1.Time
+				name   string
+			)
+			for i := range gatewayClasses.Items {
+				if gatewayClasses.Items[i].Spec.ControllerName != operatorcontroller.OpenShiftGatewayClassControllerName {
+					continue
+				}
+
+				ctime := gatewayClasses.Items[i].CreationTimestamp
+				if !found || ctime.Before(&oldest) {
+					found, oldest, name = true, ctime, gatewayClasses.Items[i].Name
+				}
+			}
+
+			if found {
+				request := reconcile.Request{
 					NamespacedName: types.NamespacedName{
-						Namespace: namespace,
-						Name:      operatorcontroller.OpenShiftDefaultGatewayClassName,
+						Namespace: "", // GatewayClass is cluster-scoped.
+						Name:      name,
 					},
-				},
+				}
+				requests = append(requests, request)
 			}
+
+			return requests
 		},
 	)
 }
@@ -162,7 +194,7 @@ func (r *reconciler) Reconcile(ctx context.Context, request reconcile.Request) (
 			isOurIstio := predicate.NewPredicateFuncs(func(o client.Object) bool {
 				return o.GetName() == operatorcontroller.IstioName(r.config.OperandNamespace).Name
 			})
-			if err = gatewayClassController.Watch(source.Kind[client.Object](r.cache, &sailv1.Istio{}, enqueueRequestForDefaultGatewayClassController(r.config.OperandNamespace), isOurIstio)); err != nil {
+			if err = gatewayClassController.Watch(source.Kind[client.Object](r.cache, &sailv1.Istio{}, r.enqueueRequestForSomeGatewayClass(), isOurIstio)); err != nil {
 				log.Error(err, "failed to watch istios.sailoperator.io", "request", request)
 				errs = append(errs, err)
 			}