fix: gate experimental gateway api resources

Author: mahmut-Abi

cmd/manager/app.go

@@ -33,8 +33,8 @@ import (
 	"github.com/nantian-gw/gateway/internal/admin"
 	"github.com/nantian-gw/gateway/internal/config"
 	"github.com/nantian-gw/gateway/internal/controller"
-	backendlbv1alpha2 "github.com/nantian-gw/gateway/internal/gatewayapiexperimental/backendlbv1alpha2"
 	aiservicev1alpha1 "github.com/nantian-gw/gateway/internal/gatewayapiexperimental/aiservicev1alpha1"
+	backendlbv1alpha2 "github.com/nantian-gw/gateway/internal/gatewayapiexperimental/backendlbv1alpha2"
 	tokenpolicyv1alpha1 "github.com/nantian-gw/gateway/internal/gatewayapiexperimental/tokenpolicyv1alpha1"
 	wasmpluginv1alpha1 "github.com/nantian-gw/gateway/internal/gatewayapiexperimental/wasmpluginv1alpha1"
 	"github.com/nantian-gw/gateway/internal/grpcserver"
@@ -172,27 +172,34 @@ func run(configPath string) error {
 			},
 		},
 	)
-	statuser := status.NewWithAddressesAndReader(
+	statusOptions := status.Options{EnableExperimentalGateway: cfg.Features.EnableExperimentalGateway}
+	statuser := status.NewWithAddressesAndReaderOptions(
 		mgr.GetClient(),
 		mgr.GetAPIReader(),
 		cfg.ControllerName,
 		cfg.AdvertisedAddresses(),
 		logger,
+		statusOptions,
 	)
 	statuser.SetEventRecorder(mgr.GetEventRecorderFor("gateway-status"))
 	if err := translator.SetupIndexes(ctx, mgr.GetFieldIndexer()); err != nil {
 		return fmt.Errorf("set up translator indexes: %w", err)
 	}
-	if err := infrastructure.SetupIndexes(ctx, mgr.GetFieldIndexer()); err != nil {
+	if err := infrastructure.SetupIndexes(
+		ctx,
+		mgr.GetFieldIndexer(),
+		infrastructure.Options{EnableExperimentalGateway: cfg.Features.EnableExperimentalGateway},
+	); err != nil {
 		return fmt.Errorf("set up infrastructure indexes: %w", err)
 	}
-	if err := status.SetupIndexes(ctx, mgr.GetFieldIndexer()); err != nil {
+	if err := status.SetupIndexes(ctx, mgr.GetFieldIndexer(), statusOptions); err != nil {
 		return fmt.Errorf("set up status indexes: %w", err)
 	}
 
 	infraOptions := infrastructure.DefaultOptions()
 	infraOptions.SnapshotStore = store
 	infraOptions.NodeStatus = nodes
+	infraOptions.EnableExperimentalGateway = cfg.Features.EnableExperimentalGateway
 	infra := infrastructure.NewWithOptions(mgr.GetClient(), mgr.GetAPIReader(), cfg.ControllerName, infraOptions, logger)
 	statusScopedReconcile := func(ctx context.Context, scope controller.ReconcilerRunnerScope) error {
 		switch scope {
@@ -239,14 +246,15 @@ func run(configPath string) error {
 		logger,
 		reconcilerRunner.QueueRunForScopes,
 	)
+	syncer.SetOptions(controller.SyncerOptions{EnableExperimentalGateway: cfg.Features.EnableExperimentalGateway})
 	syncer.SetSettleDelay(cfg.SyncSettleDelayDuration())
 	if err := syncer.SetupWithManager(mgr); err != nil {
 		return fmt.Errorf("set up snapshot sync controller: %w", err)
 	}
 	if err := mgr.Add(syncer); err != nil {
 		return fmt.Errorf("add syncer runnable: %w", err)
 	}
-	if err := status.SetupControllers(mgr, statuser); err != nil {
+	if err := status.SetupControllers(mgr, statuser, statusOptions); err != nil {
 		return fmt.Errorf("set up status controllers: %w", err)
 	}
 	if err := mgr.Add(reconcilerRunner); err != nil {

internal/controller/reconciler.go

@@ -91,28 +91,28 @@ func (s *Syncer) SetupWithManager(mgr ctrl.Manager) error {
 		Watches(&corev1.ConfigMap{}, snapshotRequests).
 		Watches(&discoveryv1.EndpointSlice{}, snapshotRequests, snapshotInputPredicate)
 
-	if resourceSupported(mgr, &gatewayv1alpha2.TCPRoute{}) {
+	if s.options.EnableExperimentalGateway && resourceSupported(mgr, &gatewayv1alpha2.TCPRoute{}) {
 		controllerBuilder = controllerBuilder.Watches(
 			&gatewayv1alpha2.TCPRoute{},
 			snapshotRequests,
 			snapshotMutationPredicate,
 		)
 	}
-	if resourceSupported(mgr, &gatewayv1alpha2.UDPRoute{}) {
+	if s.options.EnableExperimentalGateway && resourceSupported(mgr, &gatewayv1alpha2.UDPRoute{}) {
 		controllerBuilder = controllerBuilder.Watches(
 			&gatewayv1alpha2.UDPRoute{},
 			snapshotRequests,
 			snapshotMutationPredicate,
 		)
 	}
-	if resourceSupported(mgr, &gatewayv1alpha2.TLSRoute{}) {
+	if s.options.EnableExperimentalGateway && resourceSupported(mgr, &gatewayv1alpha2.TLSRoute{}) {
 		controllerBuilder = controllerBuilder.Watches(
 			&gatewayv1alpha2.TLSRoute{},
 			snapshotRequests,
 			snapshotMutationPredicate,
 		)
 	}
-	if resourceSupported(mgr, &gatewayv1.ListenerSet{}) {
+	if s.options.EnableExperimentalGateway && resourceSupported(mgr, &gatewayv1.ListenerSet{}) {
 		controllerBuilder = controllerBuilder.Watches(
 			&gatewayv1.ListenerSet{},
 			snapshotRequests,

internal/controller/syncer.go

@@ -33,12 +33,21 @@ type Syncer struct {
 	retryPending                   snapshotPendingBuild
 	backendTLSPolicyConfigMapIndex bool
 	missingFieldIndexFallbacks     map[missingFieldIndexFallbackLogKey]struct{}
+	options                        SyncerOptions
 }
 
 type ComponentReconciler interface {
 	Reconcile(context.Context) error
 }
 
+type SyncerOptions struct {
+	EnableExperimentalGateway bool
+}
+
+func defaultSyncerOptions() SyncerOptions {
+	return SyncerOptions{EnableExperimentalGateway: true}
+}
+
 func NewSyncer(
 	client client.Client,
 	translator *translator.Translator,
@@ -62,7 +71,15 @@ func NewSyncer(
 		logger:      logger,
 		leaderRun:   leaderRun,
 		settleDelay: 0,
+		options:     defaultSyncerOptions(),
+	}
+}
+
+func (s *Syncer) SetOptions(options SyncerOptions) {
+	if s == nil {
+		return
 	}
+	s.options = options
 }
 
 func (s *Syncer) Run(ctx context.Context) {

internal/infrastructure/inspector_support.go

@@ -11,6 +11,7 @@ import (
 	"k8s.io/apimachinery/pkg/selection"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
+	gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 
 	"github.com/nantian-gw/gateway/internal/ir"
 	"github.com/nantian-gw/gateway/internal/mesh"
@@ -194,17 +195,22 @@ func (r *Reconciler) loadMeshServiceParents(ctx context.Context) ([]mesh.Service
 	if err != nil {
 		return nil, err
 	}
-	tcpRoutes, err := listTCPRoutesWithServiceParents(ctx, r.client)
-	if err != nil {
-		return nil, err
-	}
-	udpRoutes, err := listUDPRoutesWithServiceParents(ctx, r.client)
-	if err != nil {
-		return nil, err
-	}
-	tlsRoutes, err := listTLSRoutesWithServiceParents(ctx, r.client)
-	if err != nil {
-		return nil, err
+	var tcpRoutes []gatewayv1alpha2.TCPRoute
+	var udpRoutes []gatewayv1alpha2.UDPRoute
+	var tlsRoutes []gatewayv1alpha2.TLSRoute
+	if r.options.EnableExperimentalGateway {
+		tcpRoutes, err = listTCPRoutesWithServiceParents(ctx, r.client)
+		if err != nil {
+			return nil, err
+		}
+		udpRoutes, err = listUDPRoutesWithServiceParents(ctx, r.client)
+		if err != nil {
+			return nil, err
+		}
+		tlsRoutes, err = listTLSRoutesWithServiceParents(ctx, r.client)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return collectMeshServiceParents(

internal/infrastructure/reconciler.go

@@ -34,11 +34,12 @@ var defaultDataplaneSelector = map[string]string{
 }
 
 type Options struct {
-	DataplaneNamespace string
-	SharedServiceName  string
-	DataplaneSelector  map[string]string
-	SnapshotStore      *ir.SnapshotStore
-	NodeStatus         *nodestatus.Registry
+	DataplaneNamespace        string
+	SharedServiceName         string
+	DataplaneSelector         map[string]string
+	SnapshotStore             *ir.SnapshotStore
+	NodeStatus                *nodestatus.Registry
+	EnableExperimentalGateway bool
 }
 
 type Reconciler struct {
@@ -85,9 +86,10 @@ func NewWithOptions(
 
 func DefaultOptions() Options {
 	return Options{
-		DataplaneNamespace: defaultDataplaneNamespace,
-		SharedServiceName:  defaultSharedServiceName,
-		DataplaneSelector:  cloneStringMap(defaultDataplaneSelector),
+		DataplaneNamespace:        defaultDataplaneNamespace,
+		SharedServiceName:         defaultSharedServiceName,
+		DataplaneSelector:         cloneStringMap(defaultDataplaneSelector),
+		EnableExperimentalGateway: true,
 	}
 }
 

internal/infrastructure/reconciler_mesh_scoped_queries_test.go

@@ -199,6 +199,37 @@ func TestReconcileMeshServicesScopesServiceAndEndpointLookups(t *testing.T) {
 	}
 }
 
+func TestLoadMeshServiceParentsStandardModeSkipsExperimentalRouteLists(t *testing.T) {
+	scheme := newScheme(t)
+	baseClient := withInfrastructureRouteParentIndexes(
+		fake.NewClientBuilder().WithScheme(scheme),
+	).Build()
+	reconciler := NewWithOptions(
+		rawValidatingClient{
+			Client: baseClient,
+			listValidators: map[reflect.Type]func([]client.ListOption) error{
+				reflect.TypeOf(&gatewayv1alpha2.TCPRouteList{}): func([]client.ListOption) error {
+					return fmt.Errorf("standard mode should not list TCPRoutes")
+				},
+				reflect.TypeOf(&gatewayv1alpha2.UDPRouteList{}): func([]client.ListOption) error {
+					return fmt.Errorf("standard mode should not list UDPRoutes")
+				},
+				reflect.TypeOf(&gatewayv1alpha2.TLSRouteList{}): func([]client.ListOption) error {
+					return fmt.Errorf("standard mode should not list TLSRoutes")
+				},
+			},
+		},
+		nil,
+		"gateway.networking.k8s.io/nantian-gw",
+		Options{EnableExperimentalGateway: false},
+		discardLogger(),
+	)
+
+	if _, err := reconciler.loadMeshServiceParents(context.Background()); err != nil {
+		t.Fatalf("loadMeshServiceParents returned error: %v", err)
+	}
+}
+
 func TestLoadMeshFrontendNetworkPolicyPortsScopesManagedMeshServices(t *testing.T) {
 	scheme := newScheme(t)
 

internal/infrastructure/route_indexes.go

@@ -25,7 +25,12 @@ const (
 	serviceParentIndexMarker        = "__service_parent__"
 )
 
-func SetupIndexes(ctx context.Context, indexer client.FieldIndexer) error {
+func SetupIndexes(ctx context.Context, indexer client.FieldIndexer, options ...Options) error {
+	enableExperimentalGateway := true
+	if len(options) > 0 {
+		enableExperimentalGateway = options[0].EnableExperimentalGateway
+	}
+
 	if err := indexer.IndexField(ctx, &gatewayv1.GatewayClass{}, gatewayClassControllerNameIndex, gatewayClassControllerNameIndexKeys); err != nil {
 		return fmt.Errorf("index GatewayClass controller name: %w", err)
 	}
@@ -38,6 +43,10 @@ func SetupIndexes(ctx context.Context, indexer client.FieldIndexer) error {
 	if err := indexer.IndexField(ctx, &gatewayv1.GRPCRoute{}, grpcRouteServiceParentIndex, grpcRouteServiceParentIndexKeys); err != nil {
 		return fmt.Errorf("index GRPCRoute service parents: %w", err)
 	}
+	if !enableExperimentalGateway {
+		return nil
+	}
+
 	// v1alpha2 CRDs (TCPRoute, UDPRoute, TLSRoute) are in the experimental
 	// Gateway API channel. Skip indexing if the CRDs are not installed.
 	if err := indexer.IndexField(ctx, &gatewayv1alpha2.TCPRoute{}, tcpRouteServiceParentIndex, tcpRouteServiceParentIndexKeys); err != nil {

internal/status/controllers.go

@@ -30,25 +30,37 @@ type controllerSetup interface {
 	SetupWithManager(ctrl.Manager) error
 }
 
-func SetupControllers(mgr ctrl.Manager, reconciler *Reconciler) error {
+func SetupControllers(mgr ctrl.Manager, reconciler *Reconciler, options ...Options) error {
+	for _, controller := range statusControllerSetups(reconciler, normalizeOptions(options)) {
+		if err := controller.SetupWithManager(mgr); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func statusControllerSetups(reconciler *Reconciler, opts Options) []controllerSetup {
 	controllers := []controllerSetup{
 		&gatewayClassController{reconciler: reconciler},
-		&gatewayController{reconciler: reconciler},
+		&gatewayController{
+			reconciler:                reconciler,
+			enableExperimentalGateway: opts.EnableExperimentalGateway,
+		},
 		&httpRouteController{reconciler: reconciler},
 		&grpcRouteController{reconciler: reconciler},
-		&tcpRouteController{reconciler: reconciler},
-		&udpRouteController{reconciler: reconciler},
-		&tlsRouteController{reconciler: reconciler},
-		&listenerSetController{reconciler: reconciler},
 	}
 
-	for _, controller := range controllers {
-		if err := controller.SetupWithManager(mgr); err != nil {
-			return err
-		}
+	if opts.EnableExperimentalGateway {
+		controllers = append(controllers,
+			&tcpRouteController{reconciler: reconciler},
+			&udpRouteController{reconciler: reconciler},
+			&tlsRouteController{reconciler: reconciler},
+			&listenerSetController{reconciler: reconciler},
+		)
 	}
 
-	return nil
+	return controllers
 }
 
 func statusControllerOptions(maxConcurrentReconciles int) controller.Options {
@@ -102,7 +114,8 @@ func (c *gatewayClassController) SetupWithManager(mgr ctrl.Manager) error {
 }
 
 type gatewayController struct {
-	reconciler *Reconciler
+	reconciler                *Reconciler
+	enableExperimentalGateway bool
 }
 
 func (c *gatewayController) Reconcile(
@@ -120,7 +133,7 @@ func (c *gatewayController) SetupWithManager(mgr ctrl.Manager) error {
 		gatewayInfrastructureStatusRequests,
 	)
 
-	return ctrl.NewControllerManagedBy(mgr).
+	controllerBuilder := ctrl.NewControllerManagedBy(mgr).
 		Named("gateway-status").
 		WithOptions(statusControllerOptions(2)).
 		For(&gatewayv1.Gateway{}, generationChanged).
@@ -133,12 +146,16 @@ func (c *gatewayController) SetupWithManager(mgr ctrl.Manager) error {
 			&discoveryv1.EndpointSlice{},
 			gatewayInfrastructureRequests,
 			builder.WithPredicates(gatewayFrontendEndpointSlicePredicate()),
-		).
-		Watches(
+		)
+
+	if c.enableExperimentalGateway && resourceSupported(mgr.GetScheme(), mgr.GetRESTMapper(), &gatewayv1.ListenerSet{}) {
+		controllerBuilder = controllerBuilder.Watches(
 			&gatewayv1.ListenerSet{},
 			handler.EnqueueRequestsFromMapFunc(gatewayListenerSetStatusRequests),
-		).
-		Complete(c)
+		)
+	}
+
+	return controllerBuilder.Complete(c)
 }
 
 func gatewayInfrastructureServicePredicate() predicate.Predicate {