core

package
v1.12.8 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 22, 2019 License: Apache-2.0 Imports: 38 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// DefaultExtenderTimeout defines the default extender timeout in second.
	DefaultExtenderTimeout = 5 * time.Second
)
View Source
const (
	// NoNodeAvailableMsg is used to format message when no nodes available.
	NoNodeAvailableMsg = "0/%v nodes are available"
)

Variables

View Source
var ErrNoNodesAvailable = fmt.Errorf("no nodes available to schedule pods")

ErrNoNodesAvailable is used to describe the error that no nodes available to schedule pods.

Functions

func EqualPriorityMap

func EqualPriorityMap(_ *v1.Pod, _ interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error)

EqualPriorityMap is a prioritizer function that gives an equal weight of one to all nodes

func NewGenericScheduler

func NewGenericScheduler(
	cache schedulercache.Cache,
	eCache *equivalence.Cache,
	podQueue SchedulingQueue,
	predicates map[string]algorithm.FitPredicate,
	predicateMetaProducer algorithm.PredicateMetadataProducer,
	prioritizers []algorithm.PriorityConfig,
	priorityMetaProducer algorithm.PriorityMetadataProducer,
	extenders []algorithm.SchedulerExtender,
	volumeBinder *volumebinder.VolumeBinder,
	pvcLister corelisters.PersistentVolumeClaimLister,
	alwaysCheckAllPredicates bool,
	disablePreemption bool,
	percentageOfNodesToScore int32,
) algorithm.ScheduleAlgorithm

NewGenericScheduler creates a genericScheduler object.

func NewHTTPExtender

func NewHTTPExtender(config *schedulerapi.ExtenderConfig) (algorithm.SchedulerExtender, error)

NewHTTPExtender creates an HTTPExtender object.

func NominatedNodeName

func NominatedNodeName(pod *v1.Pod) string

NominatedNodeName returns nominated node name of a Pod.

func PrioritizeNodes

func PrioritizeNodes(
	pod *v1.Pod,
	nodeNameToInfo map[string]*schedulercache.NodeInfo,
	meta interface{},
	priorityConfigs []algorithm.PriorityConfig,
	nodes []*v1.Node,
	extenders []algorithm.SchedulerExtender,
) (schedulerapi.HostPriorityList, error)

PrioritizeNodes prioritizes the nodes by running the individual priority functions in parallel. Each priority function is expected to set a score of 0-10 0 is the lowest priority score (least preferred node) and 10 is the highest Each priority function can also have its own weight The node scores returned by the priority function are multiplied by the weights to get weighted scores All scores are finally combined (added) to get the total weighted scores of all nodes

Types

type FIFO

type FIFO struct {
	*cache.FIFO
}

FIFO is basically a simple wrapper around cache.FIFO to make it compatible with the SchedulingQueue interface.

func NewFIFO

func NewFIFO() *FIFO

NewFIFO creates a FIFO object.

func (*FIFO) Add

func (f *FIFO) Add(pod *v1.Pod) error

Add adds a pod to the FIFO.

func (*FIFO) AddIfNotPresent

func (f *FIFO) AddIfNotPresent(pod *v1.Pod) error

AddIfNotPresent adds a pod to the FIFO if it is absent in the FIFO.

func (*FIFO) AddUnschedulableIfNotPresent

func (f *FIFO) AddUnschedulableIfNotPresent(pod *v1.Pod, podSchedulingCycle int64) error

AddUnschedulableIfNotPresent adds an unschedulable pod back to the queue. In FIFO it is added to the end of the queue.

func (*FIFO) AssignedPodAdded

func (f *FIFO) AssignedPodAdded(pod *v1.Pod)

AssignedPodAdded does nothing here.

func (*FIFO) AssignedPodUpdated

func (f *FIFO) AssignedPodUpdated(pod *v1.Pod)

AssignedPodUpdated does nothing here.

func (*FIFO) Delete

func (f *FIFO) Delete(pod *v1.Pod) error

Delete deletes a pod in the FIFO.

func (*FIFO) DeleteNominatedPodIfExists added in v1.11.6

func (f *FIFO) DeleteNominatedPodIfExists(pod *v1.Pod)

DeleteNominatedPodIfExists does nothing in FIFO.

func (*FIFO) MoveAllToActiveQueue

func (f *FIFO) MoveAllToActiveQueue()

MoveAllToActiveQueue does nothing in FIFO as all pods are always in the active queue.

func (*FIFO) NominatedPodsForNode added in v1.11.7

func (f *FIFO) NominatedPodsForNode(nodeName string) []*v1.Pod

NominatedPodsForNode returns pods that are nominated to run on the given node, but FIFO does not support it.

func (*FIFO) NumUnschedulablePods added in v1.11.7

func (f *FIFO) NumUnschedulablePods() int

NumUnschedulablePods returns the number of unschedulable pods exist in the SchedulingQueue.

func (*FIFO) Pop

func (f *FIFO) Pop() (*v1.Pod, error)

Pop removes the head of FIFO and returns it. This is just a copy/paste of cache.Pop(queue Queue) from fifo.go that scheduler has always been using. There is a comment in that file saying that this method shouldn't be used in production code, but scheduler has always been using it. This function does minimal error checking.

func (*FIFO) SchedulingCycle added in v1.12.6

func (f *FIFO) SchedulingCycle() int64

SchedulingCycle implements SchedulingQueue.SchedulingCycle interface.

func (*FIFO) Update

func (f *FIFO) Update(oldPod, newPod *v1.Pod) error

Update updates a pod in the FIFO.

func (*FIFO) UpdateNominatedPodForNode added in v1.11.7

func (f *FIFO) UpdateNominatedPodForNode(pod *v1.Pod, nodeName string)

UpdateNominatedPodForNode does nothing in FIFO.

func (*FIFO) WaitingPods added in v1.11.0

func (f *FIFO) WaitingPods() []*v1.Pod

WaitingPods returns all the waiting pods in the queue.

type FailedPredicateMap

type FailedPredicateMap map[string][]algorithm.PredicateFailureReason

FailedPredicateMap declares a map[string][]algorithm.PredicateFailureReason type.

type FitError

type FitError struct {
	Pod              *v1.Pod
	NumAllNodes      int
	FailedPredicates FailedPredicateMap
}

FitError describes a fit error of a pod.

func (*FitError) Error

func (f *FitError) Error() string

Error returns detailed information of why the pod failed to fit on each node

type HTTPExtender

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

HTTPExtender implements the algorithm.SchedulerExtender interface.

func (*HTTPExtender) Bind

func (h *HTTPExtender) Bind(binding *v1.Binding) error

Bind delegates the action of binding a pod to a node to the extender.

func (*HTTPExtender) Filter

func (h *HTTPExtender) Filter(
	pod *v1.Pod,
	nodes []*v1.Node, nodeNameToInfo map[string]*schedulercache.NodeInfo,
) ([]*v1.Node, schedulerapi.FailedNodesMap, error)

Filter based on extender implemented predicate functions. The filtered list is expected to be a subset of the supplied list. failedNodesMap optionally contains the list of failed nodes and failure reasons.

func (*HTTPExtender) IsBinder

func (h *HTTPExtender) IsBinder() bool

IsBinder returns whether this extender is configured for the Bind method.

func (*HTTPExtender) IsIgnorable added in v1.11.0

func (h *HTTPExtender) IsIgnorable() bool

IsIgnorable returns true indicates scheduling should not fail when this extender is unavailable

func (*HTTPExtender) IsInterested

func (h *HTTPExtender) IsInterested(pod *v1.Pod) bool

IsInterested returns true if at least one extended resource requested by this pod is managed by this extender.

func (*HTTPExtender) Prioritize

func (h *HTTPExtender) Prioritize(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, int, error)

Prioritize based on extender implemented priority functions. Weight*priority is added up for each such priority function. The returned score is added to the score computed by Kubernetes scheduler. The total score is used to do the host selection.

func (*HTTPExtender) ProcessPreemption added in v1.11.0

func (h *HTTPExtender) ProcessPreemption(
	pod *v1.Pod,
	nodeToVictims map[*v1.Node]*schedulerapi.Victims,
	nodeNameToInfo map[string]*schedulercache.NodeInfo,
) (map[*v1.Node]*schedulerapi.Victims, error)

ProcessPreemption returns filtered candidate nodes and victims after running preemption logic in extender.

func (*HTTPExtender) SupportsPreemption added in v1.11.0

func (h *HTTPExtender) SupportsPreemption() bool

SupportsPreemption returns if a extender support preemption. A extender should have preempt verb defined and enabled its own node cache.

type Heap

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

Heap is a producer/consumer queue that implements a heap data structure. It can be used to implement priority queues and similar data structures.

func (*Heap) Add

func (h *Heap) Add(obj interface{}) error

Add inserts an item, and puts it in the queue. The item is updated if it already exists.

func (*Heap) AddIfNotPresent

func (h *Heap) AddIfNotPresent(obj interface{}) error

AddIfNotPresent inserts an item, and puts it in the queue. If an item with the key is present in the map, no changes is made to the item.

func (*Heap) Delete

func (h *Heap) Delete(obj interface{}) error

Delete removes an item.

func (*Heap) Get

func (h *Heap) Get(obj interface{}) (interface{}, bool, error)

Get returns the requested item, or sets exists=false.

func (*Heap) GetByKey

func (h *Heap) GetByKey(key string) (interface{}, bool, error)

GetByKey returns the requested item, or sets exists=false.

func (*Heap) List

func (h *Heap) List() []interface{}

List returns a list of all the items.

func (*Heap) Pop

func (h *Heap) Pop() (interface{}, error)

Pop returns the head of the heap.

func (*Heap) Update

func (h *Heap) Update(obj interface{}) error

Update is the same as Add in this implementation. When the item does not exist, it is added.

type KeyFunc

type KeyFunc func(obj interface{}) (string, error)

KeyFunc is a function type to get the key from an object.

type LessFunc

type LessFunc func(interface{}, interface{}) bool

LessFunc is a function type to compare two objects.

type PriorityQueue

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

PriorityQueue implements a scheduling queue. It is an alternative to FIFO. The head of PriorityQueue is the highest priority pending pod. This structure has two sub queues. One sub-queue holds pods that are being considered for scheduling. This is called activeQ and is a Heap. Another queue holds pods that are already tried and are determined to be unschedulable. The latter is called unschedulableQ.

func NewPriorityQueue

func NewPriorityQueue(stop <-chan struct{}) *PriorityQueue

NewPriorityQueue creates a PriorityQueue object.

func (*PriorityQueue) Add

func (p *PriorityQueue) Add(pod *v1.Pod) error

Add adds a pod to the active queue. It should be called only when a new pod is added so there is no chance the pod is already in either queue.

func (*PriorityQueue) AddIfNotPresent

func (p *PriorityQueue) AddIfNotPresent(pod *v1.Pod) error

AddIfNotPresent adds a pod to the active queue if it is not present in any of the two queues. If it is present in any, it doesn't do any thing.

func (*PriorityQueue) AddUnschedulableIfNotPresent

func (p *PriorityQueue) AddUnschedulableIfNotPresent(pod *v1.Pod, podSchedulingCycle int64) error

AddUnschedulableIfNotPresent does nothing if the pod is present in any queue. If pod is unschedulable, it adds pod to unschedulable queue if p.moveRequestCycle > podSchedulingCycle or to backoff queue if p.moveRequestCycle <= podSchedulingCycle but pod is subject to backoff. In other cases, it adds pod to active queue.

func (*PriorityQueue) AssignedPodAdded

func (p *PriorityQueue) AssignedPodAdded(pod *v1.Pod)

AssignedPodAdded is called when a bound pod is added. Creation of this pod may make pending pods with matching affinity terms schedulable.

func (*PriorityQueue) AssignedPodUpdated

func (p *PriorityQueue) AssignedPodUpdated(pod *v1.Pod)

AssignedPodUpdated is called when a bound pod is updated. Change of labels may make pending pods with matching affinity terms schedulable.

func (*PriorityQueue) Delete

func (p *PriorityQueue) Delete(pod *v1.Pod) error

Delete deletes the item from either of the two queues. It assumes the pod is only in one queue.

func (*PriorityQueue) DeleteNominatedPodIfExists added in v1.11.6

func (p *PriorityQueue) DeleteNominatedPodIfExists(pod *v1.Pod)

DeleteNominatedPodIfExists deletes pod nominatedPods.

func (*PriorityQueue) MoveAllToActiveQueue

func (p *PriorityQueue) MoveAllToActiveQueue()

MoveAllToActiveQueue moves all pods from unschedulableQ to activeQ. This function adds all pods and then signals the condition variable to ensure that if Pop() is waiting for an item, it receives it after all the pods are in the queue and the head is the highest priority pod. TODO(bsalamat): We should add a back-off mechanism here so that a high priority pod which is unschedulable does not go to the head of the queue frequently. For example in a cluster where a lot of pods being deleted, such a high priority pod can deprive other pods from getting scheduled.

func (*PriorityQueue) NominatedPodsForNode added in v1.11.7

func (p *PriorityQueue) NominatedPodsForNode(nodeName string) []*v1.Pod

NominatedPodsForNode returns pods that are nominated to run on the given node, but they are waiting for other pods to be removed from the node before they can be actually scheduled.

func (*PriorityQueue) NumUnschedulablePods added in v1.11.7

func (p *PriorityQueue) NumUnschedulablePods() int

NumUnschedulablePods returns the number of unschedulable pods exist in the SchedulingQueue.

func (*PriorityQueue) Pop

func (p *PriorityQueue) Pop() (*v1.Pod, error)

Pop removes the head of the active queue and returns it. It blocks if the activeQ is empty and waits until a new item is added to the queue. It increments scheduling cycle when a pod is popped.

func (*PriorityQueue) SchedulingCycle added in v1.12.6

func (p *PriorityQueue) SchedulingCycle() int64

SchedulingCycle returns current scheduling cycle.

func (*PriorityQueue) Update

func (p *PriorityQueue) Update(oldPod, newPod *v1.Pod) error

Update updates a pod in the active queue if present. Otherwise, it removes the item from the unschedulable queue and adds the updated one to the active queue.

func (*PriorityQueue) UpdateNominatedPodForNode added in v1.11.7

func (p *PriorityQueue) UpdateNominatedPodForNode(pod *v1.Pod, nodeName string)

UpdateNominatedPodForNode adds a pod to the nominated pods of the given node. This is called during the preemption process after a node is nominated to run the pod. We update the structure before sending a request to update the pod object to avoid races with the following scheduling cycles.

func (*PriorityQueue) WaitingPods added in v1.11.0

func (p *PriorityQueue) WaitingPods() []*v1.Pod

WaitingPods returns all the waiting pods in the queue.

type SchedulingQueue

type SchedulingQueue interface {
	Add(pod *v1.Pod) error
	AddIfNotPresent(pod *v1.Pod) error
	// AddUnschedulableIfNotPresent adds an unschedulable pod back to scheduling queue.
	// The podSchedulingCycle represents the current scheduling cycle number which can be
	// returned by calling SchedulingCycle().
	AddUnschedulableIfNotPresent(pod *v1.Pod, podSchedulingCycle int64) error
	// SchedulingCycle returns the current number of scheduling cycle which is
	// cached by scheduling queue. Normally, incrementing this number whenever
	// a pod is popped (e.g. called Pop()) is enough.
	SchedulingCycle() int64
	Pop() (*v1.Pod, error)
	Update(oldPod, newPod *v1.Pod) error
	Delete(pod *v1.Pod) error
	MoveAllToActiveQueue()
	AssignedPodAdded(pod *v1.Pod)
	AssignedPodUpdated(pod *v1.Pod)
	NominatedPodsForNode(nodeName string) []*v1.Pod
	WaitingPods() []*v1.Pod
	// UpdateNominatedPodForNode adds the given pod to the nominated pod map or
	// updates it if it already exists.
	UpdateNominatedPodForNode(pod *v1.Pod, nodeName string)
	// DeleteNominatedPodIfExists deletes nominatedPod from internal cache
	DeleteNominatedPodIfExists(pod *v1.Pod)
	// NumUnschedulablePods returns the number of unschedulable pods exist in the SchedulingQueue.
	NumUnschedulablePods() int
}

SchedulingQueue is an interface for a queue to store pods waiting to be scheduled. The interface follows a pattern similar to cache.FIFO and cache.Heap and makes it easy to use those data structures as a SchedulingQueue.

func NewSchedulingQueue

func NewSchedulingQueue(stop <-chan struct{}) SchedulingQueue

NewSchedulingQueue initializes a new scheduling queue. If pod priority is enabled a priority queue is returned. If it is disabled, a FIFO is returned.

type UnschedulablePodsMap

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

UnschedulablePodsMap holds pods that cannot be scheduled. This data structure is used to implement unschedulableQ.

Directories

Path Synopsis
Package equivalence defines Pod equivalence classes and the equivalence class cache.
Package equivalence defines Pod equivalence classes and the equivalence class cache.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL