informers

Documentation

Index

• type GenericClusterInformer
• type ScopedDynamicSharedInformerFactory
• type SharedInformerFactory
  • func NewFilteredSharedInformerFactory(client kcpkubernetes.ClusterInterface, defaultResync time.Duration, ...) SharedInformerFactory
  • func NewSharedInformerFactory(client kcpkubernetes.ClusterInterface, defaultResync time.Duration) SharedInformerFactory
  • func NewSharedInformerFactoryWithOptions(client kcpkubernetes.ClusterInterface, defaultResync time.Duration, ...) SharedInformerFactory
• type SharedInformerOption
  • func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption
  • func WithTransform(transform cache.TransformFunc) SharedInformerOption
  • func WithTweakListOptions(tweakListOptions kcpinternalinterfaces.TweakListOptionsFunc) SharedInformerOption
• type SharedInformerOptions

Types

type GenericClusterInformer

type GenericClusterInformer interface {
	Cluster(logicalcluster.Name) clientgoinformers.GenericInformer
	ClusterWithContext(context.Context, logicalcluster.Name) clientgoinformers.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) (clientgoinformers.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 {
	kcpinternalinterfaces.SharedInformerFactory

	Cluster(logicalcluster.Name) ScopedDynamicSharedInformerFactory

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

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

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

	// InformerFor returns the SharedIndexInformer for obj using an internal
	// client.
	InformerFor(obj runtime.Object, newFunc kcpinternalinterfaces.NewInformerFunc) kcpcache.ScopeableSharedIndexInformer

	Admissionregistration() kcpadmissionregistration.ClusterInterface
	Internal() kcpapiserverinternal.ClusterInterface
	Apps() kcpapps.ClusterInterface
	Autoscaling() kcpautoscaling.ClusterInterface
	Batch() kcpbatch.ClusterInterface
	Certificates() kcpcertificates.ClusterInterface
	Coordination() kcpcoordination.ClusterInterface
	Core() kcpcore.ClusterInterface
	Discovery() kcpdiscovery.ClusterInterface
	Events() kcpevents.ClusterInterface
	Extensions() kcpextensions.ClusterInterface
	Flowcontrol() kcpflowcontrol.ClusterInterface
	Networking() kcpnetworking.ClusterInterface
	Node() kcpnode.ClusterInterface
	Policy() kcppolicy.ClusterInterface
	Rbac() kcprbac.ClusterInterface
	Resource() kcpresource.ClusterInterface
	Scheduling() kcpscheduling.ClusterInterface
	Storage() kcpstorage.ClusterInterface
	Storagemigration() kcpstoragemigration.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 := NewSharedInformerFactory(client, resyncPeriod)
defer factory.WaitForStop()    // 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 NewFilteredSharedInformerFactory

func NewFilteredSharedInformerFactory(client kcpkubernetes.ClusterInterface, defaultResync time.Duration, tweakListOptions kcpinternalinterfaces.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 kcpkubernetes.ClusterInterface, defaultResync time.Duration) SharedInformerFactory

NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.

func NewSharedInformerFactoryWithOptions

func NewSharedInformerFactoryWithOptions(client kcpkubernetes.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[v1.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 kcpinternalinterfaces.TweakListOptionsFunc) SharedInformerOption

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

type SharedInformerOptions

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