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



    This section is empty.


    This section is empty.


    This section is empty.


    type Cache

    type Cache interface {
    	// Cache acts as a client to objects stored in the cache.
    	// Cache loads informers and adds field indices.

      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 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.

              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 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. 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 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

                    Options are the optional arguments for creating a new InformersMap object


                    Path Synopsis