Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ClientBuilder

type ClientBuilder interface {
	// WithUncached takes a list of runtime objects (plain or lists) that users don't want to cache
	// for this client. This function can be called multiple times, it should append to an internal slice.
	WithUncached(objs ...client.Object) ClientBuilder

	// Build returns a new client.
	Build(cache cache.Cache, config *rest.Config, options client.Options) (client.Client, error)
}

    ClientBuilder builder is the interface for the client builder.

    func NewClientBuilder

    func NewClientBuilder() ClientBuilder

      NewClientBuilder returns a builder to build new clients to be passed when creating a Manager.

      type Cluster

      type Cluster interface {
      	// SetFields will set any dependencies on an object for which the object has implemented the inject
      	// interface - e.g. inject.Client.
      	SetFields(interface{}) error
      
      	// GetConfig returns an initialized Config
      	GetConfig() *rest.Config
      
      	// GetScheme returns an initialized Scheme
      	GetScheme() *runtime.Scheme
      
      	// GetClient returns a client configured with the Config. This client may
      	// not be a fully "direct" client -- it may read from a cache, for
      	// instance.  See Options.NewClient for more information on how the default
      	// implementation works.
      	GetClient() client.Client
      
      	// GetFieldIndexer returns a client.FieldIndexer configured with the client
      	GetFieldIndexer() client.FieldIndexer
      
      	// GetCache returns a cache.Cache
      	GetCache() cache.Cache
      
      	// GetEventRecorderFor returns a new EventRecorder for the provided name
      	GetEventRecorderFor(name string) record.EventRecorder
      
      	// GetRESTMapper returns a RESTMapper
      	GetRESTMapper() meta.RESTMapper
      
      	// GetAPIReader returns a reader that will be configured to use the API server.
      	// This should be used sparingly and only when the client does not fit your
      	// use case.
      	GetAPIReader() client.Reader
      
      	// Start starts the cluster
      	Start(ctx context.Context) error
      }

        Cluster provides various methods to interact with a cluster.

        func New

        func New(config *rest.Config, opts ...Option) (Cluster, error)

          New constructs a brand new cluster

          type Option

          type Option func(*Options)

            Option can be used to manipulate Options

            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, but it's almost always better
            	// idea to pass your own scheme in.  See the documentation in pkg/scheme for more information.
            	Scheme *runtime.Scheme
            
            	// MapperProvider provides the rest mapper used to map go types to Kubernetes APIs
            	MapperProvider func(c *rest.Config) (meta.RESTMapper, error)
            
            	// Logger is the logger that should be used by this Cluster.
            	// If none is set, it defaults to log.Log global logger.
            	Logger logr.Logger
            
            	// 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.
            	// there will a 10 percent jitter between the SyncPeriod of all controllers
            	// so that all controllers will not send list requests simultaneously.
            	SyncPeriod *time.Duration
            
            	// 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, 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
            
            	// 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 cache.NewCacheFunc
            
            	// ClientBuilder is the builder that creates 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.
            	ClientBuilder ClientBuilder
            
            	// ClientDisableCacheFor tells the client that, if any cache is used, to bypass it
            	// for the given objects.
            	ClientDisableCacheFor []client.Object
            
            	// DryRunClient specifies whether the client should be configured to enforce
            	// dryRun mode.
            	DryRunClient bool
            
            	// EventBroadcaster records Events emitted by the manager and sends them to the Kubernetes API
            	// Use this to customize the event correlator and spam filter
            	//
            	// Deprecated: using this may cause goroutine leaks if the lifetime of your manager or controllers
            	// is shorter than the lifetime of your process.
            	EventBroadcaster record.EventBroadcaster
            	// contains filtered or unexported fields
            }

              Options are the possible options that can be configured for a Cluster.