informers

Documentation

Index

• type GenericClusterInformer
• type GenericInformer
• type ScopedDynamicSharedInformerFactory
• type SharedInformerFactory
  • func NewSharedInformerFactory(client clientset.ClusterInterface, defaultResync time.Duration) SharedInformerFactory
  • func NewSharedInformerFactoryWithOptions(client clientset.ClusterInterface, defaultResync time.Duration, ...) SharedInformerFactory
• type SharedInformerOption
  • func WithCustomResyncConfig(resyncConfig map[metav1.Object]time.Duration) SharedInformerOption
  • func WithNamespace(namespace string) SharedInformerOption
  • func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption
• type SharedInformerOptions
• type SharedScopedInformerFactory
  • func NewSharedScopedInformerFactory(client scopedclientset.Interface, defaultResync time.Duration, ...) SharedScopedInformerFactory
  • func NewSharedScopedInformerFactoryWithOptions(client scopedclientset.Interface, defaultResync time.Duration, ...) SharedScopedInformerFactory

Types

type GenericClusterInformer

type GenericClusterInformer interface {
	Cluster(logicalcluster.Name) GenericInformer
	Informer() kcpcache.ScopeableSharedIndexInformer
	Lister() kcpcache.GenericClusterLister
}

type GenericInformer

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

type ScopedDynamicSharedInformerFactory

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

	// Start initializes all requested informers. They are handled in goroutines
	// which run until the stop channel gets closed.
	Start(stopCh <-chan struct{})
}

type SharedInformerFactory

type SharedInformerFactory interface {
	internalinterfaces.SharedInformerFactory

	Cluster(logicalcluster.Name) ScopedDynamicSharedInformerFactory

	// Start initializes all requested informers. They are handled in goroutines
	// which run until the stop channel gets closed.
	Start(stopCh <-chan struct{})

	// 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()

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

	// WaitForCacheSync blocks until all started informers' caches were synced
	// or the stop channel gets closed.
	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool

	// InformerFor returns the SharedIndexInformer for obj.
	InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) kcpcache.ScopeableSharedIndexInformer

	Apiresource() apiresourceinformers.ClusterInterface
	Scheduling() schedulinginformers.ClusterInterface
	Workload() workloadinformers.ClusterInterface
}

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

It is typically used like this:

ctx, cancel := context.Background()
defer cancel()
factory := NewSharedInformerFactoryWithOptions(client, resyncPeriod)
defer factory.Shutdown()    // Returns immediately if nothing was started.
genericInformer := factory.ForResource(resource)
typedInformer := factory.SomeAPIGroup().V1().SomeType()
factory.Start(ctx.Done())          // Start processing these informers.
synced := factory.WaitForCacheSync(ctx.Done())
for v, ok := range synced {
    if !ok {
        fmt.Fprintf(os.Stderr, "caches failed to sync: %v", v)
        return
    }
}

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

func NewSharedInformerFactory

func NewSharedInformerFactory(client clientset.ClusterInterface, defaultResync time.Duration) SharedInformerFactory

NewSharedInformerFactory constructs a new instance of SharedInformerFactory for all namespaces.

func NewSharedInformerFactoryWithOptions

func NewSharedInformerFactoryWithOptions(client clientset.ClusterInterface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory

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

type SharedInformerOption

type SharedInformerOption func(*SharedInformerOptions) *SharedInformerOptions

SharedInformerOption defines the functional option type for SharedInformerFactory.

func WithCustomResyncConfig

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

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

func WithNamespace

func WithNamespace(namespace string) SharedInformerOption

WithNamespace limits the SharedInformerFactory to the specified namespace.

func WithTweakListOptions

func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption

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

type SharedInformerOptions

type SharedInformerOptions struct {
	// contains filtered or unexported fields
}

type SharedScopedInformerFactory

type SharedScopedInformerFactory interface {
	internalinterfaces.SharedScopedInformerFactory
	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool

	Apiresource() apiresourceinformers.Interface
	Scheduling() schedulinginformers.Interface
	Workload() workloadinformers.Interface
}

SharedScopedInformerFactory provides shared informers for resources in all known API group versions, scoped to one workspace.

func NewSharedScopedInformerFactory

func NewSharedScopedInformerFactory(client scopedclientset.Interface, defaultResync time.Duration, namespace string) SharedScopedInformerFactory

NewSharedScopedInformerFactory constructs a new instance of SharedInformerFactory for some or all namespaces.

func NewSharedScopedInformerFactoryWithOptions

func NewSharedScopedInformerFactoryWithOptions(client scopedclientset.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedScopedInformerFactory

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