fix: propagate registration and error in controllerutils pkg (#8192)

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>

pkg/controllers/certmanager/controller.go

@@ -50,13 +50,15 @@ func NewController(
 	namespace string,
 ) controllers.Controller {
 	queue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName)
+	caEnqueue, _, _ := controllerutils.AddDefaultEventHandlers(logger, caInformer.Informer(), queue)
+	tlsEnqueue, _, _ := controllerutils.AddDefaultEventHandlers(logger, tlsInformer.Informer(), queue)
 	c := controller{
 		renewer:       certRenewer,
 		caLister:      caInformer.Lister(),
 		tlsLister:     tlsInformer.Lister(),
 		queue:         queue,
-		caEnqueue:     controllerutils.AddDefaultEventHandlers(logger, caInformer.Informer(), queue),
+		caEnqueue:     caEnqueue,
-		tlsEnqueue:    controllerutils.AddDefaultEventHandlers(logger, tlsInformer.Informer(), queue),
+		tlsEnqueue:    tlsEnqueue,
 		caSecretName:  caSecretName,
 		tlsSecretName: tlsSecretName,
 		namespace:     namespace,

pkg/controllers/cleanup/controller.go

@@ -85,24 +85,30 @@ func NewController(
 		cleanupService: cleanupService,
 		enqueue:        baseEnqueueFunc,
 	}
-	controllerutils.AddEventHandlersT(
+	if _, err := controllerutils.AddEventHandlersT(
 		cpolInformer.Informer(),
 		controllerutils.AddFuncT(logger, enqueueFunc(logger, "added", "ClusterCleanupPolicy")),
 		controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "ClusterCleanupPolicy")),
 		controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "ClusterCleanupPolicy")),
-	)
+	); err != nil {
-	controllerutils.AddEventHandlersT(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		polInformer.Informer(),
 		controllerutils.AddFuncT(logger, enqueueFunc(logger, "added", "CleanupPolicy")),
 		controllerutils.UpdateFuncT(logger, enqueueFunc(logger, "updated", "CleanupPolicy")),
 		controllerutils.DeleteFuncT(logger, enqueueFunc(logger, "deleted", "CleanupPolicy")),
-	)
+	); err != nil {
-	controllerutils.AddEventHandlersT(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		cjInformer.Informer(),
 		func(n *batchv1.CronJob) { c.enqueueCronJob(n) },
 		func(o *batchv1.CronJob, n *batchv1.CronJob) { c.enqueueCronJob(o) },
 		func(n *batchv1.CronJob) { c.enqueueCronJob(n) },
-	)
+	); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	return c
 }
 

pkg/controllers/generic/configmap/controller.go

@@ -63,7 +63,9 @@ func NewController(
 		name:           name,
 		callback:       callback,
 	}
-	controllerutils.AddDefaultEventHandlers(c.logger, informer.Informer(), c.queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, informer.Informer(), c.queue); err != nil {
+		logging.Error(err, "failed to register even handlers")
+	}
 	return &c
 }
 

pkg/controllers/generic/logging/controller.go

@@ -31,7 +31,9 @@ func NewController(logger logr.Logger, objectType string, informer informer, pre
 		logger:     logger.WithValues("type", objectType),
 		predicates: predicates,
 	}
-	controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete)
+	if _, err := controllerutils.AddEventHandlersT(informer.Informer(), c.add, c.update, c.delete); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 }
 
 func (c *controller) add(obj metav1.Object) {

pkg/controllers/generic/webhook/controller.go

@@ -97,8 +97,10 @@ func NewController(
 		labelSelector:  labelSelector,
 		caSecretName:   caSecretName,
 	}
-	controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue); err != nil {
-	controllerutils.AddEventHandlersT(
+		c.logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		secretInformer.Informer(),
 		func(obj *corev1.Secret) {
 			if obj.GetNamespace() == config.KyvernoNamespace() && obj.GetName() == caSecretName {
@@ -115,7 +117,9 @@ func NewController(
 				c.enqueue()
 			}
 		},
-	)
+	); err != nil {
+		c.logger.Error(err, "failed to register even handlers")
+	}
 	configuration.OnChanged(c.enqueue)
 	return &c
 }

pkg/controllers/metrics/policy/controller.go

@@ -52,8 +52,12 @@ func NewController(
 		polLister:     polInformer.Lister(),
 		waitGroup:     waitGroup,
 	}
-	controllerutils.AddEventHandlers(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
+	if _, err := controllerutils.AddEventHandlers(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
-	controllerutils.AddEventHandlers(polInformer.Informer(), c.addNsPolicy, c.updateNsPolicy, c.deleteNsPolicy)
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlers(polInformer.Informer(), c.addNsPolicy, c.updateNsPolicy, c.deleteNsPolicy); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	if c.ruleInfo != nil {
 		_, err := meter.RegisterCallback(c.report, c.ruleInfo)
 		if err != nil {

pkg/controllers/policycache/controller.go

@@ -53,8 +53,12 @@ func NewController(client dclient.Interface, pcache pcache.Cache, cpolInformer k
 		queue:      workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName),
 		client:     client,
 	}
-	controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil {
-	controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue)
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	return &c
 }
 

pkg/controllers/report/admission/controller.go

@@ -62,18 +62,22 @@ func NewController(
 		cadmrLister: cadmrInformer.Lister(),
 		queue:       queue,
 	}
-	controllerutils.AddEventHandlersT(
+	if _, err := controllerutils.AddEventHandlersT(
 		admrInformer.Informer(),
 		func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
 		func(old, obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(old))) },
 		func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
-	)
+	); err != nil {
-	controllerutils.AddEventHandlersT(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		cadmrInformer.Informer(),
 		func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
 		func(old, obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(old))) },
 		func(obj metav1.Object) { queue.Add(cache.ExplicitKey(reportutils.GetResourceUid(obj))) },
-	)
+	); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	return &c
 }
 

pkg/controllers/report/aggregate/controller.go

@@ -95,28 +95,40 @@ func NewController(
 		metadataCache:  metadataCache,
 		chunkSize:      chunkSize,
 	}
-	controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
+	if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
-	controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
+		logger.Error(err, "failed to register even handlers")
-	controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
+	}
-	controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc)
+	if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	enqueueFromAdmr := func(obj metav1.Object) {
 		// no need to consider non aggregated reports
 		if controllerutils.HasLabel(obj, reportutils.LabelAggregatedReport) {
 			c.queue.AddAfter(keyFunc(obj), enqueueDelay)
 		}
 	}
-	controllerutils.AddEventHandlersT(
+	if _, err := controllerutils.AddEventHandlersT(
 		admrInformer.Informer(),
 		func(obj metav1.Object) { enqueueFromAdmr(obj) },
 		func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
 		func(obj metav1.Object) { enqueueFromAdmr(obj) },
-	)
+	); err != nil {
-	controllerutils.AddEventHandlersT(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		cadmrInformer.Informer(),
 		func(obj metav1.Object) { enqueueFromAdmr(obj) },
 		func(_, obj metav1.Object) { enqueueFromAdmr(obj) },
 		func(obj metav1.Object) { enqueueFromAdmr(obj) },
-	)
+	); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	return &c
 }
 

pkg/controllers/report/background/controller.go

@@ -104,10 +104,18 @@ func NewController(
 		eventGen:       eventGen,
 		policyReports:  policyReports,
 	}
-	controllerutils.AddDefaultEventHandlers(logger, bgscanr.Informer(), queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, bgscanr.Informer(), queue); err != nil {
-	controllerutils.AddDefaultEventHandlers(logger, cbgscanr.Informer(), queue)
+		logger.Error(err, "failed to register even handlers")
-	controllerutils.AddEventHandlersT(polInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
+	}
-	controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cbgscanr.Informer(), queue); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(polInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	c.metadataCache.AddEventHandler(func(eventType resource.EventType, uid types.UID, _ schema.GroupVersionKind, res resource.Resource) {
 		// if it's a deletion, nothing to do
 		if eventType == resource.Deleted {

pkg/controllers/report/resource/controller.go

@@ -97,8 +97,12 @@ func NewController(
 		queue:           workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), ControllerName),
 		dynamicWatchers: map[schema.GroupVersionResource]*watcher{},
 	}
-	controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil {
-	controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue)
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	return &c
 }
 

pkg/controllers/validatingadmissionpolicy-generate/controller.go

@@ -68,13 +68,19 @@ func NewController(
 	}
 
 	// Set up an event handler for when Kyverno policies change
-	controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy)
+	if _, err := controllerutils.AddEventHandlersT(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 
 	// Set up an event handler for when validating admission policies change
-	controllerutils.AddEventHandlersT(vapInformer.Informer(), c.addVAP, c.updateVAP, c.deleteVAP)
+	if _, err := controllerutils.AddEventHandlersT(vapInformer.Informer(), c.addVAP, c.updateVAP, c.deleteVAP); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 
 	// Set up an event handler for when validating admission policy bindings change
-	controllerutils.AddEventHandlersT(vapbindingInformer.Informer(), c.addVAPbinding, c.updateVAPbinding, c.deleteVAPbinding)
+	if _, err := controllerutils.AddEventHandlersT(vapbindingInformer.Informer(), c.addVAPbinding, c.updateVAPbinding, c.deleteVAPbinding); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 
 	return c
 }

pkg/controllers/webhook/controller.go

@@ -156,9 +156,13 @@ func NewController(
 			config.ValidatingWebhookConfigurationName: sets.New[string](),
 		},
 	}
-	controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue)
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue); err != nil {
-	controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue)
+		logger.Error(err, "failed to register even handlers")
-	controllerutils.AddEventHandlersT(
+	}
+	if _, _, err := controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlersT(
 		secretInformer.Informer(),
 		func(obj *corev1.Secret) {
 			if obj.GetNamespace() == config.KyvernoNamespace() && obj.GetName() == caSecretName {
@@ -175,19 +179,25 @@ func NewController(
 				c.enqueueAll()
 			}
 		},
-	)
+	); err != nil {
-	controllerutils.AddEventHandlers(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlers(
 		cpolInformer.Informer(),
 		func(interface{}) { c.enqueueResourceWebhooks(0) },
 		func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
 		func(interface{}) { c.enqueueResourceWebhooks(0) },
-	)
+	); err != nil {
-	controllerutils.AddEventHandlers(
+		logger.Error(err, "failed to register even handlers")
+	}
+	if _, err := controllerutils.AddEventHandlers(
 		polInformer.Informer(),
 		func(interface{}) { c.enqueueResourceWebhooks(0) },
 		func(interface{}, interface{}) { c.enqueueResourceWebhooks(0) },
 		func(interface{}) { c.enqueueResourceWebhooks(0) },
-	)
+	); err != nil {
+		logger.Error(err, "failed to register even handlers")
+	}
 	configuration.OnChanged(c.enqueueAll)
 	return &c
 }

pkg/utils/controller/handlers.go

@@ -24,8 +24,8 @@ type (
 	EnqueueFuncT[T any] func(T) error
 )
 
-func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d deleteFunc) {
+func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d deleteFunc) (cache.ResourceEventHandlerRegistration, error) {
-	_, _ = informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
+	return informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
 		AddFunc:    a,
 		UpdateFunc: u,
 		DeleteFunc: func(obj interface{}) {
@@ -34,8 +34,8 @@ func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d
 	})
 }
 
-func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u updateFuncT[T], d deleteFuncT[T]) {
+func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u updateFuncT[T], d deleteFuncT[T]) (cache.ResourceEventHandlerRegistration, error) {
-	AddEventHandlers(
+	return AddEventHandlers(
 		informer,
 		func(obj interface{}) { a(obj.(T)) },
 		func(old, obj interface{}) { u(old.(T), obj.(T)) },
@@ -43,41 +43,50 @@ func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u up
 	)
 }
 
-func AddKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFunc) EnqueueFunc {
+func AddKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFunc) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	enqueueFunc := LogError(logger, Parse(parseKey, Queue(queue)))
-	AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc))
+	if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil {
-	return enqueueFunc
+		return nil, nil, err
+	} else {
+		return enqueueFunc, registration, nil
+	}
 }
 
-func AddKeyedEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFuncT[K, interface{}]) EnqueueFuncT[K] {
+func AddKeyedEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey keyFuncT[K, interface{}]) (EnqueueFuncT[K], cache.ResourceEventHandlerRegistration, error) {
 	enqueueFunc := LogError(logger, Parse(parseKey, Queue(queue)))
-	AddEventHandlersT(informer, AddFuncT(logger, enqueueFunc), UpdateFuncT(logger, enqueueFunc), DeleteFuncT(logger, enqueueFunc))
+	if registration, err := AddEventHandlersT(informer, AddFuncT(logger, enqueueFunc), UpdateFuncT(logger, enqueueFunc), DeleteFuncT(logger, enqueueFunc)); err != nil {
-	return enqueueFunc
+		return nil, nil, err
+	} else {
+		return enqueueFunc, registration, nil
+	}
 }
 
-func AddDelayedKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey keyFunc) EnqueueFunc {
+func AddDelayedKeyedEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey keyFunc) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	enqueueFunc := LogError(logger, Parse(parseKey, QueueAfter(queue, delay)))
-	AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc))
+	if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil {
-	return enqueueFunc
+		return nil, nil, err
+	} else {
+		return enqueueFunc, registration, nil
+	}
 }
 
-func AddDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) EnqueueFunc {
+func AddDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	return AddKeyedEventHandlers(logger, informer, queue, MetaNamespaceKey)
 }
 
-func AddDefaultEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) EnqueueFuncT[K] {
+func AddDefaultEventHandlersT[K metav1.Object](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface) (EnqueueFuncT[K], cache.ResourceEventHandlerRegistration, error) {
 	return AddKeyedEventHandlersT(logger, informer, queue, MetaNamespaceKeyT[K])
 }
 
-func AddDelayedDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration) EnqueueFunc {
+func AddDelayedDefaultEventHandlers(logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	return AddDelayedKeyedEventHandlers(logger, informer, queue, delay, MetaNamespaceKey)
 }
 
-func AddExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey func(K) cache.ExplicitKey) EnqueueFunc {
+func AddExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, parseKey func(K) cache.ExplicitKey) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	return AddKeyedEventHandlers(logger, informer, queue, ExplicitKey(parseKey))
 }
 
-func AddDelayedExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey func(K) cache.ExplicitKey) EnqueueFunc {
+func AddDelayedExplicitEventHandlers[K any](logger logr.Logger, informer cache.SharedInformer, queue workqueue.RateLimitingInterface, delay time.Duration, parseKey func(K) cache.ExplicitKey) (EnqueueFunc, cache.ResourceEventHandlerRegistration, error) {
 	return AddDelayedKeyedEventHandlers(logger, informer, queue, delay, ExplicitKey(parseKey))
 }