Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
	AddToScheme   = SchemeBuilder.AddToScheme
)
View Source
var Scheme = runtime.NewScheme()

    Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered. TODO: remove this, scheduler should not have its own scheme.

    View Source
    var SchemeGroupVersion = schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}

      SchemeGroupVersion is group version used to register these objects TODO this should be in the "scheduler" group

      Functions

      This section is empty.

      Types

      type ExtenderArgs

      type ExtenderArgs struct {
      	// Pod being scheduled
      	Pod v1.Pod
      	// List of candidate nodes where the pod can be scheduled; to be populated
      	// only if ExtenderConfig.NodeCacheCapable == false
      	Nodes *v1.NodeList
      	// List of candidate node names where the pod can be scheduled; to be
      	// populated only if ExtenderConfig.NodeCacheCapable == true
      	NodeNames *[]string
      }

        ExtenderArgs represents the arguments needed by the extender to filter/prioritize nodes for a pod.

        type ExtenderConfig

        type ExtenderConfig struct {
        	// URLPrefix at which the extender is available
        	URLPrefix string
        	// Verb for the filter call, empty if not supported. This verb is appended to the URLPrefix when issuing the filter call to extender.
        	FilterVerb string
        	// Verb for the prioritize call, empty if not supported. This verb is appended to the URLPrefix when issuing the prioritize call to extender.
        	PrioritizeVerb string
        	// The numeric multiplier for the node scores that the prioritize call generates.
        	// The weight should be a positive integer
        	Weight int
        	// EnableHttps specifies whether https should be used to communicate with the extender
        	EnableHttps bool
        	// TLSConfig specifies the transport layer security config
        	TLSConfig *restclient.TLSClientConfig
        	// HTTPTimeout specifies the timeout duration for a call to the extender. Filter timeout fails the scheduling of the pod. Prioritize
        	// timeout is ignored, k8s/other extenders priorities are used to select the node.
        	HTTPTimeout time.Duration
        	// NodeCacheCapable specifies that the extender is capable of caching node information,
        	// so the scheduler should only send minimal information about the eligible nodes
        	// assuming that the extender already cached full details of all nodes in the cluster
        	NodeCacheCapable bool
        }

          Holds the parameters used to communicate with the extender. If a verb is unspecified/empty, it is assumed that the extender chose not to provide that extension.

          type ExtenderFilterResult

          type ExtenderFilterResult struct {
          	// Filtered set of nodes where the pod can be scheduled; to be populated
          	// only if ExtenderConfig.NodeCacheCapable == false
          	Nodes *v1.NodeList
          	// Filtered set of nodes where the pod can be scheduled; to be populated
          	// only if ExtenderConfig.NodeCacheCapable == true
          	NodeNames *[]string
          	// Filtered out nodes where the pod can't be scheduled and the failure messages
          	FailedNodes FailedNodesMap
          	// Error message indicating failure
          	Error string
          }

            ExtenderFilterResult represents the results of a filter call to an extender

            type FailedNodesMap

            type FailedNodesMap map[string]string

              FailedNodesMap represents the filtered out nodes, with node names and failure messages

              type HostPriority

              type HostPriority struct {
              	// Name of the host
              	Host string
              	// Score associated with the host
              	Score int
              }

                HostPriority represents the priority of scheduling to a particular host, higher priority is better.

                type HostPriorityList

                type HostPriorityList []HostPriority

                func (HostPriorityList) Len

                func (h HostPriorityList) Len() int

                func (HostPriorityList) Less

                func (h HostPriorityList) Less(i, j int) bool

                func (HostPriorityList) Swap

                func (h HostPriorityList) Swap(i, j int)

                type LabelPreference

                type LabelPreference struct {
                	// Used to identify node "groups"
                	Label string
                	// This is a boolean flag
                	// If true, higher priority is given to nodes that have the label
                	// If false, higher priority is given to nodes that do not have the label
                	Presence bool
                }

                  Holds the parameters that are used to configure the corresponding priority function

                  type LabelsPresence

                  type LabelsPresence struct {
                  	// The list of labels that identify node "groups"
                  	// All of the labels should be either present (or absent) for the node to be considered a fit for hosting the pod
                  	Labels []string
                  	// The boolean flag that indicates whether the labels should be present or absent from the node
                  	Presence bool
                  }

                    Holds the parameters that are used to configure the corresponding predicate

                    type Policy

                    type Policy struct {
                    	metav1.TypeMeta
                    	// Holds the information to configure the fit predicate functions
                    	Predicates []PredicatePolicy
                    	// Holds the information to configure the priority functions
                    	Priorities []PriorityPolicy
                    	// Holds the information to communicate with the extender(s)
                    	ExtenderConfigs []ExtenderConfig
                    }

                    func (*Policy) GetObjectKind

                    func (obj *Policy) GetObjectKind() schema.ObjectKind

                    type PredicateArgument

                    type PredicateArgument struct {
                    	// The predicate that provides affinity for pods belonging to a service
                    	// It uses a label to identify nodes that belong to the same "group"
                    	ServiceAffinity *ServiceAffinity
                    	// The predicate that checks whether a particular node has a certain label
                    	// defined or not, regardless of value
                    	LabelsPresence *LabelsPresence
                    }

                      Represents the arguments that the different types of predicates take Only one of its members may be specified

                      type PredicatePolicy

                      type PredicatePolicy struct {
                      	// Identifier of the predicate policy
                      	// For a custom predicate, the name can be user-defined
                      	// For the Kubernetes provided predicates, the name is the identifier of the pre-defined predicate
                      	Name string
                      	// Holds the parameters to configure the given predicate
                      	Argument *PredicateArgument
                      }

                      type PriorityArgument

                      type PriorityArgument struct {
                      	// The priority function that ensures a good spread (anti-affinity) for pods belonging to a service
                      	// It uses a label to identify nodes that belong to the same "group"
                      	ServiceAntiAffinity *ServiceAntiAffinity
                      	// The priority function that checks whether a particular node has a certain label
                      	// defined or not, regardless of value
                      	LabelPreference *LabelPreference
                      }

                        Represents the arguments that the different types of priorities take. Only one of its members may be specified

                        type PriorityPolicy

                        type PriorityPolicy struct {
                        	// Identifier of the priority policy
                        	// For a custom priority, the name can be user-defined
                        	// For the Kubernetes provided priority functions, the name is the identifier of the pre-defined priority function
                        	Name string
                        	// The numeric multiplier for the node scores that the priority function generates
                        	// The weight should be a positive integer
                        	Weight int
                        	// Holds the parameters to configure the given priority function
                        	Argument *PriorityArgument
                        }

                        type ServiceAffinity

                        type ServiceAffinity struct {
                        	// The list of labels that identify node "groups"
                        	// All of the labels should match for the node to be considered a fit for hosting the pod
                        	Labels []string
                        }

                          Holds the parameters that are used to configure the corresponding predicate

                          type ServiceAntiAffinity

                          type ServiceAntiAffinity struct {
                          	// Used to identify node "groups"
                          	Label string
                          }

                            Holds the parameters that are used to configure the corresponding priority function

                            Directories

                            Path Synopsis