providers/namespace: fix indexes

Signed-off-by: Dr. Stefan Schimanski <stefan.schimanski@gmail.com>

Author: sttts

examples/namespace/main.go

@@ -23,16 +23,15 @@ import (
 
 	flag "github.com/spf13/pflag"
 	"golang.org/x/sync/errgroup"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
 
 	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
 
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/cluster"
 	"sigs.k8s.io/controller-runtime/pkg/envtest"
@@ -103,17 +102,16 @@ func main() {
 	runtime.Must(client.IgnoreAlreadyExists(cli.Create(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "island"}})))
 	runtime.Must(client.IgnoreAlreadyExists(cli.Create(ctx, &corev1.ConfigMap{ObjectMeta: metav1.ObjectMeta{Namespace: "island", Name: "bird"}})))
 
-	cl, err := cluster.New(cfg, namespace.WithClusterNameIndex())
+	cl, err := cluster.New(cfg)
+	if err != nil {
+		entryLog.Error(err, "failed to create cluster")
+		os.Exit(1)
+	}
 	provider := namespace.New(cl)
 
 	// Setup a cluster-aware Manager, with the provider to lookup clusters.
 	entryLog.Info("Setting up cluster-aware manager")
-	mgr, err := mcmanager.New(cfg, provider, manager.Options{
-		NewCache: func(config *rest.Config, opts cache.Options) (cache.Cache, error) {
-			// wrap cache to turn IndexField calls into cluster-scoped indexes.
-			return &namespace.NamespaceScopeableCache{Cache: cl.GetCache()}, nil
-		},
-	})
+	mgr, err := mcmanager.New(cfg, provider, manager.Options{})
 	if err != nil {
 		entryLog.Error(err, "unable to set up overall controller manager")
 		os.Exit(1)

providers/namespace/cache.go

@@ -19,7 +19,6 @@ package namespace
 import (
 	"context"
 	"errors"
-	"fmt"
 	"time"
 
 	corev1 "k8s.io/api/core/v1"
@@ -33,13 +32,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-const (
-	// ClusterNameIndex indexes object by cluster and name.
-	ClusterNameIndex = "cluster/name"
-	// ClusterIndex indexes object by cluster.
-	ClusterIndex = "cluster"
-)
-
 var _ cache.Cache = &NamespacedCache{}
 
 // NamespacedCache is a cache that operates on a specific namespace.
@@ -68,26 +60,16 @@ func (c *NamespacedCache) List(ctx context.Context, list client.ObjectList, opts
 		o.ApplyToList(&listOpts)
 	}
 
-	switch {
-	case listOpts.FieldSelector != nil:
-		reqs := listOpts.FieldSelector.Requirements()
-		flds := make(map[string]string, len(reqs))
-		for i := range reqs {
-			flds[fmt.Sprintf("cluster/%s", reqs[i].Field)] = fmt.Sprintf("%s/%s", c.clusterName, reqs[i].Value)
-		}
-		opts = append(opts, client.MatchingFields(flds))
-	case listOpts.Namespace != "":
-		opts = append(opts, client.MatchingFields(map[string]string{ClusterIndex: c.clusterName}))
-		if c.clusterName == "*" {
-			listOpts.Namespace = ""
-		} else if listOpts.Namespace == corev1.NamespaceDefault {
-			listOpts.Namespace = c.clusterName
-		}
-	default:
-		opts = append(opts, client.MatchingFields(map[string]string{ClusterIndex: c.clusterName}))
+	if listOpts.Namespace != "" && listOpts.Namespace != corev1.NamespaceDefault {
+		return nil
 	}
 
-	if err := c.Cache.List(ctx, list, opts...); err != nil {
+	ns := c.clusterName
+	if ns == "*" {
+		ns = ""
+	}
+
+	if err := c.Cache.List(ctx, list, append(opts, client.InNamespace(ns))...); err != nil {
 		return err
 	}
 
@@ -201,26 +183,3 @@ func (i *ScopedInformer) AddEventHandlerWithResyncPeriod(handler toolscache.Reso
 func (i *ScopedInformer) AddIndexers(indexers toolscache.Indexers) error {
 	return errors.New("indexes cannot be added to scoped informers")
 }
-
-// NamespaceScopeableCache is a cache that indexes objects by namespace.
-type NamespaceScopeableCache struct { //nolint:revive // Stuttering here is fine.
-	cache.Cache
-}
-
-// IndexField adds an index for the given object kind.
-func (f *NamespaceScopeableCache) IndexField(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc) error {
-	return f.Cache.IndexField(ctx, obj, "cluster/"+field, func(obj client.Object) []string {
-		keys := extractValue(obj)
-		withCluster := make([]string, len(keys)*2)
-		for i, key := range keys {
-			withCluster[i] = fmt.Sprintf("%s/%s", obj.GetNamespace(), key)
-			withCluster[i+len(keys)] = fmt.Sprintf("*/%s", key)
-		}
-		return withCluster
-	})
-}
-
-// Start starts the cache.
-func (f *NamespaceScopeableCache) Start(ctx context.Context) error {
-	return nil // no-op as this is shared
-}

providers/namespace/cluster.go

@@ -18,50 +18,14 @@ package namespace
 
 import (
 	"context"
-	"fmt"
-	"time"
 
-	apiruntime "k8s.io/apimachinery/pkg/runtime"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	toolscache "k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/record"
 
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/cluster"
 )
 
-// WithClusterNameIndex adds indexers for cluster name and namespace.
-func WithClusterNameIndex() cluster.Option {
-	return func(options *cluster.Options) {
-		old := options.Cache.NewInformer
-		options.Cache.NewInformer = func(watcher toolscache.ListerWatcher, object apiruntime.Object, duration time.Duration, indexers toolscache.Indexers) toolscache.SharedIndexInformer {
-			var inf toolscache.SharedIndexInformer
-			if old != nil {
-				inf = old(watcher, object, duration, indexers)
-			} else {
-				inf = toolscache.NewSharedIndexInformer(watcher, object, duration, indexers)
-			}
-			if err := inf.AddIndexers(toolscache.Indexers{
-				ClusterNameIndex: func(obj any) ([]string, error) {
-					o := obj.(client.Object)
-					return []string{
-						fmt.Sprintf("%s/%s", o.GetNamespace(), o.GetName()),
-						fmt.Sprintf("%s/%s", "*", o.GetName()),
-					}, nil
-				},
-				ClusterIndex: func(obj any) ([]string, error) {
-					o := obj.(client.Object)
-					return []string{o.GetNamespace()}, nil
-				},
-			}); err != nil {
-				utilruntime.HandleError(fmt.Errorf("unable to add cluster name indexers: %w", err))
-			}
-			return inf
-		}
-	}
-}
-
 // NamespacedCluster is a cluster that operates on a specific namespace.
 type NamespacedCluster struct {
 	clusterName string

providers/namespace/provider_test.go

@@ -19,18 +19,18 @@ package namespace
 import (
 	"context"
 	"errors"
+	"strconv"
 
 	"golang.org/x/sync/errgroup"
 
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/client-go/rest"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/client-go/util/retry"
 
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/cluster"
 	"sigs.k8s.io/controller-runtime/pkg/log"
@@ -61,25 +61,14 @@ var _ = Describe("Provider Namespace", Ordered, func() {
 
 		By("Setting up the provider against the host cluster", func() {
 			var err error
-			cl, err = cluster.New(cfg, WithClusterNameIndex(), func(options *cluster.Options) {
-				options.Cache.ByObject = map[client.Object]cache.ByObject{
-					&corev1.ConfigMap{}: {
-						Label: labels.Set{"type": "animal"}.AsSelector(),
-					},
-				}
-			})
+			cl, err = cluster.New(cfg)
 			Expect(err).NotTo(HaveOccurred())
 			provider = New(cl)
 		})
 
 		By("Setting up the cluster-aware manager, with the provider to lookup clusters", func() {
 			var err error
-			mgr, err = mcmanager.New(cfg, provider, manager.Options{
-				NewCache: func(config *rest.Config, opts cache.Options) (cache.Cache, error) {
-					// wrap cache to turn IndexField calls into cluster-scoped indexes.
-					return &NamespaceScopeableCache{Cache: cl.GetCache()}, nil
-				},
-			})
+			mgr, err = mcmanager.New(cfg, provider, manager.Options{})
 			Expect(err).NotTo(HaveOccurred())
 		})