package informers

import "k8s.io/client-go/informers"

Package informers provides generated informers for Kubernetes APIs.

Index ¶

• type GenericInformer
• type SharedInformerFactory
• func NewFilteredSharedInformerFactory(client kubernetes.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory
• func NewSharedInformerFactory(client kubernetes.Interface, defaultResync time.Duration) SharedInformerFactory
• func NewSharedInformerFactoryWithOptions(client kubernetes.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory
• type SharedInformerOption
• func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption
• func WithInformerName(informerName *cache.InformerName) SharedInformerOption
• func WithNamespace(namespace string) SharedInformerOption
• func WithTransform(transform cache.TransformFunc) SharedInformerOption
• func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption

Types ¶

type GenericInformer ¶

type GenericInformer interface {
	Informer() cache.SharedIndexInformer
	Lister() cache.GenericLister
}

GenericInformer is type of SharedIndexInformer which will locate and delegate to other sharedInformers based on type

type SharedInformerFactory ¶

type SharedInformerFactory interface {
	internalinterfaces.SharedInformerFactory

	// Start initializes all requested informers. They are handled in goroutines
	// which run until the stop channel gets closed.
	// Warning: Start does not block. When run in a go-routine, it will race with a later WaitForCacheSync.
	//
	// Contextual logging: StartWithContext should be used instead of Start in code which supports contextual logging.
	Start(stopCh <-chan struct{})

	// StartWithContext initializes all requested informers. They are handled in goroutines
	// which run until the context gets canceled.
	// Warning: StartWithContext does not block. When run in a go-routine, it will race with a later WaitForCacheSync.
	StartWithContext(ctx context.Context)

	// Shutdown marks a factory as shutting down. At that point no new
	// informers can be started anymore and Start will return without
	// doing anything.
	//
	// In addition, Shutdown blocks until all goroutines have terminated. For that
	// to happen, the close channel(s) that they were started with must be closed,
	// either before Shutdown gets called or while it is waiting.
	//
	// Shutdown may be called multiple times, even concurrently. All such calls will
	// block until all goroutines have terminated.
	Shutdown()

	// WaitForCacheSync blocks until all started informers' caches were synced
	// or the stop channel gets closed.
	//
	// Contextual logging: WaitForCacheSync should be used instead of WaitForCacheSync in code which supports contextual logging. It also returns a more useful result.
	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool

	// WaitForCacheSyncWithContext blocks until all started informers' caches were synced
	// or the context gets canceled.
	WaitForCacheSyncWithContext(ctx context.Context) cache.SyncResult

	// ForResource gives generic access to a shared informer of the matching type.
	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)

	// InformerFor returns the SharedIndexInformer for obj using an internal
	// client.
	InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer

	Admissionregistration() admissionregistration.Interface
	Internal() apiserverinternal.Interface
	Apps() apps.Interface
	Autoscaling() autoscaling.Interface
	Batch() batch.Interface
	Certificates() certificates.Interface
	Coordination() coordination.Interface
	Core() core.Interface
	Discovery() discovery.Interface
	Events() events.Interface
	Extensions() extensions.Interface
	Flowcontrol() flowcontrol.Interface
	Networking() networking.Interface
	Node() node.Interface
	Policy() policy.Interface
	Rbac() rbac.Interface
	Resource() resource.Interface
	Scheduling() scheduling.Interface
	Storage() storage.Interface
	Storagemigration() storagemigration.Interface
}

SharedInformerFactory provides shared informers for resources in all known API group versions.

It is typically used like this:

ctx, cancel := context.WithCancel(context.Background())
defer cancel()
factory := NewSharedInformerFactory(client, resyncPeriod)
defer factory.WaitForStop()    // Returns immediately if nothing was started.
genericInformer := factory.ForResource(resource)
typedInformer := factory.SomeAPIGroup().V1().SomeType()
handle, err := typeInformer.Informer().AddEventHandler(...)
if err != nil {
    return fmt.Errorf("register event handler: %v", err)
}
defer typeInformer.Informer().RemoveEventHandler(handle) // Avoids leaking goroutines.
factory.StartWithContext(ctx)                            // Start processing these informers.
synced := factory.WaitForCacheSyncWithContext(ctx)
if err := synced.AsError(); err != nil {
    return err
}
for v := range synced {
    // Only if desired log some information similar to this.
    fmt.Fprintf(os.Stdout, "cache synced: %s", v)
}

// Also make sure that all of the initial cache events have been delivered.
if !WaitFor(ctx, "event handler sync", handle.HasSyncedChecker()) {
    // Must have failed because of context.
    return fmt.Errorf("sync event handler: %w", context.Cause(ctx))
}

// Creating informers can also be created after Start, but then
// Start must be called again:
anotherGenericInformer := factory.ForResource(resource)
factory.StartWithContext(ctx)

func NewFilteredSharedInformerFactory ¶

func NewFilteredSharedInformerFactory(client kubernetes.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory

NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory. Listers obtained via this SharedInformerFactory will be subject to the same filters as specified here.

Deprecated: Please use NewSharedInformerFactoryWithOptions instead

func NewSharedInformerFactory ¶

func NewSharedInformerFactory(client kubernetes.Interface, defaultResync time.Duration) SharedInformerFactory

NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.

func NewSharedInformerFactoryWithOptions ¶

func NewSharedInformerFactoryWithOptions(client kubernetes.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory

NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.

type SharedInformerOption ¶

type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory

SharedInformerOption defines the functional option type for SharedInformerFactory.

func WithCustomResyncConfig ¶

func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption

WithCustomResyncConfig sets a custom resync period for the specified informer types.

func WithInformerName ¶

func WithInformerName(informerName *cache.InformerName) SharedInformerOption

WithInformerName sets the InformerName for informer identity used in metrics. The InformerName must be created via cache.NewInformerName() at startup, which validates global uniqueness. Each informer type will register its GVR under this name.

func WithNamespace ¶

func WithNamespace(namespace string) SharedInformerOption

WithNamespace limits the SharedInformerFactory to the specified namespace.

func WithTransform ¶

func WithTransform(transform cache.TransformFunc) SharedInformerOption

WithTransform sets a transform on all informers.

func WithTweakListOptions ¶

func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption

WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.

Source Files ¶

doc.go factory.go generic.go

Directories ¶