Documentation

Overview

    Package builder provides wraps other controller-runtime libraries and exposes simple patterns for building common Controllers.

    Projects built with the builder package can trivially be rebased on top of the underlying packages if the project requires more customized behavior in the future.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	// OnlyMetadata tells the controller to *only* cache metadata, and to watch
    	// the the API server in metadata-only form.  This is useful when watching
    	// lots of objects, really big objects, or objects for which you only know
    	// the the GVK, but not the structure.  You'll need to pass
    	// metav1.PartialObjectMetadata to the client when fetching objects in your
    	// reconciler, otherwise you'll end up with a duplicate structured or
    	// unstructured cache.
    	OnlyMetadata = projectAs(projectAsMetadata)
    )

    Functions

    This section is empty.

    Types

    type Builder

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

      Builder builds a Controller.

      Example

        This example creates a simple application ControllerManagedBy that is configured for ReplicaSets and Pods.

        * Create a new application for ReplicaSets that manages Pods owned by the ReplicaSet and calls into ReplicaSetReconciler.

        * Start the application.

        Output:
        
        
        Example (Metadata_only)
        Output:
        
        

        func ControllerManagedBy

        func ControllerManagedBy(m manager.Manager) *Builder

          ControllerManagedBy returns a new controller builder that will be started by the provided Manager

          func (*Builder) Build

            Build builds the Application ControllerManagedBy and returns the Controller it created.

            func (*Builder) Complete

            func (blder *Builder) Complete(r reconcile.Reconciler) error

              Complete builds the Application ControllerManagedBy.

              func (*Builder) For

              func (blder *Builder) For(object client.Object, opts ...ForOption) *Builder

                For defines the type of Object being *reconciled*, and configures the ControllerManagedBy to respond to create / delete / update events by *reconciling the object*. This is the equivalent of calling Watches(&source.Kind{Type: apiType}, &handler.EnqueueRequestForObject{})

                func (*Builder) Named

                func (blder *Builder) Named(name string) *Builder

                  Named sets the name of the controller to the given name. The name shows up in metrics, among other things, and thus should be a prometheus compatible name (underscores and alphanumeric characters only).

                  By default, controllers are named using the lowercase version of their kind.

                  func (*Builder) Owns

                  func (blder *Builder) Owns(object client.Object, opts ...OwnsOption) *Builder

                    Owns defines types of Objects being *generated* by the ControllerManagedBy, and configures the ControllerManagedBy to respond to create / delete / update events by *reconciling the owner object*. This is the equivalent of calling Watches(&source.Kind{Type: <ForType-forInput>}, &handler.EnqueueRequestForOwner{OwnerType: apiType, IsController: true})

                    func (*Builder) Watches

                    func (blder *Builder) Watches(src source.Source, eventhandler handler.EventHandler, opts ...WatchesOption) *Builder

                      Watches exposes the lower-level ControllerManagedBy Watches functions through the builder. Consider using Owns or For instead of Watches directly. Specified predicates are registered only for given source.

                      func (*Builder) WithEventFilter

                      func (blder *Builder) WithEventFilter(p predicate.Predicate) *Builder

                        WithEventFilter sets the event filters, to filter which create/update/delete/generic events eventually trigger reconciliations. For example, filtering on whether the resource version has changed. Given predicate is added for all watched objects. Defaults to the empty list.

                        func (*Builder) WithLogger

                        func (blder *Builder) WithLogger(log logr.Logger) *Builder

                          WithLogger overrides the controller options's logger used.

                          func (*Builder) WithOptions

                          func (blder *Builder) WithOptions(options controller.Options) *Builder

                            WithOptions overrides the controller options use in doController. Defaults to empty.

                            type ForInput

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

                              ForInput represents the information set by For method.

                              type ForOption

                              type ForOption interface {
                              	// ApplyToFor applies this configuration to the given for input.
                              	ApplyToFor(*ForInput)
                              }

                                ForOption is some configuration that modifies options for a For request.

                                type OwnsInput

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

                                  OwnsInput represents the information set by Owns method.

                                  type OwnsOption

                                  type OwnsOption interface {
                                  	// ApplyToOwns applies this configuration to the given owns input.
                                  	ApplyToOwns(*OwnsInput)
                                  }

                                    OwnsOption is some configuration that modifies options for a owns request.

                                    type Predicates

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

                                      Predicates filters events before enqueuing the keys.

                                      func WithPredicates

                                      func WithPredicates(predicates ...predicate.Predicate) Predicates

                                        WithPredicates sets the given predicates list.

                                        func (Predicates) ApplyToFor

                                        func (w Predicates) ApplyToFor(opts *ForInput)

                                          ApplyToFor applies this configuration to the given ForInput options.

                                          func (Predicates) ApplyToOwns

                                          func (w Predicates) ApplyToOwns(opts *OwnsInput)

                                            ApplyToOwns applies this configuration to the given OwnsInput options.

                                            func (Predicates) ApplyToWatches

                                            func (w Predicates) ApplyToWatches(opts *WatchesInput)

                                              ApplyToWatches applies this configuration to the given WatchesInput options.

                                              type WatchesInput

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

                                                WatchesInput represents the information set by Watches method.

                                                type WatchesOption

                                                type WatchesOption interface {
                                                	// ApplyToWatches applies this configuration to the given watches options.
                                                	ApplyToWatches(*WatchesInput)
                                                }

                                                  WatchesOption is some configuration that modifies options for a watches request.

                                                  type WebhookBuilder

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

                                                    WebhookBuilder builds a Webhook.

                                                    Example

                                                      This example use webhook builder to create a simple webhook that is managed by a manager for CRD ChaosPod. And then start the manager.

                                                      Output:
                                                      
                                                      

                                                      func WebhookManagedBy

                                                      func WebhookManagedBy(m manager.Manager) *WebhookBuilder

                                                        WebhookManagedBy allows inform its manager.Manager

                                                        func (*WebhookBuilder) Complete

                                                        func (blder *WebhookBuilder) Complete() error

                                                          Complete builds the webhook.

                                                          func (*WebhookBuilder) For

                                                          func (blder *WebhookBuilder) For(apiType runtime.Object) *WebhookBuilder

                                                            For takes a runtime.Object which should be a CR. If the given object implements the admission.Defaulter interface, a MutatingWebhook will be wired for this type. If the given object implements the admission.Validator interface, a ValidatingWebhook will be wired for this type.