controller

Documentation

Index

• Constants
• Variables
• func Filter(gvk schema.GroupVersionKind) func(obj interface{}) bool
• func FilterGroupKind(gk schema.GroupKind) func(obj interface{}) bool
• func FilterGroupVersionKind(gvk schema.GroupVersionKind) func(obj interface{}) bool
• func FilterWithName(name string) func(obj interface{}) bool
• func FilterWithNameAndNamespace(namespace, name string) func(obj interface{}) bool
• func GetEventRecorder(ctx context.Context) record.EventRecorder
• func GetResyncPeriod(ctx context.Context) time.Duration
• func GetTrackerLease(ctx context.Context) time.Duration
• func HandleAll(h func(interface{})) cache.ResourceEventHandler
• func IsPermanentError(err error) bool
• func NewPermanentError(err error) error
• func PassNew(f func(interface{})) func(interface{}, interface{})
• func RunInformers(stopCh <-chan struct{}, informers ...Informer) (func(), error)
• func StartAll(stopCh <-chan struct{}, controllers ...*Impl)
• func StartInformers(stopCh <-chan struct{}, informers ...Informer) error
• func WithEventRecorder(ctx context.Context, er record.EventRecorder) context.Context
• func WithResyncPeriod(ctx context.Context, resync time.Duration) context.Context
• type Callback
  • func EnsureTypeMeta(f Callback, gvk schema.GroupVersionKind) Callback
• type Impl
  • func NewImpl(r Reconciler, logger *zap.SugaredLogger, workQueueName string) *Impl
  • func NewImplWithStats(r Reconciler, logger *zap.SugaredLogger, workQueueName string, ...) *Impl
  • func (c *Impl) Enqueue(obj interface{})
  • func (c *Impl) EnqueueAfter(obj interface{}, after time.Duration)
  • func (c *Impl) EnqueueControllerOf(obj interface{})
  • func (c *Impl) EnqueueKey(key types.NamespacedName)
  • func (c *Impl) EnqueueKeyAfter(key types.NamespacedName, delay time.Duration)
  • func (c *Impl) EnqueueLabelOfClusterScopedResource(nameLabel string) func(obj interface{})
  • func (c *Impl) EnqueueLabelOfNamespaceScopedResource(namespaceLabel, nameLabel string) func(obj interface{})
  • func (c *Impl) EnqueueSentinel(k types.NamespacedName) func(interface{})
  • func (c *Impl) FilteredGlobalResync(f func(interface{}) bool, si cache.SharedInformer)
  • func (c *Impl) GlobalResync(si cache.SharedInformer)
  • func (c *Impl) Run(threadiness int, stopCh <-chan struct{}) error
• type Informer
• type Options
• type OptionsFn
• type Reconciler
• type StatsReporter
  • func MustNewStatsReporter(reconciler string, logger *zap.SugaredLogger) StatsReporter
  • func NewStatsReporter(reconciler string) (StatsReporter, error)

Constants

const (

	// DefaultResyncPeriod is the default duration that is used when no
	// resync period is associated with a controllers initialization context.
	DefaultResyncPeriod = 10 * time.Hour
)

Variables

var (
	// DefaultThreadsPerController is the number of threads to use
	// when processing the controller's workqueue.  Controller binaries
	// may adjust this process-wide default.  For finer control, invoke
	// Run on the controller directly.
	DefaultThreadsPerController = 2
)

Functions

func Filter

func Filter(gvk schema.GroupVersionKind) func(obj interface{}) bool

Filter makes it simple to create FilterFunc's for use with cache.FilteringResourceEventHandler that filter based on the schema.GroupVersionKind of the controlling resources.

Deprecated: Use FilterGroupVersionKind or FilterGroupKind instead

func FilterGroupKind

func FilterGroupKind(gk schema.GroupKind) func(obj interface{}) bool

FilterGroupKind makes it simple to create FilterFunc's for use with cache.FilteringResourceEventHandler that filter based on the schema.GroupKind of the controlling resources.

func FilterGroupVersionKind

func FilterGroupVersionKind(gvk schema.GroupVersionKind) func(obj interface{}) bool

FilterGroupVersionKind makes it simple to create FilterFunc's for use with cache.FilteringResourceEventHandler that filter based on the schema.GroupVersionKind of the controlling resources.

func FilterWithName

func FilterWithName(name string) func(obj interface{}) bool

FilterWithName makes it simple to create FilterFunc's for use with cache.FilteringResourceEventHandler that filter based on a name.

func FilterWithNameAndNamespace

func FilterWithNameAndNamespace(namespace, name string) func(obj interface{}) bool

FilterWithNameAndNamespace makes it simple to create FilterFunc's for use with cache.FilteringResourceEventHandler that filter based on a namespace and a name.

func GetEventRecorder

func GetEventRecorder(ctx context.Context) record.EventRecorder

GetEventRecorder attempts to look up the record.EventRecorder on a given context. It may return null if none is found.

func GetResyncPeriod

func GetResyncPeriod(ctx context.Context) time.Duration

GetResyncPeriod returns the resync period associated with the given context. When none is specified a default resync period is used.

func GetTrackerLease

func GetTrackerLease(ctx context.Context) time.Duration

GetTrackerLease fetches the tracker lease from the controller context.

func HandleAll

func HandleAll(h func(interface{})) cache.ResourceEventHandler

HandleAll wraps the provided handler function into a cache.ResourceEventHandler that sends all events to the given handler. For Updates, only the new object is forwarded.

func IsPermanentError

func IsPermanentError(err error) bool

IsPermanentError returns true if given error is permanentError

func NewPermanentError

func NewPermanentError(err error) error

NewPermanentError returns a new instance of permanentError. Users can wrap an error as permanentError with this in reconcile, when he does not expect the key to get re-queued.

func PassNew

func PassNew(f func(interface{})) func(interface{}, interface{})

PassNew makes it simple to create an UpdateFunc for use with cache.ResourceEventHandlerFuncs that can delegate the same methods as AddFunc/DeleteFunc but passing through only the second argument (which is the "new" object).

func RunInformers

func RunInformers(stopCh <-chan struct{}, informers ...Informer) (func(), error)

RunInformers kicks off all of the passed informers and then waits for all of them to synchronize. Returned function will wait for all informers to finish.

func StartAll

func StartAll(stopCh <-chan struct{}, controllers ...*Impl)

StartAll kicks off all of the passed controllers with DefaultThreadsPerController.

func StartInformers

func StartInformers(stopCh <-chan struct{}, informers ...Informer) error

StartInformers kicks off all of the passed informers and then waits for all of them to synchronize.

func WithEventRecorder

func WithEventRecorder(ctx context.Context, er record.EventRecorder) context.Context

WithEventRecorder attaches the given record.EventRecorder to the provided context in the returned context.

func WithResyncPeriod

func WithResyncPeriod(ctx context.Context, resync time.Duration) context.Context

WithResyncPeriod associates the given resync period with the given context in the context that is returned.

Types

type Callback

type Callback func(interface{})

func EnsureTypeMeta

func EnsureTypeMeta(f Callback, gvk schema.GroupVersionKind) Callback

type Impl

type Impl struct {
	// Reconciler is the workhorse of this controller, it is fed the keys
	// from the workqueue to process.  Public for testing.
	Reconciler Reconciler

	// WorkQueue is a rate limited work queue. This is used to queue work to be
	// processed instead of performing it as soon as a change happens. This
	// means we can ensure we only process a fixed amount of resources at a
	// time, and makes it easy to ensure we are never processing the same item
	// simultaneously in two different workers.
	WorkQueue workqueue.RateLimitingInterface
	// contains filtered or unexported fields
}

Impl is our core controller implementation. It handles queuing and feeding work from the queue to an implementation of Reconciler.

func NewImpl

func NewImpl(r Reconciler, logger *zap.SugaredLogger, workQueueName string) *Impl

NewImpl instantiates an instance of our controller that will feed work to the provided Reconciler as it is enqueued.

func NewImplWithStats

func NewImplWithStats(r Reconciler, logger *zap.SugaredLogger, workQueueName string, reporter StatsReporter) *Impl

func (*Impl) Enqueue

func (c *Impl) Enqueue(obj interface{})

Enqueue takes a resource, converts it into a namespace/name string, and passes it to EnqueueKey.

func (*Impl) EnqueueAfter

func (c *Impl) EnqueueAfter(obj interface{}, after time.Duration)

EnqueueAfter takes a resource, converts it into a namespace/name string, and passes it to EnqueueKey.

func (*Impl) EnqueueControllerOf

func (c *Impl) EnqueueControllerOf(obj interface{})

EnqueueControllerOf takes a resource, identifies its controller resource, converts it into a namespace/name string, and passes that to EnqueueKey.

func (*Impl) EnqueueKey

func (c *Impl) EnqueueKey(key types.NamespacedName)

EnqueueKey takes a namespace/name string and puts it onto the work queue.

func (*Impl) EnqueueKeyAfter

func (c *Impl) EnqueueKeyAfter(key types.NamespacedName, delay time.Duration)

EnqueueKeyAfter takes a namespace/name string and schedules its execution in the work queue after given delay.

func (*Impl) EnqueueLabelOfClusterScopedResource

func (c *Impl) EnqueueLabelOfClusterScopedResource(nameLabel string) func(obj interface{})

EnqueueLabelOfClusterScopedResource returns with an Enqueue func that takes a resource, identifies its controller resource through given name label, and passes it to EnqueueKey. The controller resource must be of cluster-scoped.

func (*Impl) EnqueueLabelOfNamespaceScopedResource

func (c *Impl) EnqueueLabelOfNamespaceScopedResource(namespaceLabel, nameLabel string) func(obj interface{})

EnqueueLabelOfNamespaceScopedResource returns with an Enqueue func that takes a resource, identifies its controller resource through given namespace and name labels, converts it into a namespace/name string, and passes that to EnqueueKey. The controller resource must be of namespace-scoped.

func (*Impl) EnqueueSentinel

func (c *Impl) EnqueueSentinel(k types.NamespacedName) func(interface{})

EnqueueSentinel returns a Enqueue method which will always enqueue a predefined key instead of the object key.

func (*Impl) FilteredGlobalResync

func (c *Impl) FilteredGlobalResync(f func(interface{}) bool, si cache.SharedInformer)

FilteredGlobalResync enqueues (with a delay) all objects from the SharedInformer that pass the filter function

func (*Impl) GlobalResync

func (c *Impl) GlobalResync(si cache.SharedInformer)

GlobalResync enqueues (with a delay) all objects from the passed SharedInformer

func (*Impl) Run

func (c *Impl) Run(threadiness int, stopCh <-chan struct{}) error

Run starts the controller's worker threads, the number of which is threadiness. It then blocks until stopCh is closed, at which point it shuts down its internal work queue and waits for workers to finish processing their current work items.

type Informer

type Informer interface {
	Run(<-chan struct{})
	HasSynced() bool
}

Informer is the group of methods that a type must implement to be passed to StartInformers.

type Options

type Options struct {
	// ConfigStore is used to attach the frozen configuration to the context.
	ConfigStore reconciler.ConfigStore
}

Options is additional resources a Controller might want to use depending on implementation.

type OptionsFn

type OptionsFn func(impl *Impl) Options

OptionsFn is a callback method signature that accepts an Impl and returns Options. Used for controllers that need access to the members of Options but to build Options, integrators need an Impl.

type Reconciler

type Reconciler interface {
	Reconcile(ctx context.Context, key string) error
}

Reconciler is the interface that controller implementations are expected to implement, so that the shared controller.Impl can drive work through it.

type StatsReporter

type StatsReporter interface {
	// ReportQueueDepth reports the queue depth metric
	ReportQueueDepth(v int64) error

	// ReportReconcile reports the count and latency metrics for a reconcile operation
	ReportReconcile(duration time.Duration, key, success string) error
}

StatsReporter defines the interface for sending metrics

func MustNewStatsReporter

func MustNewStatsReporter(reconciler string, logger *zap.SugaredLogger) StatsReporter

MustNewStatsReporter creates a new instance of StatsReporter. Logs fatally if creation fails.

func NewStatsReporter

func NewStatsReporter(reconciler string) (StatsReporter, error)

NewStatsReporter creates a reporter that collects and reports metrics