From 7d74eb3ab0b341e733f4d921c0390046720d0616 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Charles-Edouard=20Br=C3=A9t=C3=A9ch=C3=A9?= Date: Thu, 31 Aug 2023 22:08:29 +0200 Subject: [PATCH] fix: propagate registration and error in controllerutils pkg (#8192) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Charles-Edouard Brétéché --- pkg/controllers/certmanager/controller.go | 6 ++- pkg/controllers/cleanup/controller.go | 18 +++++--- .../generic/configmap/controller.go | 4 +- pkg/controllers/generic/logging/controller.go | 4 +- pkg/controllers/generic/webhook/controller.go | 10 +++-- pkg/controllers/metrics/policy/controller.go | 8 +++- pkg/controllers/policycache/controller.go | 8 +++- .../report/admission/controller.go | 12 +++-- .../report/aggregate/controller.go | 28 ++++++++---- .../report/background/controller.go | 16 +++++-- pkg/controllers/report/resource/controller.go | 8 +++- .../controller.go | 12 +++-- pkg/controllers/webhook/controller.go | 26 +++++++---- pkg/utils/controller/handlers.go | 45 +++++++++++-------- 14 files changed, 141 insertions(+), 64 deletions(-) diff --git a/pkg/controllers/certmanager/controller.go b/pkg/controllers/certmanager/controller.go index 1bd53ff8ae..b6dad1ae26 100644 --- a/pkg/controllers/certmanager/controller.go +++ b/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), - tlsEnqueue: controllerutils.AddDefaultEventHandlers(logger, tlsInformer.Informer(), queue), + caEnqueue: caEnqueue, + tlsEnqueue: tlsEnqueue, caSecretName: caSecretName, tlsSecretName: tlsSecretName, namespace: namespace, diff --git a/pkg/controllers/cleanup/controller.go b/pkg/controllers/cleanup/controller.go index df7cdfd3f1..15a8899740 100644 --- a/pkg/controllers/cleanup/controller.go +++ b/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")), - ) - controllerutils.AddEventHandlersT( + ); err != nil { + 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")), - ) - controllerutils.AddEventHandlersT( + ); err != nil { + 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 } diff --git a/pkg/controllers/generic/configmap/controller.go b/pkg/controllers/generic/configmap/controller.go index ec4b66d74a..ac6ea42c25 100644 --- a/pkg/controllers/generic/configmap/controller.go +++ b/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 } diff --git a/pkg/controllers/generic/logging/controller.go b/pkg/controllers/generic/logging/controller.go index a982e969f9..a17f9656b0 100644 --- a/pkg/controllers/generic/logging/controller.go +++ b/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) { diff --git a/pkg/controllers/generic/webhook/controller.go b/pkg/controllers/generic/webhook/controller.go index 389d26ddd9..bc6a354289 100644 --- a/pkg/controllers/generic/webhook/controller.go +++ b/pkg/controllers/generic/webhook/controller.go @@ -97,8 +97,10 @@ func NewController( labelSelector: labelSelector, caSecretName: caSecretName, } - controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue) - controllerutils.AddEventHandlersT( + if _, _, err := controllerutils.AddDefaultEventHandlers(c.logger, vwcInformer.Informer(), queue); err != nil { + 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 } diff --git a/pkg/controllers/metrics/policy/controller.go b/pkg/controllers/metrics/policy/controller.go index 8f5805f635..3d76a4a60a 100644 --- a/pkg/controllers/metrics/policy/controller.go +++ b/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) - controllerutils.AddEventHandlers(polInformer.Informer(), c.addNsPolicy, c.updateNsPolicy, c.deleteNsPolicy) + if _, err := controllerutils.AddEventHandlers(cpolInformer.Informer(), c.addPolicy, c.updatePolicy, c.deletePolicy); err != nil { + 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 { diff --git a/pkg/controllers/policycache/controller.go b/pkg/controllers/policycache/controller.go index a5993530b5..aa42377ebb 100644 --- a/pkg/controllers/policycache/controller.go +++ b/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) - controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue) + if _, _, err := controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue); err != nil { + 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 } diff --git a/pkg/controllers/report/admission/controller.go b/pkg/controllers/report/admission/controller.go index 20edb0bbf0..3c837f7c2d 100644 --- a/pkg/controllers/report/admission/controller.go +++ b/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))) }, - ) - controllerutils.AddEventHandlersT( + ); err != nil { + 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 } diff --git a/pkg/controllers/report/aggregate/controller.go b/pkg/controllers/report/aggregate/controller.go index d5f83c81d2..408ac2d71a 100644 --- a/pkg/controllers/report/aggregate/controller.go +++ b/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) - controllerutils.AddDelayedExplicitEventHandlers(logger, cpolrInformer.Informer(), c.queue, enqueueDelay, keyFunc) - controllerutils.AddDelayedExplicitEventHandlers(logger, bgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc) - controllerutils.AddDelayedExplicitEventHandlers(logger, cbgscanrInformer.Informer(), c.queue, enqueueDelay, keyFunc) + if _, _, err := controllerutils.AddDelayedExplicitEventHandlers(logger, polrInformer.Informer(), c.queue, enqueueDelay, keyFunc); err != nil { + logger.Error(err, "failed to register even handlers") + } + 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) }, - ) - controllerutils.AddEventHandlersT( + ); err != nil { + 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 } diff --git a/pkg/controllers/report/background/controller.go b/pkg/controllers/report/background/controller.go index b821ed2259..5c35466a97 100644 --- a/pkg/controllers/report/background/controller.go +++ b/pkg/controllers/report/background/controller.go @@ -104,10 +104,18 @@ func NewController( eventGen: eventGen, policyReports: policyReports, } - controllerutils.AddDefaultEventHandlers(logger, bgscanr.Informer(), queue) - controllerutils.AddDefaultEventHandlers(logger, cbgscanr.Informer(), queue) - 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, bgscanr.Informer(), queue); err != nil { + logger.Error(err, "failed to register even handlers") + } + 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 { diff --git a/pkg/controllers/report/resource/controller.go b/pkg/controllers/report/resource/controller.go index 29deb7d6f4..0d0fde1b78 100644 --- a/pkg/controllers/report/resource/controller.go +++ b/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) - controllerutils.AddDefaultEventHandlers(logger, cpolInformer.Informer(), c.queue) + if _, _, err := controllerutils.AddDefaultEventHandlers(logger, polInformer.Informer(), c.queue); err != nil { + 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 } diff --git a/pkg/controllers/validatingadmissionpolicy-generate/controller.go b/pkg/controllers/validatingadmissionpolicy-generate/controller.go index f425075b4b..e5b77dd06d 100644 --- a/pkg/controllers/validatingadmissionpolicy-generate/controller.go +++ b/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 } diff --git a/pkg/controllers/webhook/controller.go b/pkg/controllers/webhook/controller.go index 57f121a14b..d0877bf9be 100644 --- a/pkg/controllers/webhook/controller.go +++ b/pkg/controllers/webhook/controller.go @@ -156,9 +156,13 @@ func NewController( config.ValidatingWebhookConfigurationName: sets.New[string](), }, } - controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue) - controllerutils.AddDefaultEventHandlers(logger, vwcInformer.Informer(), queue) - controllerutils.AddEventHandlersT( + if _, _, err := controllerutils.AddDefaultEventHandlers(logger, mwcInformer.Informer(), queue); err != nil { + logger.Error(err, "failed to register even handlers") + } + 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() } }, - ) - controllerutils.AddEventHandlers( + ); err != nil { + 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) }, - ) - controllerutils.AddEventHandlers( + ); err != nil { + 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 } diff --git a/pkg/utils/controller/handlers.go b/pkg/utils/controller/handlers.go index db992fe329..c3e68eb3f6 100644 --- a/pkg/utils/controller/handlers.go +++ b/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) { - _, _ = informer.AddEventHandler(cache.ResourceEventHandlerFuncs{ +func AddEventHandlers(informer cache.SharedInformer, a addFunc, u updateFunc, d deleteFunc) (cache.ResourceEventHandlerRegistration, error) { + 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]) { - AddEventHandlers( +func AddEventHandlersT[T any](informer cache.SharedInformer, a addFuncT[T], u updateFuncT[T], d deleteFuncT[T]) (cache.ResourceEventHandlerRegistration, error) { + 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)) - return enqueueFunc + if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil { + 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)) - return enqueueFunc + if registration, err := AddEventHandlersT(informer, AddFuncT(logger, enqueueFunc), UpdateFuncT(logger, enqueueFunc), DeleteFuncT(logger, enqueueFunc)); err != nil { + 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)) - return enqueueFunc + if registration, err := AddEventHandlers(informer, AddFunc(logger, enqueueFunc), UpdateFunc(logger, enqueueFunc), DeleteFunc(logger, enqueueFunc)); err != nil { + 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)) }