Documentation

Overview

    Package manager is required to create Controllers and provides shared dependencies such as clients, caches, schemes, etc. Controllers must be started by calling Manager.Start.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Manager

    type Manager interface {
    	// Add will set reqeusted dependencies on the component, and cause the component to be
    	// started when Start is called.  Add will inject any dependencies for which the argument
    	// implements the inject interface - e.g. inject.Client
    	Add(Runnable) error
    
    	// SetFields will set any dependencies on an object for which the object has implemented the inject
    	// interface - e.g. inject.Client.
    	SetFields(interface{}) error
    
    	// Start starts all registered Controllers and blocks until the Stop channel is closed.
    	// Returns an error if there is an error starting any controller.
    	Start(<-chan struct{}) error
    
    	// GetConfig returns an initialized Config
    	GetConfig() *rest.Config
    
    	// GetScheme returns and initialized Scheme
    	GetScheme() *runtime.Scheme
    
    	// GetAdmissionDecoder returns the runtime.Decoder based on the scheme.
    	GetAdmissionDecoder() types.Decoder
    
    	// GetClient returns a client configured with the Config
    	GetClient() client.Client
    
    	// GetFieldIndexer returns a client.FieldIndexer configured with the client
    	GetFieldIndexer() client.FieldIndexer
    
    	// GetCache returns a cache.Cache
    	GetCache() cache.Cache
    
    	// GetRecorder returns a new EventRecorder for the provided name
    	GetRecorder(name string) record.EventRecorder
    
    	// GetRESTMapper returns a RESTMapper
    	GetRESTMapper() meta.RESTMapper
    }

      Manager initializes shared dependencies such as Caches and Clients, and provides them to Runnables. A Manager is required to create Controllers.

      func New

      func New(config *rest.Config, options Options) (Manager, error)

        New returns a new Manager for creating Controllers.

        Example

          This example creates a new Manager that can be used with controller.New to create Controllers.

          Output:
          
          

          type NewCacheFunc

          type NewCacheFunc func(config *rest.Config, opts cache.Options) (cache.Cache, error)

            NewCacheFunc allows a user to define how to create a cache

            type NewClientFunc

            type NewClientFunc func(cache cache.Cache, config *rest.Config, options client.Options) (client.Client, error)

              NewClientFunc allows a user to define how to create a client

              type Options

              type Options struct {
              	// Scheme is the scheme used to resolve runtime.Objects to GroupVersionKinds / Resources
              	// Defaults to the kubernetes/client-go scheme.Scheme
              	Scheme *runtime.Scheme
              
              	// MapperProvider provides the rest mapper used to map go types to Kubernetes APIs
              	MapperProvider func(c *rest.Config) (meta.RESTMapper, error)
              
              	// SyncPeriod determines the minimum frequency at which watched resources are
              	// reconciled. A lower period will correct entropy more quickly, but reduce
              	// responsiveness to change if there are many watched resources. Change this
              	// value only if you know what you are doing. Defaults to 10 hours if unset.
              	SyncPeriod *time.Duration
              
              	// LeaderElection determines whether or not to use leader election when
              	// starting the manager.
              	LeaderElection bool
              
              	// LeaderElectionNamespace determines the namespace in which the leader
              	// election configmap will be created.
              	LeaderElectionNamespace string
              
              	// LeaderElectionID determines the name of the configmap that leader election
              	// will use for holding the leader lock.
              	LeaderElectionID string
              
              	// Namespace if specified restricts the manager's cache to watch objects in the desired namespace
              	// Defaults to all namespaces
              	// Note: If a namespace is specified then controllers can still Watch for a cluster-scoped resource e.g Node
              	// For namespaced resources the cache will only hold objects from the desired namespace.
              	Namespace string
              
              	// MetricsBindAddress is the TCP address that the controller should bind to
              	// for serving prometheus metrics
              	MetricsBindAddress string
              
              	// NewCache is the function that will create the cache to be used
              	// by the manager. If not set this will use the default new cache function.
              	NewCache NewCacheFunc
              
              	// NewClient will create the client to be used by the manager.
              	// If not set this will create the default DelegatingClient that will
              	// use the cache for reads and the client for writes.
              	NewClient NewClientFunc
              	// contains filtered or unexported fields
              }

                Options are the arguments for creating a new Manager

                type Runnable

                type Runnable interface {
                	// Start starts running the component.  The component will stop running when the channel is closed.
                	// Start blocks until the channel is closed or an error occurs.
                	Start(<-chan struct{}) error
                }

                  Runnable allows a component to be started.

                  type RunnableFunc

                  type RunnableFunc func(<-chan struct{}) error

                    RunnableFunc implements Runnable

                    func (RunnableFunc) Start

                    func (r RunnableFunc) Start(s <-chan struct{}) error

                      Start implements Runnable