Documentation

Overview

    Package source provides event streams to hook up to Controllers with Controller.Watch. Events are used with handler.EventHandlers to enqueue reconcile.Requests and trigger Reconciles for Kubernetes objects.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Channel

    type Channel struct {
    
    	// Source is the source channel to fetch GenericEvents
    	Source <-chan event.GenericEvent
    
    	// DestBufferSize is the specified buffer size of dest channels.
    	// Default to 1024 if not specified.
    	DestBufferSize int
    	// contains filtered or unexported fields
    }

      Channel is used to provide a source of events originating outside the cluster (e.g. GitHub Webhook callback). Channel requires the user to wire the external source (eh.g. http handler) to write GenericEvents to the underlying channel.

      Example

        This example reads GenericEvents from a channel and enqueues a reconcile.Request containing the Name and Namespace provided by the event.

        Output:
        
        

        func (*Channel) InjectStopChannel

        func (cs *Channel) InjectStopChannel(stop <-chan struct{}) error

          InjectStopChannel is internal should be called only by the Controller. It is used to inject the stop channel initialized by the ControllerManager.

          func (*Channel) Start

            Start implements Source and should only be called by the Controller.

            func (*Channel) String

            func (cs *Channel) String() string

            type Func

              Func is a function that implements Source

              func (Func) Start

                Start implements Source

                func (Func) String

                func (f Func) String() string

                type Informer

                type Informer struct {
                	// Informer is the controller-runtime Informer
                	Informer cache.Informer
                }

                  Informer is used to provide a source of events originating inside the cluster from Watches (e.g. Pod Create)

                  func (*Informer) Start

                    Start is internal and should be called only by the Controller to register an EventHandler with the Informer to enqueue reconcile.Requests.

                    func (*Informer) String

                    func (is *Informer) String() string

                    type Kind

                    type Kind struct {
                    	// Type is the type of object to watch.  e.g. &v1.Pod{}
                    	Type client.Object
                    	// contains filtered or unexported fields
                    }

                      Kind is used to provide a source of events originating inside the cluster from Watches (e.g. Pod Create)

                      Example

                        This example Watches for Pod Events (e.g. Create / Update / Delete) and enqueues a reconcile.Request with the Name and Namespace of the Pod.

                        Output:
                        
                        

                        func (*Kind) InjectCache

                        func (ks *Kind) InjectCache(c cache.Cache) error

                          InjectCache is internal should be called only by the Controller. InjectCache is used to inject the Cache dependency initialized by the ControllerManager.

                          func (*Kind) Start

                            Start is internal and should be called only by the Controller to register an EventHandler with the Informer to enqueue reconcile.Requests.

                            func (*Kind) String

                            func (ks *Kind) String() string

                            func (*Kind) WaitForSync

                            func (ks *Kind) WaitForSync(ctx context.Context) error

                              WaitForSync implements SyncingSource to allow controllers to wait with starting workers until the cache is synced.

                              type Source

                              type Source interface {
                              	// Start is internal and should be called only by the Controller to register an EventHandler with the Informer
                              	// to enqueue reconcile.Requests.
                              	Start(context.Context, handler.EventHandler, workqueue.RateLimitingInterface, ...predicate.Predicate) error
                              }

                                Source is a source of events (eh.g. Create, Update, Delete operations on Kubernetes Objects, Webhook callbacks, etc) which should be processed by event.EventHandlers to enqueue reconcile.Requests.

                                * Use Kind for events originating in the cluster (e.g. Pod Create, Pod Update, Deployment Update).

                                * Use Channel for events originating outside the cluster (eh.g. GitHub Webhook callback, Polling external urls).

                                Users may build their own Source implementations. If their implementations implement any of the inject package interfaces, the dependencies will be injected by the Controller when Watch is called.

                                type SyncingSource

                                type SyncingSource interface {
                                	Source
                                	WaitForSync(ctx context.Context) error
                                }

                                  SyncingSource is a source that needs syncing prior to being usable. The controller will call its WaitForSync prior to starting workers.

                                  func NewKindWithCache

                                  func NewKindWithCache(object client.Object, cache cache.Cache) SyncingSource

                                    NewKindWithCache creates a Source without InjectCache, so that it is assured that the given cache is used and not overwritten. It can be used to watch objects in a different cluster by passing the cache from that other cluster

                                    Source Files

                                    Directories

                                    Path Synopsis