From d97d931a645952ebe7b3ddff48c1baf1d8338bf4 Mon Sep 17 00:00:00 2001 From: Troy Connor Date: Mon, 18 Sep 2023 10:02:29 -0400 Subject: [PATCH] pass watchErrorHandler through Options struct Signed-off-by: Troy Connor --- pkg/cache/cache.go | 10 ++++++++++ pkg/cache/internal/informers.go | 9 ++++----- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go index d8446e85b3..f944ec2bfe 100644 --- a/pkg/cache/cache.go +++ b/pkg/cache/cache.go @@ -188,6 +188,12 @@ type Options struct { // unless there is already one set in ByObject or DefaultNamespaces. DefaultTransform toolscache.TransformFunc + // DefaultWatchErrorHandler will be used to the WatchErrorHandler which is called + // whenever ListAndWatch drops the connection with an error. + // + // After calling this handler, the informer will backoff and retry. + DefaultWatchErrorHandler toolscache.WatchErrorHandler + // DefaultUnsafeDisableDeepCopy is the default for UnsafeDisableDeepCopy // for everything that doesn't specify this. // @@ -353,6 +359,7 @@ func newCache(restConfig *rest.Config, opts Options) newCacheFunc { Field: config.FieldSelector, }, Transform: config.Transform, + WatchErrorHandler: opts.DefaultWatchErrorHandler, UnsafeDisableDeepCopy: pointer.BoolDeref(config.UnsafeDisableDeepCopy, false), NewInformer: opts.newInformer, }), @@ -381,6 +388,9 @@ func defaultOpts(config *rest.Config, opts Options) (Options, error) { opts.Scheme = scheme.Scheme } + if opts.DefaultWatchErrorHandler == nil { + opts.DefaultWatchErrorHandler = toolscache.DefaultWatchErrorHandler + } // Construct a new Mapper if unset if opts.Mapper == nil { var err error diff --git a/pkg/cache/internal/informers.go b/pkg/cache/internal/informers.go index ac9ee3f36e..8971c6a110 100644 --- a/pkg/cache/internal/informers.go +++ b/pkg/cache/internal/informers.go @@ -55,13 +55,9 @@ type InformersOpts struct { // NewInformers creates a new InformersMap that can create informers under the hood. func NewInformers(config *rest.Config, options *InformersOpts) *Informers { newInformer := cache.NewSharedIndexInformer - watchErrorHandler := cache.DefaultWatchErrorHandler if options.NewInformer != nil { newInformer = *options.NewInformer } - if options.WatchErrorHandler != nil { - watchErrorHandler = options.WatchErrorHandler - } return &Informers{ config: config, httpClient: options.HTTPClient, @@ -81,7 +77,7 @@ func NewInformers(config *rest.Config, options *InformersOpts) *Informers { transform: options.Transform, unsafeDisableDeepCopy: options.UnsafeDisableDeepCopy, newInformer: newInformer, - watchErrorHandler: watchErrorHandler, + watchErrorHandler: options.WatchErrorHandler, } } @@ -166,6 +162,9 @@ type Informers struct { // NewInformer allows overriding of the shared index informer constructor for testing. newInformer func(cache.ListerWatcher, runtime.Object, time.Duration, cache.Indexers) cache.SharedIndexInformer + // WatchErrorHandler allows the shared index informer's + // watchErrorHandler to be set by overriding the options + // or to use the default watchErrorHandler watchErrorHandler cache.WatchErrorHandler }