informers

Documentation

Index

• type GenericClusterInformer
• 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 WithTransform(transform cache.TransformFunc) SharedInformerOption
  • func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption
• type SharedInformerOptions

Types

type GenericClusterInformer

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

type ScopedDynamicSharedInformerFactory

type ScopedDynamicSharedInformerFactory interface {
	// ForResource gives generic access to a shared informer of the matching type.
	ForResource(resource schema.GroupVersionResource) (upstreaminformers.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

	Admissionregistration() admissionregistrationinformers.ClusterInterface
	Internal() apiserverinternalinformers.ClusterInterface
	Apps() appsinformers.ClusterInterface
	Autoscaling() autoscalinginformers.ClusterInterface
	Batch() batchinformers.ClusterInterface
	Certificates() certificatesinformers.ClusterInterface
	Coordination() coordinationinformers.ClusterInterface
	Core() coreinformers.ClusterInterface
	Discovery() discoveryinformers.ClusterInterface
	Events() eventsinformers.ClusterInterface
	Extensions() extensionsinformers.ClusterInterface
	Flowcontrol() flowcontrolinformers.ClusterInterface
	Networking() networkinginformers.ClusterInterface
	Node() nodeinformers.ClusterInterface
	Policy() policyinformers.ClusterInterface
	Rbac() rbacinformers.ClusterInterface
	Resource() resourceinformers.ClusterInterface
	Scheduling() schedulinginformers.ClusterInterface
	Storage() storageinformers.ClusterInterface
	Storagemigration() storagemigrationinformers.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 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.

type SharedInformerOptions

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