Documentation

Index

Constants

This section is empty.

Variables

View Source
var (

	// PluginEnabledFn checks whether a plugin is enabled.  By default, if you ask about it, it's enabled.
	PluginEnabledFn = func(name string, config io.Reader) bool {
		return true
	}
)

    All registered admission options.

    Functions

    func GetAdmissionPluginConfigurationFor

    func GetAdmissionPluginConfigurationFor(pluginCfg apiserver.AdmissionPluginConfiguration) (io.Reader, error)

      GetAdmissionPluginConfigurationFor returns a reader that holds the admission plugin configuration.

      func GetPlugins

      func GetPlugins() []string

        GetPlugins enumerates the names of all registered plugins.

        func NewForbidden

        func NewForbidden(a Attributes, internalError error) error

          NewForbidden is a utility function to return a well-formatted admission control error response

          func NewNotFound

          func NewNotFound(a Attributes) error

            NewNotFound is a utility function to return a well-formatted admission control error response

            func RegisterPlugin

            func RegisterPlugin(name string, plugin Factory)

              RegisterPlugin registers a plugin Factory by name. This is expected to happen during app startup.

              func Validate

              func Validate(plugin Interface) error

                Validate will call the Validate function in each plugin if they implement the Validator interface.

                Types

                type Attributes

                type Attributes interface {
                	// GetName returns the name of the object as presented in the request.  On a CREATE operation, the client
                	// may omit name and rely on the server to generate the name.  If that is the case, this method will return
                	// the empty string
                	GetName() string
                	// GetNamespace is the namespace associated with the request (if any)
                	GetNamespace() string
                	// GetResource is the name of the resource being requested.  This is not the kind.  For example: pods
                	GetResource() schema.GroupVersionResource
                	// GetSubresource is the name of the subresource being requested.  This is a different resource, scoped to the parent resource, but it may have a different kind.
                	// For instance, /pods has the resource "pods" and the kind "Pod", while /pods/foo/status has the resource "pods", the sub resource "status", and the kind "Pod"
                	// (because status operates on pods). The binding resource for a pod though may be /pods/foo/binding, which has resource "pods", subresource "binding", and kind "Binding".
                	GetSubresource() string
                	// GetOperation is the operation being performed
                	GetOperation() Operation
                	// GetObject is the object from the incoming request prior to default values being applied
                	GetObject() runtime.Object
                	// GetOldObject is the existing object. Only populated for UPDATE requests.
                	GetOldObject() runtime.Object
                	// GetKind is the type of object being manipulated.  For example: Pod
                	GetKind() schema.GroupVersionKind
                	// GetUserInfo is information about the requesting user
                	GetUserInfo() user.Info
                }

                  Attributes is an interface used by AdmissionController to get information about a request that is used to make an admission decision.

                  func NewAttributesRecord

                  func NewAttributesRecord(object runtime.Object, oldObject runtime.Object, kind schema.GroupVersionKind, namespace, name string, resource schema.GroupVersionResource, subresource string, operation Operation, userInfo user.Info) Attributes

                  type ConfigProvider

                  type ConfigProvider interface {
                  	ConfigFor(pluginName string) (io.Reader, error)
                  }

                    ConfigProvider provides a way to get configuration for an admission plugin based on its name

                    func ReadAdmissionConfiguration

                    func ReadAdmissionConfiguration(pluginNames []string, configFilePath string) (ConfigProvider, error)

                      ReadAdmissionConfiguration reads the admission configuration at the specified path. It returns the loaded admission configuration if the input file aligns with the required syntax. If it does not align with the provided syntax, it returns a default configuration for the enumerated set of pluginNames whose config location references the specified configFilePath. It does this to preserve backward compatibility when admission control files were opaque. It returns an error if the file did not exist.

                      type Factory

                      type Factory func(config io.Reader) (Interface, error)

                        Factory is a function that returns an Interface for admission decisions. The config parameter provides an io.Reader handler to the factory in order to load specific configurations. If no configuration is provided the parameter is nil.

                        type Handler

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

                          Handler is a base for admission control handlers that support a predefined set of operations

                          func NewHandler

                          func NewHandler(ops ...Operation) *Handler

                            NewHandler creates a new base handler that handles the passed in operations

                            func (*Handler) Handles

                            func (h *Handler) Handles(operation Operation) bool

                              Handles returns true for methods that this handler supports

                              func (*Handler) SetReadyFunc

                              func (h *Handler) SetReadyFunc(readyFunc ReadyFunc)

                                SetReadyFunc allows late registration of a ReadyFunc to know if the handler is ready to process requests.

                                func (*Handler) WaitForReady

                                func (h *Handler) WaitForReady() bool

                                  WaitForReady will wait for the readyFunc (if registered) to return ready, and in case of timeout, will return false.

                                  type Interface

                                  type Interface interface {
                                  	// Admit makes an admission decision based on the request attributes
                                  	Admit(a Attributes) (err error)
                                  
                                  	// Handles returns true if this admission controller can handle the given operation
                                  	// where operation can be one of CREATE, UPDATE, DELETE, or CONNECT
                                  	Handles(operation Operation) bool
                                  }

                                    Interface is an abstract, pluggable interface for Admission Control decisions.

                                    func InitPlugin

                                    func InitPlugin(name string, config io.Reader, pluginInitializer PluginInitializer) (Interface, error)

                                      InitPlugin creates an instance of the named interface.

                                      func NewChainHandler

                                      func NewChainHandler(handlers ...Interface) Interface

                                        NewChainHandler creates a new chain handler from an array of handlers. Used for testing.

                                        func NewFromPlugins

                                        func NewFromPlugins(pluginNames []string, configProvider ConfigProvider, pluginInitializer PluginInitializer) (Interface, error)

                                          NewFromPlugins returns an admission.Interface that will enforce admission control decisions of all the given plugins.

                                          type Operation

                                          type Operation string

                                            Operation is the type of resource operation being checked for admission control

                                            const (
                                            	Create  Operation = "CREATE"
                                            	Update  Operation = "UPDATE"
                                            	Delete  Operation = "DELETE"
                                            	Connect Operation = "CONNECT"
                                            )

                                              Operation constants

                                              type PluginEnabledFunc

                                              type PluginEnabledFunc func(name string, config io.Reader) bool

                                                PluginEnabledFunc is a function type that can provide an external check on whether an admission plugin may be enabled

                                                type PluginInitializer

                                                type PluginInitializer interface {
                                                	Initialize(plugin Interface)
                                                }

                                                  PluginInitializer is used for initialization of shareable resources between admission plugins. After initialization the resources have to be set separately

                                                  type PluginInitializers

                                                  type PluginInitializers []PluginInitializer

                                                  func (PluginInitializers) Initialize

                                                  func (pp PluginInitializers) Initialize(plugin Interface)

                                                  type ReadyFunc

                                                  type ReadyFunc func() bool

                                                    ReadyFunc is a function that returns true if the admission controller is ready to handle requests.

                                                    type Validator

                                                    type Validator interface {
                                                    	Validate() error
                                                    }

                                                      Validator holds Validate functions, which are responsible for validation of initialized shared resources and should be implemented on admission plugins