Documentation

Index

Constants

View Source
const DefaultNameQualifier = ".kubebuilder.io"

    DefaultNameQualifier is the suffix appended to all kubebuilder plugin names.

    Variables

    This section is empty.

    Functions

    func GetShortName

    func GetShortName(name string) string

      GetShortName returns plugin's short name (name before domain) if name is fully qualified (has a domain suffix), otherwise GetShortName returns name.

      func Key

      func Key(name, version string) string

        Key returns a unique identifying string for a plugin's name and version.

        func KeyFor

        func KeyFor(p Plugin) string

          KeyFor returns a Plugin's unique identifying string.

          func SplitKey

          func SplitKey(key string) (string, string)

            SplitKey returns a name and version for a plugin key.

            func ValidateName

            func ValidateName(name string) error

              ValidateName ensures name is a valid DNS 1123 subdomain.

              Types

              type Context

              type Context struct {
              	// CommandName sets the command name for a subcommand.
              	CommandName string
              	// Description is a description of what this subcommand does. It is used to display help.
              	Description string
              	// Examples are one or more examples of the command-line usage of this subcommand. It is used to display help.
              	Examples string
              }

                Context is the runtime context for a subcommand.

                type CreateAPI

                type CreateAPI interface {
                	Plugin
                	// GetCreateAPISubcommand returns the underlying CreateAPISubcommand interface.
                	GetCreateAPISubcommand() CreateAPISubcommand
                }

                  CreateAPI is an interface for plugins that provide a `create api` subcommand

                  type CreateAPISubcommand

                  type CreateAPISubcommand interface {
                  	Subcommand
                  }

                    CreateAPISubcommand is an interface that represents a `create api` subcommand

                    type CreateWebhook

                    type CreateWebhook interface {
                    	Plugin
                    	// GetCreateWebhookSubcommand returns the underlying CreateWebhookSubcommand interface.
                    	GetCreateWebhookSubcommand() CreateWebhookSubcommand
                    }

                      CreateWebhook is an interface for plugins that provide a `create webhook` subcommand

                      type CreateWebhookSubcommand

                      type CreateWebhookSubcommand interface {
                      	Subcommand
                      }

                        CreateWebhookSubcommand is an interface that represents a `create wekbhook` subcommand

                        type Deprecated

                        type Deprecated interface {
                        	// DeprecationWarning returns a string indicating a plugin is deprecated.
                        	DeprecationWarning() string
                        }

                          Deprecated is an interface that defines the messages for plugins that are deprecated.

                          type Edit

                          type Edit interface {
                          	Plugin
                          	// GetEditSubcommand returns the underlying EditSubcommand interface.
                          	GetEditSubcommand() EditSubcommand
                          }

                            Edit is an interface for plugins that provide a `edit` subcommand

                            type EditSubcommand

                            type EditSubcommand interface {
                            	Subcommand
                            }

                              EditSubcommand is an interface that represents an `edit` subcommand

                              type Full

                              type Full interface {
                              	Init
                              	CreateAPI
                              	CreateWebhook
                              	Edit
                              }

                                Full is an interface for plugins that provide `init`, `create api`, `create webhook` and `edit` subcommands

                                type Init

                                type Init interface {
                                	Plugin
                                	// GetInitSubcommand returns the underlying InitSubcommand interface.
                                	GetInitSubcommand() InitSubcommand
                                }

                                  Init is an interface for plugins that provide an `init` subcommand

                                  type InitSubcommand

                                  type InitSubcommand interface {
                                  	Subcommand
                                  }

                                    InitSubcommand is an interface that represents an `init` subcommand

                                    type Plugin

                                    type Plugin interface {
                                    	// Name returns a DNS1123 label string identifying the plugin uniquely. This name should be fully-qualified,
                                    	// i.e. have a short prefix describing the plugin type (like a language) followed by a domain.
                                    	// For example, Kubebuilder's main plugin would return "go.kubebuilder.io".
                                    	Name() string
                                    	// Version returns the plugin's version.
                                    	//
                                    	// NOTE: this version is different from config version.
                                    	Version() Version
                                    	// SupportedProjectVersions lists all project configuration versions this plugin supports, ex. []string{"2", "3"}.
                                    	// The returned slice cannot be empty.
                                    	SupportedProjectVersions() []string
                                    }

                                      Plugin is an interface that defines the common base for all plugins

                                      type Stage

                                      type Stage uint8

                                        Stage represents the stability of a version

                                        const (
                                        	// StableStage should be used for plugins that are rarely changed in backwards-compatible ways, e.g. bug fixes.
                                        	StableStage Stage = iota
                                        	// BetaStage should be used for plugins that may be changed in minor ways and are not expected to break between uses.
                                        	BetaStage Stage = iota
                                        	// AlphaStage should be used for plugins that are frequently changed and may break between uses.
                                        	AlphaStage Stage = iota
                                        )

                                          Order Stage in decreasing degree of stability for comparison purposes. StableStage must be 0 so that it is the default Stage

                                          func ParseStage

                                          func ParseStage(stage string) (Stage, error)

                                            ParseStage parses stage into a Stage, assuming it is one of the valid stages

                                            func (Stage) Compare

                                            func (s Stage) Compare(other Stage) int

                                              Compare returns -1 if s < other, 0 if s == other, and 1 if s > other.

                                              func (*Stage) Parse

                                              func (s *Stage) Parse(stage string) error

                                                Parse parses stage inline, assuming it is one of the valid stages

                                                func (Stage) String

                                                func (s Stage) String() string

                                                  String returns the string representation of s

                                                  func (Stage) Validate

                                                  func (s Stage) Validate() error

                                                    Validate ensures that the stage is one of the valid stages

                                                    type Subcommand

                                                    type Subcommand interface {
                                                    	// UpdateContext updates a Context with subcommand-specific help text, like description and examples. It also serves
                                                    	// to pass context from the CLI to the subcommand, such as the command name.
                                                    	// Can be a no-op if default help text is desired.
                                                    	UpdateContext(*Context)
                                                    	// BindFlags binds the subcommand's flags to the CLI. This allows each subcommand to define its own
                                                    	// command line flags.
                                                    	BindFlags(*pflag.FlagSet)
                                                    	// Run runs the subcommand.
                                                    	Run() error
                                                    	// InjectConfig passes a config to a plugin. The plugin may modify the config.
                                                    	// Initializing, loading, and saving the config is managed by the cli package.
                                                    	InjectConfig(*config.Config)
                                                    }

                                                      Subcommand is an interface that defines the common base for subcommands returned by plugins

                                                      type Version

                                                      type Version struct {
                                                      	// Number denotes the current version of a plugin. Two different numbers between versions
                                                      	// indicate that they are incompatible.
                                                      	Number int64
                                                      	// Stage indicates stability.
                                                      	Stage Stage
                                                      }

                                                        Version is a plugin version containing a non-zero positive integer and a stage value that represents stability.

                                                        func ParseVersion

                                                        func ParseVersion(version string) (Version, error)

                                                          ParseVersion parses version into a Version, assuming it adheres to format: (v)?[1-9][0-9]*(-(alpha|beta))?

                                                          func (Version) Compare

                                                          func (v Version) Compare(other Version) int

                                                            Compare returns -1 if v < other, 0 if v == other, and 1 if v > other.

                                                            func (*Version) Parse

                                                            func (v *Version) Parse(version string) (err error)

                                                              Parse parses version inline, assuming it adheres to format: (v)?[1-9][0-9]*(-(alpha|beta))?

                                                              func (Version) String

                                                              func (v Version) String() string

                                                                String returns the string representation of v

                                                                func (Version) Validate

                                                                func (v Version) Validate() error

                                                                  Validate ensures that the version number is positive and the stage is one of the valid stages

                                                                  Directories

                                                                  Path Synopsis
                                                                  v2
                                                                  scaffolds
                                                                  Package scaffolds contains libraries for scaffolding code to use with controller-runtime
                                                                  Package scaffolds contains libraries for scaffolding code to use with controller-runtime
                                                                  v3
                                                                  scaffolds
                                                                  Package scaffolds contains libraries for scaffolding code to use with controller-runtime
                                                                  Package scaffolds contains libraries for scaffolding code to use with controller-runtime
                                                                  internal