✨ Allow configuring a default cache selector

It is already possible to configure cache selectors per gvk, but it is
not possible to default this selector for all types. This change adds
that.

pkg/cache/cache.go

@@ -22,6 +22,7 @@ import (
 	"time"
 
 	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/kubernetes/scheme"
@@ -90,8 +91,22 @@ type Informer interface {
 type ObjectSelector internal.Selector
 
 // SelectorsByObject associate a client.Object's GVK to a field/label selector.
+// Use SelectorsByObjectDefaultKey as key to specify a default selector that
+// will be used for all types that do not have a selector configured.
 type SelectorsByObject map[client.Object]ObjectSelector
 
+// SelectorsByObjectDefaultKey can be used in SelectorsByObject to configure a default
+// selector for all kinds that do not have a specific selector set up.
+type SelectorsByObjectDefaultKey struct{ metav1.Object }
+
+// GetObjectKind implements runtime.Object.
+func (s *SelectorsByObjectDefaultKey) GetObjectKind() schema.ObjectKind {
+	return schema.EmptyObjectKind
+}
+
+// DeepCopyObject implements runtime.Object.
+func (s *SelectorsByObjectDefaultKey) DeepCopyObject() runtime.Object { return s }
+
 // Options are the optional arguments for creating a new InformersMap object.
 type Options struct {
 	// Scheme is the scheme to use for mapping objects to GroupVersionKinds
@@ -197,6 +212,10 @@ func defaultOpts(config *rest.Config, opts Options) (Options, error) {
 func convertToSelectorsByGVK(selectorsByObject SelectorsByObject, scheme *runtime.Scheme) (internal.SelectorsByGVK, error) {
 	selectorsByGVK := internal.SelectorsByGVK{}
 	for object, selector := range selectorsByObject {
+		if _, isDefault := object.(*SelectorsByObjectDefaultKey); isDefault {
+			selectorsByGVK[internal.DefaultSelectorKey] = internal.Selector(selector)
+			continue
+		}
 		gvk, err := apiutil.GVKForObject(object, scheme)
 		if err != nil {
 			return nil, err

pkg/cache/cache_test.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"reflect"
 	"sort"
+	"strconv"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/ginkgo/extensions/table"
@@ -73,6 +74,33 @@ func createPodWithLabels(name, namespace string, restartPolicy corev1.RestartPol
 	return pod
 }
 
+func createSvc(name, namespace string, cl client.Client) client.Object {
+	svc := &corev1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: corev1.ServiceSpec{
+			Ports: []corev1.ServicePort{{Port: 1}},
+		},
+	}
+	err := cl.Create(context.Background(), svc)
+	Expect(err).NotTo(HaveOccurred())
+	return svc
+}
+
+func createSA(name, namespace string, cl client.Client) client.Object {
+	sa := &corev1.ServiceAccount{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+	err := cl.Create(context.Background(), sa)
+	Expect(err).NotTo(HaveOccurred())
+	return sa
+}
+
 func createPod(name, namespace string, restartPolicy corev1.RestartPolicy) client.Object {
 	return createPodWithLabels(name, namespace, restartPolicy, nil)
 }
@@ -93,6 +121,76 @@ var _ = Describe("Multi-Namespace Informer Cache", func() {
 var _ = Describe("Informer Cache without DeepCopy", func() {
 	CacheTest(cache.New, cache.Options{UnsafeDisableDeepCopyByObject: cache.DisableDeepCopyByObject{cache.ObjectAll{}: true}})
 })
+var _ = Describe("Cache with selectors", func() {
+	defer GinkgoRecover()
+	var (
+		informerCache       cache.Cache
+		informerCacheCtx    context.Context
+		informerCacheCancel context.CancelFunc
+	)
+
+	BeforeEach(func() {
+		informerCacheCtx, informerCacheCancel = context.WithCancel(context.Background())
+		Expect(cfg).NotTo(BeNil())
+		cl, err := client.New(cfg, client.Options{})
+		Expect(err).NotTo(HaveOccurred())
+		err = ensureNamespace(testNamespaceOne, cl)
+		Expect(err).NotTo(HaveOccurred())
+		err = ensureNamespace(testNamespaceTwo, cl)
+		Expect(err).NotTo(HaveOccurred())
+		for idx, namespace := range []string{testNamespaceOne, testNamespaceTwo} {
+			_ = createSA("test-sa-"+strconv.Itoa(idx), namespace, cl)
+			_ = createSvc("test-svc-"+strconv.Itoa(idx), namespace, cl)
+		}
+
+		opts := cache.Options{
+			SelectorsByObject: cache.SelectorsByObject{
+				&corev1.ServiceAccount{}:             {Field: fields.OneTermEqualSelector("metadata.namespace", testNamespaceOne)},
+				&cache.SelectorsByObjectDefaultKey{}: cache.ObjectSelector{Field: fields.OneTermEqualSelector("metadata.namespace", testNamespaceTwo)},
+			},
+		}
+
+		By("creating the informer cache")
+		informerCache, err = cache.New(cfg, opts)
+		Expect(err).NotTo(HaveOccurred())
+		By("running the cache and waiting for it to sync")
+		// pass as an arg so that we don't race between close and re-assign
+		go func(ctx context.Context) {
+			defer GinkgoRecover()
+			Expect(informerCache.Start(ctx)).To(Succeed())
+		}(informerCacheCtx)
+		Expect(informerCache.WaitForCacheSync(informerCacheCtx)).To(BeTrue())
+	})
+
+	AfterEach(func() {
+		ctx := context.Background()
+		cl, err := client.New(cfg, client.Options{})
+		Expect(err).NotTo(HaveOccurred())
+		for idx, namespace := range []string{testNamespaceOne, testNamespaceTwo} {
+			err = cl.Delete(ctx, &corev1.ServiceAccount{ObjectMeta: metav1.ObjectMeta{Namespace: namespace, Name: "test-sa-" + strconv.Itoa(idx)}})
+			Expect(err).NotTo(HaveOccurred())
+			err = cl.Delete(ctx, &corev1.Service{ObjectMeta: metav1.ObjectMeta{Namespace: namespace, Name: "test-svc-" + strconv.Itoa(idx)}})
+			Expect(err).NotTo(HaveOccurred())
+		}
+		informerCacheCancel()
+	})
+
+	It("Should list serviceaccounts and find exactly one in namespace "+testNamespaceOne, func() {
+		var sas corev1.ServiceAccountList
+		err := informerCache.List(informerCacheCtx, &sas)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(sas.Items)).To(Equal(1))
+		Expect(sas.Items[0].Namespace).To(Equal(testNamespaceOne))
+	})
+
+	It("Should list services and find exactly one in namespace "+testNamespaceTwo, func() {
+		var svcs corev1.ServiceList
+		err := informerCache.List(informerCacheCtx, &svcs)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(svcs.Items)).To(Equal(1))
+		Expect(svcs.Items[0].Namespace).To(Equal(testNamespaceTwo))
+	})
+})
 
 func CacheTest(createCacheFunc func(config *rest.Config, opts cache.Options) (cache.Cache, error), opts cache.Options) {
 	Describe("Cache test", func() {

pkg/cache/internal/informers_map.go

@@ -277,19 +277,19 @@ func createStructuredListWatch(gvk schema.GroupVersionKind, ip *specificInformer
 	// Create a new ListWatch for the obj
 	return &cache.ListWatch{
 		ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) {
-			ip.selectors[gvk].ApplyToList(&opts)
+			ip.selectors.forGVK(gvk).ApplyToList(&opts)
 			res := listObj.DeepCopyObject()
-			namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk])
+			namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors.forGVK(gvk))
 			isNamespaceScoped := namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot
 			err := client.Get().NamespaceIfScoped(namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Do(ctx).Into(res)
 			return res, err
 		},
 		// Setup the watch function
 		WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) {
-			ip.selectors[gvk].ApplyToList(&opts)
+			ip.selectors.forGVK(gvk).ApplyToList(&opts)
 			// Watch needs to be set to true separately
 			opts.Watch = true
-			namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors[gvk])
+			namespace := restrictNamespaceBySelector(ip.namespace, ip.selectors.forGVK(gvk))
 			isNamespaceScoped := namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot
 			return client.Get().NamespaceIfScoped(namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Watch(ctx)
 		},

pkg/cache/internal/selector.go

@@ -23,9 +23,22 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
+var DefaultSelectorKey = schema.GroupVersionKind{}
+
 // SelectorsByGVK associate a GroupVersionKind to a field/label selector.
 type SelectorsByGVK map[schema.GroupVersionKind]Selector
 
+func (s SelectorsByGVK) forGVK(gvk schema.GroupVersionKind) Selector {
+	if specific, found := s[gvk]; found {
+		return specific
+	}
+	if defaultSelector, found := s[DefaultSelectorKey]; found {
+		return defaultSelector
+	}
+
+	return Selector{}
+}
+
 // Selector specify the label/field selector to fill in ListOptions.
 type Selector struct {
 	Label labels.Selector