cache

Documentation

Overview

Package cache provides object caches that act as caching client.Reader instances and help drive Kubernetes-object-based event handlers.

Index

• type Cache
  • func New(config *rest.Config, opts Options) (Cache, error)
• type DisableDeepCopyByObject
• type ErrCacheNotStarted
  • func (*ErrCacheNotStarted) Error() string
• type Informer
• type Informers
• type NewCacheFunc
  • func BuilderWithOptions(options Options) NewCacheFunc
  • func MultiNamespacedCacheBuilder(namespaces []string) NewCacheFunc
• type ObjectAll
• type ObjectSelector
• type Options
• type SelectorsByObject
• type TransformByObject

Types

type Cache

type Cache interface {
	// Cache acts as a client to objects stored in the cache.
	client.Reader

	// Cache loads informers and adds field indices.
	Informers
}

Cache knows how to load Kubernetes objects, fetch informers to request to receive events for Kubernetes objects (at a low-level), and add indices to fields on the objects stored in the cache.

func New

func New(config *rest.Config, opts Options) (Cache, error)

New initializes and returns a new Cache.

type DisableDeepCopyByObject

type DisableDeepCopyByObject map[client.Object]bool

DisableDeepCopyByObject associate a client.Object's GVK to disable DeepCopy during get or list from cache.

type ErrCacheNotStarted

type ErrCacheNotStarted struct{}

ErrCacheNotStarted is returned when trying to read from the cache that wasn't started.

func (*ErrCacheNotStarted) Error

func (*ErrCacheNotStarted) Error() string

type Informer

type Informer interface {
	// AddEventHandler adds an event handler to the shared informer using the shared informer's resync
	// period.  Events to a single handler are delivered sequentially, but there is no coordination
	// between different handlers.
	AddEventHandler(handler toolscache.ResourceEventHandler)
	// AddEventHandlerWithResyncPeriod adds an event handler to the shared informer using the
	// specified resync period.  Events to a single handler are delivered sequentially, but there is
	// no coordination between different handlers.
	AddEventHandlerWithResyncPeriod(handler toolscache.ResourceEventHandler, resyncPeriod time.Duration)
	// AddIndexers adds more indexers to this store.  If you call this after you already have data
	// in the store, the results are undefined.
	AddIndexers(indexers toolscache.Indexers) error
	// HasSynced return true if the informers underlying store has synced.
	HasSynced() bool
}

Informer - informer allows you interact with the underlying informer.

type Informers

type Informers interface {
	// GetInformer fetches or constructs an informer for the given object that corresponds to a single
	// API kind and resource.
	GetInformer(ctx context.Context, obj client.Object) (Informer, error)

	// GetInformerForKind is similar to GetInformer, except that it takes a group-version-kind, instead
	// of the underlying object.
	GetInformerForKind(ctx context.Context, gvk schema.GroupVersionKind) (Informer, error)

	// Start runs all the informers known to this cache until the context is closed.
	// It blocks.
	Start(ctx context.Context) error

	// WaitForCacheSync waits for all the caches to sync.  Returns false if it could not sync a cache.
	WaitForCacheSync(ctx context.Context) bool

	// Informers knows how to add indices to the caches (informers) that it manages.
	client.FieldIndexer
}

Informers knows how to create or fetch informers for different group-version-kinds, and add indices to those informers. It's safe to call GetInformer from multiple threads.

type NewCacheFunc

type NewCacheFunc func(config *rest.Config, opts Options) (Cache, error)

NewCacheFunc - Function for creating a new cache from the options and a rest config.

func BuilderWithOptions

func BuilderWithOptions(options Options) NewCacheFunc

BuilderWithOptions returns a Cache constructor that will build the 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 MultiNamespacedCacheBuilder

func MultiNamespacedCacheBuilder(namespaces []string) NewCacheFunc

MultiNamespacedCacheBuilder - Builder function to create a new multi-namespaced cache. This will scope the cache to a list of namespaces. Listing for all namespaces will list for all the namespaces that this knows about. By default this will create a global cache for cluster scoped resource. Note that this is not intended to be used for excluding namespaces, this is better done via a Predicate. Also note that you may face performance issues when using this with a high number of namespaces.

type ObjectAll

type ObjectAll struct {
	client.Object
}

ObjectAll is the argument to represent all objects' types.

type ObjectSelector

type ObjectSelector internal.Selector

ObjectSelector is an alias name of internal.Selector.

type Options

type Options struct {
	// 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

	// Namespace restricts the cache's ListWatch to the desired namespace
	// Default watches all namespaces
	Namespace 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

	// DefaultSelector will be used as selectors for all object types
	// that do not have a selector in SelectorsByObject defined.
	DefaultSelector ObjectSelector

	// UnsafeDisableDeepCopyByObject 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.
	UnsafeDisableDeepCopyByObject DisableDeepCopyByObject

	// TransformByObject is a map from GVKs 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

	// DefaultTransform is the transform used for all GVKs which do
	// not have an explicit transform func set in TransformByObject
	DefaultTransform toolscache.TransformFunc
}

Options are the optional arguments for creating a new InformersMap object.

type SelectorsByObject

type SelectorsByObject map[client.Object]ObjectSelector

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 TransformByObject

type TransformByObject map[client.Object]toolscache.TransformFunc

TransformByObject associate a client.Object's GVK to a transformer function to be applied when storing the object into the cache.