Add non-panicing versions of ListerFor, IndexerFor and prefix

the panicing versions with Must*

Author: ecordell

adopt/adopt_test.go

@@ -46,7 +46,7 @@ func TestSecretAdopterHandler(t *testing.T) {
 		err    error
 	}
 
-	secretNotFound := func(name string) error {
+	secretNotFound := func(_ string) error {
 		return apierrors.NewNotFound(
 			corev1.SchemeGroupVersion.WithResource("secrets").GroupResource(),
 			"test")

component/ensure_component_test.go

@@ -122,7 +122,7 @@ func TestEnsureServiceHandler(t *testing.T) {
 			client := clientfake.NewSimpleDynamicClient(scheme, tt.existingServices...)
 			informerFactory := dynamicinformer.NewDynamicSharedInformerFactory(client, 0)
 			require.NoError(t, informerFactory.ForResource(serviceGVR).Informer().AddIndexers(map[string]cache.IndexFunc{
-				ownerIndex: func(obj interface{}) ([]string, error) {
+				ownerIndex: func(_ interface{}) ([]string, error) {
 					return []string{types.NamespacedName{Namespace: "test", Name: "owner"}.String()}, nil
 				},
 			}))

handler/handler.go

@@ -127,7 +127,7 @@ func (f Builder) Handler(id Key) Handler {
 }
 
 // NoopHandler is a handler that does nothing
-var NoopHandler = NewHandler(ContextHandlerFunc(func(ctx context.Context) {}), NextKey)
+var NoopHandler = NewHandler(ContextHandlerFunc(func(_ context.Context) {}), NextKey)
 
 // Key is used to identify a given Handler in a set of Handlers
 type Key string

queue/controls_test.go

@@ -28,7 +28,7 @@ func ExampleNewOperations() {
 	}, cancel)
 
 	// typically called from a handler
-	handler.NewHandlerFromFunc(func(ctx context.Context) {
+	handler.NewHandlerFromFunc(func(_ context.Context) {
 		// do some work
 		operations.Done()
 	}, "example").Handle(ctx)
@@ -60,7 +60,7 @@ func ExampleNewQueueOperationsCtx() {
 	}, cancel))
 
 	// queue controls are passed via context
-	handler.NewHandlerFromFunc(func(ctx context.Context) {
+	handler.NewHandlerFromFunc(func(_ context.Context) {
 		// do some work
 		CtxQueue.Done()
 	}, "example").Handle(ctx)

typed/registry.go

@@ -94,13 +94,43 @@ func (r *Registry) NewFilteredDynamicSharedInformerFactory(key FactoryKey, clien
 }
 
 // ListerFor returns a typed Lister from a Registry
+// Deprecated: Use MustListerForKey instead
 func ListerFor[K runtime.Object](r *Registry, key RegistryKey) *Lister[K] {
-	return NewLister[K](r.ListerFor(key))
+	return MustListerForKey[K](r, key)
+}
+
+// MustListerForKey returns a typed Lister from a Registry, or panics if the key is not found
+func MustListerForKey[K runtime.Object](r *Registry, key RegistryKey) *Lister[K] {
+	return NewLister[K](r.MustListerForKey(key))
+}
+
+// ListerForKey returns a typed Lister from a Registry, or an error if the key is not found
+func ListerForKey[K runtime.Object](r *Registry, key RegistryKey) (*Lister[K], error) {
+	lister, err := r.ListerForKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return NewLister[K](lister), nil
 }
 
 // IndexerFor returns a typed Indexer from a Registry
+// Deprecated: Use MustIndexerForKey instead
 func IndexerFor[K runtime.Object](r *Registry, key RegistryKey) *Indexer[K] {
-	return NewIndexer[K](r.InformerFor(key).GetIndexer())
+	return MustIndexerForKey[K](r, key)
+}
+
+// MustIndexerForKey returns a typed Indexer from a Registry, or panics if the key is not found
+func MustIndexerForKey[K runtime.Object](r *Registry, key RegistryKey) *Indexer[K] {
+	return NewIndexer[K](r.MustIndexerForKey(key))
+}
+
+// IndexerForKey returns a typed Indexer from a Registry, or an error if the key is not found
+func IndexerForKey[K runtime.Object](r *Registry, key RegistryKey) (*Indexer[K], error) {
+	indexer, err := r.IndexerForKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return NewIndexer[K](indexer), nil
 }
 
 // Add adds a factory to the registry under the given FactoryKey
@@ -124,27 +154,95 @@ func (r *Registry) Remove(key FactoryKey) {
 }
 
 // InformerFactoryFor returns GVR-specific InformerFactory from the Registry.
+// Deprecated: use MustInformerFactoryForKey instead.
 func (r *Registry) InformerFactoryFor(key RegistryKey) informers.GenericInformer {
+	return r.MustInformerFactoryForKey(key)
+}
+
+// MustInformerFactoryForKey returns GVR-specific InformerFactory from the Registry
+// or panics if the key is not found.
+func (r *Registry) MustInformerFactoryForKey(key RegistryKey) informers.GenericInformer {
+	informer, err := r.InformerFactoryForKey(key)
+	if err != nil {
+		panic(err)
+	}
+	return informer
+}
+
+// InformerFactoryForKey returns GVR-specific InformerFactory from the Registry
+// or returns an error if the key is not found.
+func (r *Registry) InformerFactoryForKey(key RegistryKey) (informers.GenericInformer, error) {
 	r.RLock()
 	defer r.RUnlock()
 	factory, ok := r.factories[key.FactoryKey]
 	if !ok {
-		panic(fmt.Errorf("InformerFactoryFor called with unknown key %s", key))
+		return nil, fmt.Errorf("InformerFactoryFor called with unknown key %s", key)
 	}
-	return factory.ForResource(key.GroupVersionResource)
+	return factory.ForResource(key.GroupVersionResource), nil
 }
 
 // ListerFor returns the GVR-specific Lister from the Registry
+// Deprecated: use MustListerForKey instead.
 func (r *Registry) ListerFor(key RegistryKey) cache.GenericLister {
-	return r.InformerFactoryFor(key).Lister()
+	return r.MustInformerFactoryForKey(key).Lister()
+}
+
+// MustListerForKey returns the GVR-specific Lister from the Registry, or panics
+// if the key is not found.
+func (r *Registry) MustListerForKey(key RegistryKey) cache.GenericLister {
+	return r.MustInformerFactoryForKey(key).Lister()
+}
+
+// ListerForKey returns the GVR-specific Lister from the Registry, or an error
+// if the key is not found.
+func (r *Registry) ListerForKey(key RegistryKey) (cache.GenericLister, error) {
+	factory, err := r.InformerFactoryForKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return factory.Lister(), nil
 }
 
 // InformerFor returns the GVR-specific Informer from the Registry
+// Deprecated: use MustInformerForKey instead.
 func (r *Registry) InformerFor(key RegistryKey) cache.SharedIndexInformer {
-	return r.InformerFactoryFor(key).Informer()
+	return r.MustInformerFactoryForKey(key).Informer()
+}
+
+// MustInformerForKey returns the GVR-specific Informer from the Registry, or panics
+// if the key is not found.
+func (r *Registry) MustInformerForKey(key RegistryKey) cache.SharedIndexInformer {
+	return r.MustInformerFactoryForKey(key).Informer()
+}
+
+// InformerForKey returns the GVR-specific Informer from the Registry, or an error
+// if the key is not found.
+func (r *Registry) InformerForKey(key RegistryKey) (cache.SharedIndexInformer, error) {
+	factory, err := r.InformerFactoryForKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return factory.Informer(), nil
 }
 
 // IndexerFor returns the GVR-specific Indexer from the Registry
+// Deprecated: use MustIndexerForKey instead.
 func (r *Registry) IndexerFor(key RegistryKey) cache.Indexer {
-	return r.InformerFactoryFor(key).Informer().GetIndexer()
+	return r.MustInformerForKey(key).GetIndexer()
+}
+
+// MustIndexerForKey returns the GVR-specific Indexer from the Registry, or panics
+// if the key is not found.
+func (r *Registry) MustIndexerForKey(key RegistryKey) cache.Indexer {
+	return r.MustInformerForKey(key).GetIndexer()
+}
+
+// IndexerForKey returns the GVR-specific Indexer from the Registry, or an error
+// if the key is not found.
+func (r *Registry) IndexerForKey(key RegistryKey) (cache.Indexer, error) {
+	informer, err := r.InformerForKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return informer.GetIndexer(), nil
 }

typed/registry_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -92,7 +93,7 @@ func ExampleListerFor() {
 
 	dependentSecretKey := NewRegistryKey(dependentObjectKey, secretGVR)
 
-	cachedSecret, _ := ListerFor[*corev1.Secret](registry, dependentSecretKey).ByNamespace("example").Get("mysecret")
+	cachedSecret, _ := MustListerForKey[*corev1.Secret](registry, dependentSecretKey).ByNamespace("example").Get("mysecret")
 	fmt.Printf("%T %s/%s", cachedSecret, cachedSecret.GetNamespace(), cachedSecret.GetName())
 	// Output: *v1.Secret example/mysecret
 }
@@ -131,7 +132,7 @@ func ExampleIndexerFor() {
 	const indexName = "ExampleIndex"
 	const constantIndexValue = "indexVal"
 	if err := informerFactory.ForResource(secretGVR).Informer().AddIndexers(map[string]cache.IndexFunc{
-		indexName: func(obj interface{}) ([]string, error) {
+		indexName: func(_ interface{}) ([]string, error) {
 			return []string{constantIndexValue}, nil
 		},
 	}); err != nil {
@@ -143,7 +144,7 @@ func ExampleIndexerFor() {
 
 	dependentSecretKey := NewRegistryKey(dependentObjectKey, secretGVR)
 
-	matchingCachedSecrets, _ := IndexerFor[*corev1.Secret](registry, dependentSecretKey).ByIndex(indexName, constantIndexValue)
+	matchingCachedSecrets, _ := MustIndexerForKey[*corev1.Secret](registry, dependentSecretKey).ByIndex(indexName, constantIndexValue)
 	fmt.Printf("%T %s/%s", matchingCachedSecrets, matchingCachedSecrets[0].GetNamespace(), matchingCachedSecrets[0].GetName())
 	// Output: []*v1.Secret example/mysecret
 }
@@ -176,3 +177,69 @@ func TestRemove(_ *testing.T) {
 
 	registry.Remove(dependentObjectKey)
 }
+
+func TestForKey(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	registry := NewRegistry()
+
+	secretGVR := corev1.SchemeGroupVersion.WithResource("secrets")
+	scheme := runtime.NewScheme()
+	if err := corev1.AddToScheme(scheme); err != nil {
+		panic(err)
+	}
+	client := fake.NewSimpleDynamicClient(scheme)
+	dependentObjectKey := NewFactoryKey("my-controller", "localCluster", "dependentObjects")
+	informerFactory := registry.MustNewFilteredDynamicSharedInformerFactory(
+		dependentObjectKey,
+		client,
+		0,
+		metav1.NamespaceAll,
+		func(options *metav1.ListOptions) {
+			options.LabelSelector = "my-controller.com/related-to=myobjecttype"
+		},
+	)
+	informerFactory.ForResource(secretGVR)
+	informerFactory.Start(ctx.Done())
+	informerFactory.WaitForCacheSync(ctx.Done())
+
+	// good key works
+	dependentSecretKey := NewRegistryKey(dependentObjectKey, secretGVR)
+	require.NotPanics(t, func() {
+		registry.MustInformerFactoryForKey(dependentSecretKey)
+		registry.MustListerForKey(dependentSecretKey)
+		registry.MustIndexerForKey(dependentSecretKey)
+		MustListerForKey[*corev1.Secret](registry, dependentSecretKey)
+		MustIndexerForKey[*corev1.Secret](registry, dependentSecretKey)
+	})
+
+	// bad key panics Must*ForKey
+	badKey := NewRegistryKey(NewFactoryKey("other-controller", "othercluster", "dependentObjects"), corev1.SchemeGroupVersion.WithResource("pods"))
+	require.Panics(t, func() {
+		registry.MustInformerFactoryForKey(badKey)
+	})
+	require.Panics(t, func() {
+		registry.MustListerForKey(badKey)
+	})
+	require.Panics(t, func() {
+		registry.MustIndexerForKey(badKey)
+	})
+	require.Panics(t, func() {
+		MustListerForKey[*corev1.Pod](registry, badKey)
+	})
+	require.Panics(t, func() {
+		MustIndexerForKey[*corev1.Pod](registry, badKey)
+	})
+
+	// bad key returns error for *ForKey
+	_, err := registry.InformerFactoryForKey(badKey)
+	require.Error(t, err)
+	_, err = registry.ListerForKey(badKey)
+	require.Error(t, err)
+	_, err = registry.IndexerForKey(badKey)
+	require.Error(t, err)
+	_, err = ListerForKey[*corev1.Pod](registry, badKey)
+	require.Error(t, err)
+	_, err = IndexerForKey[*corev1.Pod](registry, badKey)
+	require.Error(t, err)
+}