rebase: update sigs.k8s.io/controller-runtime to current version

There is no release for sigs.k8s.io/controller-runtime that supports Kubernetes v1.27. The main branch has all the required modifications, so we can use that for the time being. Signed-off-by: Niels de Vos <ndevos@ibm.com>
2025-06-14 10:53:34 +00:00 · 2023-06-01 19:01:19 +02:00
parent 2551a0b05f
commit b1a4590967
74 changed files with 3412 additions and 3741 deletions
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go
@ -19,10 +19,11 @@ package cache
 import (
 	"context"
 	"fmt"
-	"reflect"
+	"net/http"
 	"time"

 	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
@ -37,7 +38,10 @@ import (
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )

-var log = logf.RuntimeLog.WithName("object-cache")
+var (
+	log               = logf.RuntimeLog.WithName("object-cache")
+	defaultSyncPeriod = 10 * time.Hour
+)

 // Cache knows how to load Kubernetes objects, fetch informers to request
 // to receive events for Kubernetes objects (at a low-level),
@ -98,310 +102,152 @@ type Informer interface {
 	HasSynced() bool
 }

-// ObjectSelector is an alias name of internal.Selector.
-type ObjectSelector internal.Selector
-
-// SelectorsByObject associate a client.Object's GVK to a field/label selector.
-// There is also `DefaultSelector` to set a global default (which will be overridden by
-// a more specific setting here, if any).
-type SelectorsByObject map[client.Object]ObjectSelector
-
 // Options are the optional arguments for creating a new InformersMap object.
 type Options struct {
+	// HTTPClient is the http client to use for the REST client
+	HTTPClient *http.Client
+
 	// Scheme is the scheme to use for mapping objects to GroupVersionKinds
 	Scheme *runtime.Scheme

 	// Mapper is the RESTMapper to use for mapping GroupVersionKinds to Resources
 	Mapper meta.RESTMapper

-	// Resync is the base frequency the informers are resynced.
-	// Defaults to defaultResyncTime.
-	// A 10 percent jitter will be added to the Resync period between informers
-	// So that all informers will not send list requests simultaneously.
-	Resync *time.Duration
+	// SyncPeriod determines the minimum frequency at which watched resources are
+	// reconciled. A lower period will correct entropy more quickly, but reduce
+	// responsiveness to change if there are many watched resources. Change this
+	// value only if you know what you are doing. Defaults to 10 hours if unset.
+	// there will a 10 percent jitter between the SyncPeriod of all controllers
+	// so that all controllers will not send list requests simultaneously.
+	//
+	// This applies to all controllers.
+	//
+	// A period sync happens for two reasons:
+	// 1. To insure against a bug in the controller that causes an object to not
+	// be requeued, when it otherwise should be requeued.
+	// 2. To insure against an unknown bug in controller-runtime, or its dependencies,
+	// that causes an object to not be requeued, when it otherwise should be
+	// requeued, or to be removed from the queue, when it otherwise should not
+	// be removed.
+	//
+	// If you want
+	// 1. to insure against missed watch events, or
+	// 2. to poll services that cannot be watched,
+	// then we recommend that, instead of changing the default period, the
+	// controller requeue, with a constant duration `t`, whenever the controller
+	// is "done" with an object, and would otherwise not requeue it, i.e., we
+	// recommend the `Reconcile` function return `reconcile.Result{RequeueAfter: t}`,
+	// instead of `reconcile.Result{}`.
+	SyncPeriod *time.Duration

-	// Namespace restricts the cache's ListWatch to the desired namespace
+	// Namespaces restricts the cache's ListWatch to the desired namespaces
 	// Default watches all namespaces
-	Namespace string
+	Namespaces []string

-	// SelectorsByObject restricts the cache's ListWatch to the desired
-	// fields per GVK at the specified object, the map's value must implement
-	// Selector [1] using for example a Set [2]
-	// [1] https://pkg.go.dev/k8s.io/apimachinery/pkg/fields#Selector
-	// [2] https://pkg.go.dev/k8s.io/apimachinery/pkg/fields#Set
-	SelectorsByObject SelectorsByObject
+	// DefaultLabelSelector will be used as a label selectors for all object types
+	// unless they have a more specific selector set in ByObject.
+	DefaultLabelSelector labels.Selector

-	// DefaultSelector will be used as selectors for all object types
-	// that do not have a selector in SelectorsByObject defined.
-	DefaultSelector ObjectSelector
+	// DefaultFieldSelector will be used as a field selectors for all object types
+	// unless they have a more specific selector set in ByObject.
+	DefaultFieldSelector fields.Selector

-	// UnsafeDisableDeepCopyByObject indicates not to deep copy objects during get or
-	// list objects per GVK at the specified object.
+	// DefaultTransform will be used as transform for all object types
+	// unless they have a more specific transform set in ByObject.
+	DefaultTransform toolscache.TransformFunc
+
+	// ByObject restricts the cache's ListWatch to the desired fields per GVK at the specified object.
+	ByObject map[client.Object]ByObject
+
+	// UnsafeDisableDeepCopy indicates not to deep copy objects during get or
+	// list objects for EVERY object.
 	// Be very careful with this, when enabled you must DeepCopy any object before mutating it,
 	// otherwise you will mutate the object in the cache.
-	UnsafeDisableDeepCopyByObject DisableDeepCopyByObject
+	//
+	// This is a global setting for all objects, and can be overridden by the ByObject setting.
+	UnsafeDisableDeepCopy *bool
+}

-	// TransformByObject is a map from GVKs to transformer functions which
+// ByObject offers more fine-grained control over the cache's ListWatch by object.
+type ByObject struct {
+	// Label represents a label selector for the object.
+	Label labels.Selector
+
+	// Field represents a field selector for the object.
+	Field fields.Selector
+
+	// Transform is a map from objects to transformer functions which
 	// get applied when objects of the transformation are about to be committed
 	// to cache.
 	//
 	// This function is called both for new objects to enter the cache,
-	// 	and for updated objects.
-	TransformByObject TransformByObject
+	// and for updated objects.
+	Transform toolscache.TransformFunc

-	// DefaultTransform is the transform used for all GVKs which do
-	// not have an explicit transform func set in TransformByObject
-	DefaultTransform toolscache.TransformFunc
+	// UnsafeDisableDeepCopy indicates not to deep copy objects during get or
+	// list objects per GVK at the specified object.
+	// Be very careful with this, when enabled you must DeepCopy any object before mutating it,
+	// otherwise you will mutate the object in the cache.
+	UnsafeDisableDeepCopy *bool
 }

-var defaultResyncTime = 10 * time.Hour
+// NewCacheFunc - Function for creating a new cache from the options and a rest config.
+type NewCacheFunc func(config *rest.Config, opts Options) (Cache, error)

 // New initializes and returns a new Cache.
 func New(config *rest.Config, opts Options) (Cache, error) {
+	if len(opts.Namespaces) == 0 {
+		opts.Namespaces = []string{metav1.NamespaceAll}
+	}
+	if len(opts.Namespaces) > 1 {
+		return newMultiNamespaceCache(config, opts)
+	}
+
 	opts, err := defaultOpts(config, opts)
 	if err != nil {
 		return nil, err
 	}
-	selectorsByGVK, err := convertToByGVK(opts.SelectorsByObject, opts.DefaultSelector, opts.Scheme)
+
+	byGVK, err := convertToInformerOptsByGVK(opts.ByObject, opts.Scheme)
 	if err != nil {
 		return nil, err
 	}
-	disableDeepCopyByGVK, err := convertToDisableDeepCopyByGVK(opts.UnsafeDisableDeepCopyByObject, opts.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	transformByGVK, err := convertToByGVK(opts.TransformByObject, opts.DefaultTransform, opts.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	transformByObj := internal.TransformFuncByObjectFromMap(transformByGVK)
-
-	internalSelectorsByGVK := internal.SelectorsByGVK{}
-	for gvk, selector := range selectorsByGVK {
-		internalSelectorsByGVK[gvk] = internal.Selector(selector)
+	// Set the default selector and transform.
+	byGVK[schema.GroupVersionKind{}] = internal.InformersOptsByGVK{
+		Selector: internal.Selector{
+			Label: opts.DefaultLabelSelector,
+			Field: opts.DefaultFieldSelector,
+		},
+		Transform:             opts.DefaultTransform,
+		UnsafeDisableDeepCopy: opts.UnsafeDisableDeepCopy,
 	}

-	im := internal.NewInformersMap(config, opts.Scheme, opts.Mapper, *opts.Resync, opts.Namespace, internalSelectorsByGVK, disableDeepCopyByGVK, transformByObj)
-	return &informerCache{InformersMap: im}, nil
-}
-
-// BuilderWithOptions returns a Cache constructor that will build a cache
-// honoring the options argument, this is useful to specify options like
-// SelectorsByObject
-// WARNING: If SelectorsByObject is specified, filtered out resources are not
-// returned.
-// WARNING: If UnsafeDisableDeepCopy is enabled, you must DeepCopy any object
-// returned from cache get/list before mutating it.
-func BuilderWithOptions(options Options) NewCacheFunc {
-	return func(config *rest.Config, inherited Options) (Cache, error) {
-		var err error
-		inherited, err = defaultOpts(config, inherited)
-		if err != nil {
-			return nil, err
-		}
-		options, err = defaultOpts(config, options)
-		if err != nil {
-			return nil, err
-		}
-		combined, err := options.inheritFrom(inherited)
-		if err != nil {
-			return nil, err
-		}
-		return New(config, *combined)
-	}
-}
-
-func (options Options) inheritFrom(inherited Options) (*Options, error) {
-	var (
-		combined Options
-		err      error
-	)
-	combined.Scheme = combineScheme(inherited.Scheme, options.Scheme)
-	combined.Mapper = selectMapper(inherited.Mapper, options.Mapper)
-	combined.Resync = selectResync(inherited.Resync, options.Resync)
-	combined.Namespace = selectNamespace(inherited.Namespace, options.Namespace)
-	combined.SelectorsByObject, combined.DefaultSelector, err = combineSelectors(inherited, options, combined.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	combined.UnsafeDisableDeepCopyByObject, err = combineUnsafeDeepCopy(inherited, options, combined.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	combined.TransformByObject, combined.DefaultTransform, err = combineTransforms(inherited, options, combined.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	return &combined, nil
-}
-
-func combineScheme(schemes ...*runtime.Scheme) *runtime.Scheme {
-	var out *runtime.Scheme
-	for _, sch := range schemes {
-		if sch == nil {
-			continue
-		}
-		for gvk, t := range sch.AllKnownTypes() {
-			if out == nil {
-				out = runtime.NewScheme()
-			}
-			out.AddKnownTypeWithName(gvk, reflect.New(t).Interface().(runtime.Object))
-		}
-	}
-	return out
-}
-
-func selectMapper(def, override meta.RESTMapper) meta.RESTMapper {
-	if override != nil {
-		return override
-	}
-	return def
-}
-
-func selectResync(def, override *time.Duration) *time.Duration {
-	if override != nil {
-		return override
-	}
-	return def
-}
-
-func selectNamespace(def, override string) string {
-	if override != "" {
-		return override
-	}
-	return def
-}
-
-func combineSelectors(inherited, options Options, scheme *runtime.Scheme) (SelectorsByObject, ObjectSelector, error) {
-	// Selectors are combined via logical AND.
-	//  - Combined label selector is a union of the selectors requirements from both sets of options.
-	//  - Combined field selector uses fields.AndSelectors with the combined list of non-nil field selectors
-	//    defined in both sets of options.
-	//
-	// There is a bunch of complexity here because we need to convert to SelectorsByGVK
-	// to be able to match keys between options and inherited and then convert back to SelectorsByObject
-	optionsSelectorsByGVK, err := convertToByGVK(options.SelectorsByObject, options.DefaultSelector, scheme)
-	if err != nil {
-		return nil, ObjectSelector{}, err
-	}
-	inheritedSelectorsByGVK, err := convertToByGVK(inherited.SelectorsByObject, inherited.DefaultSelector, inherited.Scheme)
-	if err != nil {
-		return nil, ObjectSelector{}, err
-	}
-
-	for gvk, inheritedSelector := range inheritedSelectorsByGVK {
-		optionsSelectorsByGVK[gvk] = combineSelector(inheritedSelector, optionsSelectorsByGVK[gvk])
-	}
-	return convertToByObject(optionsSelectorsByGVK, scheme)
-}
-
-func combineSelector(selectors ...ObjectSelector) ObjectSelector {
-	ls := make([]labels.Selector, 0, len(selectors))
-	fs := make([]fields.Selector, 0, len(selectors))
-	for _, s := range selectors {
-		ls = append(ls, s.Label)
-		fs = append(fs, s.Field)
-	}
-	return ObjectSelector{
-		Label: combineLabelSelectors(ls...),
-		Field: combineFieldSelectors(fs...),
-	}
-}
-
-func combineLabelSelectors(ls ...labels.Selector) labels.Selector {
-	var combined labels.Selector
-	for _, l := range ls {
-		if l == nil {
-			continue
-		}
-		if combined == nil {
-			combined = labels.NewSelector()
-		}
-		reqs, _ := l.Requirements()
-		combined = combined.Add(reqs...)
-	}
-	return combined
-}
-
-func combineFieldSelectors(fs ...fields.Selector) fields.Selector {
-	nonNil := fs[:0]
-	for _, f := range fs {
-		if f == nil {
-			continue
-		}
-		nonNil = append(nonNil, f)
-	}
-	if len(nonNil) == 0 {
-		return nil
-	}
-	if len(nonNil) == 1 {
-		return nonNil[0]
-	}
-	return fields.AndSelectors(nonNil...)
-}
-
-func combineUnsafeDeepCopy(inherited, options Options, scheme *runtime.Scheme) (DisableDeepCopyByObject, error) {
-	// UnsafeDisableDeepCopyByObject is combined via precedence. Only if a value for a particular GVK is unset
-	// in options will a value from inherited be used.
-	optionsDisableDeepCopyByGVK, err := convertToDisableDeepCopyByGVK(options.UnsafeDisableDeepCopyByObject, options.Scheme)
-	if err != nil {
-		return nil, err
-	}
-	inheritedDisableDeepCopyByGVK, err := convertToDisableDeepCopyByGVK(inherited.UnsafeDisableDeepCopyByObject, inherited.Scheme)
-	if err != nil {
-		return nil, err
-	}
-
-	for gvk, inheritedDeepCopy := range inheritedDisableDeepCopyByGVK {
-		if _, ok := optionsDisableDeepCopyByGVK[gvk]; !ok {
-			if optionsDisableDeepCopyByGVK == nil {
-				optionsDisableDeepCopyByGVK = map[schema.GroupVersionKind]bool{}
-			}
-			optionsDisableDeepCopyByGVK[gvk] = inheritedDeepCopy
-		}
-	}
-	return convertToDisableDeepCopyByObject(optionsDisableDeepCopyByGVK, scheme)
-}
-
-func combineTransforms(inherited, options Options, scheme *runtime.Scheme) (TransformByObject, toolscache.TransformFunc, error) {
-	// Transform functions are combined via chaining. If both inherited and options define a transform
-	// function, the transform function from inherited will be called first, and the transform function from
-	// options will be called second.
-	optionsTransformByGVK, err := convertToByGVK(options.TransformByObject, options.DefaultTransform, options.Scheme)
-	if err != nil {
-		return nil, nil, err
-	}
-	inheritedTransformByGVK, err := convertToByGVK(inherited.TransformByObject, inherited.DefaultTransform, inherited.Scheme)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	for gvk, inheritedTransform := range inheritedTransformByGVK {
-		if optionsTransformByGVK == nil {
-			optionsTransformByGVK = map[schema.GroupVersionKind]toolscache.TransformFunc{}
-		}
-		optionsTransformByGVK[gvk] = combineTransform(inheritedTransform, optionsTransformByGVK[gvk])
-	}
-	return convertToByObject(optionsTransformByGVK, scheme)
-}
-
-func combineTransform(inherited, current toolscache.TransformFunc) toolscache.TransformFunc {
-	if inherited == nil {
-		return current
-	}
-	if current == nil {
-		return inherited
-	}
-	return func(in interface{}) (interface{}, error) {
-		mid, err := inherited(in)
-		if err != nil {
-			return nil, err
-		}
-		return current(mid)
-	}
+	return &informerCache{
+		scheme: opts.Scheme,
+		Informers: internal.NewInformers(config, &internal.InformersOpts{
+			HTTPClient:   opts.HTTPClient,
+			Scheme:       opts.Scheme,
+			Mapper:       opts.Mapper,
+			ResyncPeriod: *opts.SyncPeriod,
+			Namespace:    opts.Namespaces[0],
+			ByGVK:        byGVK,
+		}),
+	}, nil
 }

 func defaultOpts(config *rest.Config, opts Options) (Options, error) {
+	logger := log.WithName("setup")
+
+	// Use the rest HTTP client for the provided config if unset
+	if opts.HTTPClient == nil {
+		var err error
+		opts.HTTPClient, err = rest.HTTPClientFor(config)
+		if err != nil {
+			logger.Error(err, "Failed to get HTTP client")
+			return opts, fmt.Errorf("could not create HTTP client from config: %w", err)
+		}
+	}
+
 	// Use the default Kubernetes Scheme if unset
 	if opts.Scheme == nil {
 		opts.Scheme = scheme.Scheme
@ -410,108 +256,38 @@ func defaultOpts(config *rest.Config, opts Options) (Options, error) {
 	// Construct a new Mapper if unset
 	if opts.Mapper == nil {
 		var err error
-		opts.Mapper, err = apiutil.NewDiscoveryRESTMapper(config)
+		opts.Mapper, err = apiutil.NewDiscoveryRESTMapper(config, opts.HTTPClient)
 		if err != nil {
-			log.WithName("setup").Error(err, "Failed to get API Group-Resources")
-			return opts, fmt.Errorf("could not create RESTMapper from config")
+			logger.Error(err, "Failed to get API Group-Resources")
+			return opts, fmt.Errorf("could not create RESTMapper from config: %w", err)
 		}
 	}

 	// Default the resync period to 10 hours if unset
-	if opts.Resync == nil {
-		opts.Resync = &defaultResyncTime
+	if opts.SyncPeriod == nil {
+		opts.SyncPeriod = &defaultSyncPeriod
 	}
 	return opts, nil
 }

-func convertToByGVK[T any](byObject map[client.Object]T, def T, scheme *runtime.Scheme) (map[schema.GroupVersionKind]T, error) {
-	byGVK := map[schema.GroupVersionKind]T{}
-	for object, value := range byObject {
+func convertToInformerOptsByGVK(in map[client.Object]ByObject, scheme *runtime.Scheme) (map[schema.GroupVersionKind]internal.InformersOptsByGVK, error) {
+	out := map[schema.GroupVersionKind]internal.InformersOptsByGVK{}
+	for object, byObject := range in {
 		gvk, err := apiutil.GVKForObject(object, scheme)
 		if err != nil {
 			return nil, err
 		}
-		byGVK[gvk] = value
-	}
-	byGVK[schema.GroupVersionKind{}] = def
-	return byGVK, nil
-}
-
-func convertToByObject[T any](byGVK map[schema.GroupVersionKind]T, scheme *runtime.Scheme) (map[client.Object]T, T, error) {
-	var byObject map[client.Object]T
-	def := byGVK[schema.GroupVersionKind{}]
-	for gvk, value := range byGVK {
-		if gvk == (schema.GroupVersionKind{}) {
-			continue
+		if _, ok := out[gvk]; ok {
+			return nil, fmt.Errorf("duplicate cache options for GVK %v, cache.Options.ByObject has multiple types with the same GroupVersionKind", gvk)
 		}
-		obj, err := scheme.New(gvk)
-		if err != nil {
-			return nil, def, err
-		}
-		cObj, ok := obj.(client.Object)
-		if !ok {
-			return nil, def, fmt.Errorf("object %T for GVK %q does not implement client.Object", obj, gvk)
-		}
-		cObj.GetObjectKind().SetGroupVersionKind(gvk)
-		if byObject == nil {
-			byObject = map[client.Object]T{}
-		}
-		byObject[cObj] = value
-	}
-	return byObject, def, nil
-}
-
-// DisableDeepCopyByObject associate a client.Object's GVK to disable DeepCopy during get or list from cache.
-type DisableDeepCopyByObject map[client.Object]bool
-
-var _ client.Object = &ObjectAll{}
-
-// ObjectAll is the argument to represent all objects' types.
-type ObjectAll struct {
-	client.Object
-}
-
-func convertToDisableDeepCopyByGVK(disableDeepCopyByObject DisableDeepCopyByObject, scheme *runtime.Scheme) (internal.DisableDeepCopyByGVK, error) {
-	disableDeepCopyByGVK := internal.DisableDeepCopyByGVK{}
-	for obj, disable := range disableDeepCopyByObject {
-		switch obj.(type) {
-		case ObjectAll, *ObjectAll:
-			disableDeepCopyByGVK[internal.GroupVersionKindAll] = disable
-		default:
-			gvk, err := apiutil.GVKForObject(obj, scheme)
-			if err != nil {
-				return nil, err
-			}
-			disableDeepCopyByGVK[gvk] = disable
+		out[gvk] = internal.InformersOptsByGVK{
+			Selector: internal.Selector{
+				Field: byObject.Field,
+				Label: byObject.Label,
+			},
+			Transform:             byObject.Transform,
+			UnsafeDisableDeepCopy: byObject.UnsafeDisableDeepCopy,
 		}
 	}
-	return disableDeepCopyByGVK, nil
+	return out, nil
 }
-
-func convertToDisableDeepCopyByObject(byGVK internal.DisableDeepCopyByGVK, scheme *runtime.Scheme) (DisableDeepCopyByObject, error) {
-	var byObject DisableDeepCopyByObject
-	for gvk, value := range byGVK {
-		if byObject == nil {
-			byObject = DisableDeepCopyByObject{}
-		}
-		if gvk == (schema.GroupVersionKind{}) {
-			byObject[ObjectAll{}] = value
-			continue
-		}
-		obj, err := scheme.New(gvk)
-		if err != nil {
-			return nil, err
-		}
-		cObj, ok := obj.(client.Object)
-		if !ok {
-			return nil, fmt.Errorf("object %T for GVK %q does not implement client.Object", obj, gvk)
-		}
-
-		byObject[cObj] = value
-	}
-	return byObject, nil
-}
-
-// TransformByObject associate a client.Object's GVK to a transformer function
-// to be applied when storing the object into the cache.
-type TransformByObject map[client.Object]toolscache.TransformFunc