status: Add Gateway API objects to relatedObjects

This commit resolves NE-1277.

https://issues.redhat.com/browse/NE-1277

* pkg/operator/controller/status/controller.go (New): Add a watch for
subscriptions so that the status controller updates relatedObjects with the
OSSM subscription when it is added or removed.
(Config): Add GatewayAPIEnabled field.
(Reconcile): Add dnsrecords in the operand namespace to relatedObjects.
If GatewayAPIEnabled is true, add resources related to Gateway API.
If haveOSSMSubscription is true, add resources that require the subscription.
(operatorState): Add haveOSSMSubscription field.
(getOperatorState): Set haveOSSMSubscription.
* pkg/operator/operator.go (New): Specify GatewayAPIEnabled in the status
controller's config.
* test/e2e/operator_test.go (TestClusterOperatorStatusRelatedObjects): Expect to
observe "dnsrecords" for the "openshift-ingress" namespace as well as
"gatewayclasses" in relatedObjects.

Author: Miciah

pkg/operator/controller/status/controller.go

@@ -8,6 +8,8 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
+	sailv1 "github.com/istio-ecosystem/sail-operator/api/v1"
+	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
 
 	configv1 "github.com/openshift/api/config/v1"
 	operatorv1 "github.com/openshift/api/operator/v1"
@@ -26,9 +28,12 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	utilclock "k8s.io/utils/clock"
 
+	gatewayapiv1 "sigs.k8s.io/gateway-api/apis/v1"
+
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
+	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
@@ -92,11 +97,33 @@ func New(mgr manager.Manager, config Config) (controller.Controller, error) {
 	if err := c.Watch(source.Kind[client.Object](operatorCache, &configv1.ClusterOperator{}, handler.EnqueueRequestsFromMapFunc(toDefaultIngressController), predicate.NewPredicateFuncs(isIngressClusterOperator))); err != nil {
 		return nil, err
 	}
+
+	if config.GatewayAPIEnabled {
+		if err := c.Watch(source.Kind[client.Object](operatorCache, &operatorsv1alpha1.Subscription{}, handler.EnqueueRequestsFromMapFunc(toDefaultIngressController), predicate.Funcs{
+			CreateFunc: func(e event.CreateEvent) bool {
+				return e.Object.GetNamespace() == operatorcontroller.OpenshiftOperatorNamespace
+			},
+			UpdateFunc: func(e event.UpdateEvent) bool {
+				return false
+			},
+			DeleteFunc: func(e event.DeleteEvent) bool {
+				return e.Object.GetNamespace() == operatorcontroller.OpenshiftOperatorNamespace
+			},
+			GenericFunc: func(e event.GenericEvent) bool {
+				return false
+			},
+		})); err != nil {
+			return nil, err
+		}
+	}
+
 	return c, nil
 }
 
 // Config holds all the things necessary for the controller to run.
 type Config struct {
+	// GatewayAPIEnabled indicates that the "GatewayAPI" featuregate is enabled.
+	GatewayAPIEnabled      bool
 	IngressControllerImage string
 	CanaryImage            string
 	OperatorReleaseVersion string
@@ -159,6 +186,10 @@ func (r *reconciler) Reconcile(ctx context.Context, request reconcile.Request) (
 		related = append(related, configv1.ObjectReference{
 			Resource: "namespaces",
 			Name:     state.IngressNamespace.Name,
+		}, configv1.ObjectReference{
+			Group:     iov1.GroupVersion.Group,
+			Resource:  "dnsrecords",
+			Namespace: state.IngressNamespace.Name,
 		})
 	}
 	if state.CanaryNamespace != nil {
@@ -167,6 +198,33 @@ func (r *reconciler) Reconcile(ctx context.Context, request reconcile.Request) (
 			Name:     state.CanaryNamespace.Name,
 		})
 	}
+	if r.config.GatewayAPIEnabled {
+		related = append(related, configv1.ObjectReference{
+			Group:    gatewayapiv1.GroupName,
+			Resource: "gatewayclasses",
+		})
+		if state.haveOSSMSubscription {
+			subscriptionName := operatorcontroller.ServiceMeshOperatorSubscriptionName()
+			related = append(related, configv1.ObjectReference{
+				Group:     operatorsv1alpha1.GroupName,
+				Resource:  "subscriptions",
+				Namespace: subscriptionName.Namespace,
+				Name:      subscriptionName.Name,
+			})
+			if state.IngressNamespace != nil {
+				related = append(related, configv1.ObjectReference{
+					Group:     sailv1.GroupVersion.Group,
+					Resource:  "istios",
+					Namespace: state.IngressNamespace.Name,
+				})
+				related = append(related, configv1.ObjectReference{
+					Group:     gatewayapiv1.GroupName,
+					Resource:  "gateways",
+					Namespace: state.IngressNamespace.Name,
+				})
+			}
+		}
+	}
 
 	co.Status.RelatedObjects = related
 
@@ -236,6 +294,8 @@ type operatorState struct {
 	CanaryNamespace    *corev1.Namespace
 	IngressControllers []operatorv1.IngressController
 	DNSRecords         []iov1.DNSRecord
+
+	haveOSSMSubscription bool
 }
 
 // getOperatorState gets and returns the resources necessary to compute the
@@ -268,6 +328,18 @@ func (r *reconciler) getOperatorState(ingressNamespace, canaryNamespace string)
 		state.IngressControllers = ingressList.Items
 	}
 
+	if r.config.GatewayAPIEnabled {
+		var subscription operatorsv1alpha1.Subscription
+		subscriptionName := operatorcontroller.ServiceMeshOperatorSubscriptionName()
+		if err := r.cache.Get(context.TODO(), subscriptionName, &subscription); err != nil {
+			if !errors.IsNotFound(err) {
+				return state, fmt.Errorf("failed to get subscription %q: %v", subscriptionName, err)
+			}
+		} else {
+			state.haveOSSMSubscription = true
+		}
+	}
+
 	return state, nil
 }
 

pkg/operator/operator.go

@@ -212,6 +212,7 @@ func New(config operatorconfig.Config, kubeConfig *rest.Config) (*Operator, erro
 		IngressControllerImage: config.IngressControllerImage,
 		CanaryImage:            config.CanaryImage,
 		OperatorReleaseVersion: config.OperatorReleaseVersion,
+		GatewayAPIEnabled:      gatewayAPIEnabled,
 	}); err != nil {
 		return nil, fmt.Errorf("failed to create status controller: %v", err)
 	}

test/e2e/operator_test.go

@@ -219,24 +219,49 @@ func TestClusterOperatorStatusRelatedObjects(t *testing.T) {
 			Resource: "namespaces",
 			Name:     "openshift-ingress",
 		},
+		{
+			Group:     iov1.GroupVersion.Group,
+			Resource:  "dnsrecords",
+			Namespace: "openshift-ingress",
+		},
 		{
 			Resource: "namespaces",
 			Name:     "openshift-ingress-canary",
 		},
 	}
 
+	if gatewayAPIEnabled, err := isFeatureGateEnabled(features.FeatureGateGatewayAPI); err != nil {
+		t.Fatalf("Failed to look up %q featuregate: %v", features.FeatureGateGatewayAPI, err)
+	} else if gatewayAPIEnabled {
+		expected = append(expected, configv1.ObjectReference{
+			Group:    "gateway.networking.k8s.io",
+			Resource: "gatewayclasses",
+		})
+		// This test runs before TestGatewayAPI, so we do *not* expect
+		// to see subscriptions, istios, or gateways in relatedObjects.
+	}
+
 	coName := controller.IngressClusterOperatorName()
 	err := wait.PollImmediate(1*time.Second, 5*time.Minute, func() (bool, error) {
 		co := &configv1.ClusterOperator{}
 		if err := kclient.Get(context.TODO(), coName, co); err != nil {
-			t.Logf("failed to get ingress cluster operator %s: %v", coName, err)
+			t.Logf("Failed to get clusteroperator %q: %v", coName.Name, err)
+
 			return false, nil
 		}
 
-		return reflect.DeepEqual(expected, co.Status.RelatedObjects), nil
+		if !reflect.DeepEqual(expected, co.Status.RelatedObjects) {
+			t.Logf("Expected %+v, found %+v", expected, co.Status.RelatedObjects)
+
+			return false, nil
+		}
+
+		t.Log("Found the expected status.relatedObjects")
+
+		return true, nil
 	})
 	if err != nil {
-		t.Errorf("did not get expected status related objects: %v", err)
+		t.Errorf("Did not get expected status related objects: %v", err)
 	}
 }