kubernetes: k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1 Index | Files

package v1alpha1

import "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"

Index

Package Files

cycle_state.go framework.go interface.go metrics_recorder.go registry.go waiting_pods_map.go

Constants

const (
    // MaxNodeScore is the maximum score a Score plugin is expected to return.
    MaxNodeScore int64 = 100

    // MinNodeScore is the minimum score a Score plugin is expected to return.
    MinNodeScore int64 = 0

    // MaxTotalScore is the maximum total score.
    MaxTotalScore int64 = math.MaxInt64
)
const (
    // NotFound is the not found error message.
    NotFound = "not found"
)

func DecodeInto Uses

func DecodeInto(configuration *runtime.Unknown, into interface{}) error

DecodeInto decodes configuration whose type is *runtime.Unknown to the interface into.

type BindPlugin Uses

type BindPlugin interface {
    Plugin
    // Bind plugins will not be called until all pre-bind plugins have completed. Each
    // bind plugin is called in the configured order. A bind plugin may choose whether
    // or not to handle the given Pod. If a bind plugin chooses to handle a Pod, the
    // remaining bind plugins are skipped. When a bind plugin does not handle a pod,
    // it must return Skip in its Status code. If a bind plugin returns an Error, the
    // pod is rejected and will not be bound.
    Bind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
}

BindPlugin is an interface that must be implemented by "bind" plugins. Bind plugins are used to bind a pod to a Node.

type Code Uses

type Code int

Code is the Status code/type which is returned from plugins.

const (
    // Success means that plugin ran correctly and found pod schedulable.
    // NOTE: A nil status is also considered as "Success".
    Success Code = iota
    // Error is used for internal plugin errors, unexpected input, etc.
    Error
    // Unschedulable is used when a plugin finds a pod unschedulable. The scheduler might attempt to
    // preempt other pods to get this pod scheduled. Use UnschedulableAndUnresolvable to make the
    // scheduler skip preemption.
    // The accompanying status message should explain why the pod is unschedulable.
    Unschedulable
    // UnschedulableAndUnresolvable is used when a (pre-)filter plugin finds a pod unschedulable and
    // preemption would not change anything. Plugins should return Unschedulable if it is possible
    // that the pod can get scheduled with preemption.
    // The accompanying status message should explain why the pod is unschedulable.
    UnschedulableAndUnresolvable
    // Wait is used when a permit plugin finds a pod scheduling should wait.
    Wait
    // Skip is used when a bind plugin chooses to skip binding.
    Skip
)

These are predefined codes used in a Status.

func (Code) String Uses

func (c Code) String() string

type CycleState Uses

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

CycleState provides a mechanism for plugins to store and retrieve arbitrary data. StateData stored by one plugin can be read, altered, or deleted by another plugin. CycleState does not provide any data protection, as all plugins are assumed to be trusted.

func NewCycleState Uses

func NewCycleState() *CycleState

NewCycleState initializes a new CycleState and returns its pointer.

func (*CycleState) Clone Uses

func (c *CycleState) Clone() *CycleState

Clone creates a copy of CycleState and returns its pointer. Clone returns nil if the context being cloned is nil.

func (*CycleState) Delete Uses

func (c *CycleState) Delete(key StateKey)

Delete deletes data with the given key from CycleState. This function is not thread safe. In multi-threaded code, lock should be acquired first.

func (*CycleState) Lock Uses

func (c *CycleState) Lock()

Lock acquires CycleState lock.

func (*CycleState) RLock Uses

func (c *CycleState) RLock()

RLock acquires CycleState read lock.

func (*CycleState) RUnlock Uses

func (c *CycleState) RUnlock()

RUnlock releases CycleState read lock.

func (*CycleState) Read Uses

func (c *CycleState) Read(key StateKey) (StateData, error)

Read retrieves data with the given "key" from CycleState. If the key is not present an error is returned. This function is not thread safe. In multi-threaded code, lock should be acquired first.

func (*CycleState) SetRecordFrameworkMetrics Uses

func (c *CycleState) SetRecordFrameworkMetrics(flag bool)

SetRecordFrameworkMetrics sets recordFrameworkMetrics to the given value.

func (*CycleState) ShouldRecordFrameworkMetrics Uses

func (c *CycleState) ShouldRecordFrameworkMetrics() bool

ShouldRecordFrameworkMetrics returns whether framework metrics should be recorded.

func (*CycleState) Unlock Uses

func (c *CycleState) Unlock()

Unlock releases CycleState lock.

func (*CycleState) Write Uses

func (c *CycleState) Write(key StateKey, val StateData)

Write stores the given "val" in CycleState with the given "key". This function is not thread safe. In multi-threaded code, lock should be acquired first.

type FilterPlugin Uses

type FilterPlugin interface {
    Plugin
    // Filter is called by the scheduling framework.
    // All FilterPlugins should return "Success" to declare that
    // the given node fits the pod. If Filter doesn't return "Success",
    // please refer scheduler/algorithm/predicates/error.go
    // to set error message.
    // For the node being evaluated, Filter plugins should look at the passed
    // nodeInfo reference for this particular node's information (e.g., pods
    // considered to be running on the node) instead of looking it up in the
    // NodeInfoSnapshot because we don't guarantee that they will be the same.
    // For example, during preemption, we may pass a copy of the original
    // nodeInfo object that has some pods removed from it to evaluate the
    // possibility of preempting them to schedule the target pod.
    Filter(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status
}

FilterPlugin is an interface for Filter plugins. These plugins are called at the filter extension point for filtering out hosts that cannot run a pod. This concept used to be called 'predicate' in the original scheduler. These plugins should return "Success", "Unschedulable" or "Error" in Status.code. However, the scheduler accepts other valid codes as well. Anything other than "Success" will lead to exclusion of the given host from running the pod.

type Framework Uses

type Framework interface {
    FrameworkHandle
    // QueueSortFunc returns the function to sort pods in scheduling queue
    QueueSortFunc() LessFunc

    // RunPreFilterPlugins runs the set of configured prefilter plugins. It returns
    // *Status and its code is set to non-success if any of the plugins returns
    // anything but Success. If a non-success status is returned, then the scheduling
    // cycle is aborted.
    RunPreFilterPlugins(ctx context.Context, state *CycleState, pod *v1.Pod) *Status

    // RunFilterPlugins runs the set of configured filter plugins for pod on
    // the given node. It returns directly if any of the filter plugins
    // return any status other than "Success". Note that for the node being
    // evaluated, the passed nodeInfo reference could be different from the
    // one in NodeInfoSnapshot map (e.g., pods considered to be running on
    // the node could be different). For example, during preemption, we may
    // pass a copy of the original nodeInfo object that has some pods
    // removed from it to evaluate the possibility of preempting them to
    // schedule the target pod.
    RunFilterPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status

    // RunPreFilterExtensionAddPod calls the AddPod interface for the set of configured
    // PreFilter plugins. It returns directly if any of the plugins return any
    // status other than Success.
    RunPreFilterExtensionAddPod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status

    // RunPreFilterExtensionRemovePod calls the RemovePod interface for the set of configured
    // PreFilter plugins. It returns directly if any of the plugins return any
    // status other than Success.
    RunPreFilterExtensionRemovePod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status

    // RunPostFilterPlugins runs the set of configured post-filter plugins. If any
    // of these plugins returns any status other than "Success", the given node is
    // rejected. The filteredNodeStatuses is the set of filtered nodes and their statuses.
    RunPostFilterPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodes []*v1.Node, filteredNodesStatuses NodeToStatusMap) *Status

    // RunScorePlugins runs the set of configured scoring plugins. It returns a map that
    // stores for each scoring plugin name the corresponding NodeScoreList(s).
    // It also returns *Status, which is set to non-success if any of the plugins returns
    // a non-success status.
    RunScorePlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodes []*v1.Node) (PluginToNodeScores, *Status)

    // RunPreBindPlugins runs the set of configured prebind plugins. It returns
    // *Status and its code is set to non-success if any of the plugins returns
    // anything but Success. If the Status code is "Unschedulable", it is
    // considered as a scheduling check failure, otherwise, it is considered as an
    // internal error. In either case the pod is not going to be bound.
    RunPreBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

    // RunPostBindPlugins runs the set of configured postbind plugins.
    RunPostBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string)

    // RunReservePlugins runs the set of configured reserve plugins. If any of these
    // plugins returns an error, it does not continue running the remaining ones and
    // returns the error. In such case, pod will not be scheduled.
    RunReservePlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

    // RunUnreservePlugins runs the set of configured unreserve plugins.
    RunUnreservePlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string)

    // RunPermitPlugins runs the set of configured permit plugins. If any of these
    // plugins returns a status other than "Success" or "Wait", it does not continue
    // running the remaining plugins and returns an error. Otherwise, if any of the
    // plugins returns "Wait", then this function will block for the timeout period
    // returned by the plugin, if the time expires, then it will return an error.
    // Note that if multiple plugins asked to wait, then we wait for the minimum
    // timeout duration.
    RunPermitPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

    // RunBindPlugins runs the set of configured bind plugins. A bind plugin may choose
    // whether or not to handle the given Pod. If a bind plugin chooses to skip the
    // binding, it should return code=4("skip") status. Otherwise, it should return "Error"
    // or "Success". If none of the plugins handled binding, RunBindPlugins returns
    // code=4("skip") status.
    RunBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

    // HasFilterPlugins returns true if at least one filter plugin is defined.
    HasFilterPlugins() bool

    // HasScorePlugins returns true if at least one score plugin is defined.
    HasScorePlugins() bool

    // ListPlugins returns a map of extension point name to list of configured Plugins.
    ListPlugins() map[string][]config.Plugin
}

Framework manages the set of plugins in use by the scheduling framework. Configured plugins are called at specified points in a scheduling context.

func NewFramework Uses

func NewFramework(r Registry, plugins *config.Plugins, args []config.PluginConfig, opts ...Option) (Framework, error)

NewFramework initializes plugins given the configuration and the registry.

type FrameworkHandle Uses

type FrameworkHandle interface {
    // SnapshotSharedLister returns listers from the latest NodeInfo Snapshot. The snapshot
    // is taken at the beginning of a scheduling cycle and remains unchanged until
    // a pod finishes "Reserve" point. There is no guarantee that the information
    // remains unchanged in the binding phase of scheduling, so plugins in the binding
    // cycle(permit/pre-bind/bind/post-bind/un-reserve plugin) should not use it,
    // otherwise a concurrent read/write error might occur, they should use scheduler
    // cache instead.
    SnapshotSharedLister() schedulerlisters.SharedLister

    // IterateOverWaitingPods acquires a read lock and iterates over the WaitingPods map.
    IterateOverWaitingPods(callback func(WaitingPod))

    // GetWaitingPod returns a waiting pod given its UID.
    GetWaitingPod(uid types.UID) WaitingPod

    // RejectWaitingPod rejects a waiting pod given its UID.
    RejectWaitingPod(uid types.UID)

    // ClientSet returns a kubernetes clientSet.
    ClientSet() clientset.Interface

    SharedInformerFactory() informers.SharedInformerFactory
}

FrameworkHandle provides data and some tools that plugins can use. It is passed to the plugin factories at the time of plugin initialization. Plugins must store and use this handle to call framework functions.

type LessFunc Uses

type LessFunc func(podInfo1, podInfo2 *PodInfo) bool

LessFunc is the function to sort pod info

type NodeScore Uses

type NodeScore struct {
    Name  string
    Score int64
}

NodeScore is a struct with node name and score.

type NodeScoreList Uses

type NodeScoreList []NodeScore

NodeScoreList declares a list of nodes and their scores.

type NodeToStatusMap Uses

type NodeToStatusMap map[string]*Status

NodeToStatusMap declares map from node name to its status.

type Option Uses

type Option func(*frameworkOptions)

Option for the framework.

func WithClientSet Uses

func WithClientSet(clientSet clientset.Interface) Option

WithClientSet sets clientSet for the scheduling framework.

func WithInformerFactory Uses

func WithInformerFactory(informerFactory informers.SharedInformerFactory) Option

WithInformerFactory sets informer factory for the scheduling framework.

func WithSnapshotSharedLister Uses

func WithSnapshotSharedLister(snapshotSharedLister schedulerlisters.SharedLister) Option

WithSnapshotSharedLister sets the SharedLister of the snapshot.

type PermitPlugin Uses

type PermitPlugin interface {
    Plugin
    // Permit is called before binding a pod (and before prebind plugins). Permit
    // plugins are used to prevent or delay the binding of a Pod. A permit plugin
    // must return success or wait with timeout duration, or the pod will be rejected.
    // The pod will also be rejected if the wait timeout or the pod is rejected while
    // waiting. Note that if the plugin returns "wait", the framework will wait only
    // after running the remaining plugins given that no other plugin rejects the pod.
    Permit(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) (*Status, time.Duration)
}

PermitPlugin is an interface that must be implemented by "permit" plugins. These plugins are called before a pod is bound to a node.

type Plugin Uses

type Plugin interface {
    Name() string
}

Plugin is the parent type for all the scheduling framework plugins.

type PluginFactory Uses

type PluginFactory = func(configuration *runtime.Unknown, f FrameworkHandle) (Plugin, error)

PluginFactory is a function that builds a plugin.

type PluginToNodeScores Uses

type PluginToNodeScores map[string]NodeScoreList

PluginToNodeScores declares a map from plugin name to its NodeScoreList.

type PodInfo Uses

type PodInfo struct {
    Pod *v1.Pod
    // The time pod added to the scheduling queue.
    Timestamp time.Time
    // Number of schedule attempts before successfully scheduled.
    // It's used to record the # attempts metric.
    Attempts int
    // The time when the pod is added to the queue for the first time. The pod may be added
    // back to the queue multiple times before it's successfully scheduled.
    // It shouldn't be updated once initialized. It's used to record the e2e scheduling
    // latency for a pod.
    InitialAttemptTimestamp time.Time
}

PodInfo is a wrapper to a Pod with additional information for purposes such as tracking the timestamp when it's added to the queue or recording per-pod metrics.

func (*PodInfo) DeepCopy Uses

func (podInfo *PodInfo) DeepCopy() *PodInfo

DeepCopy returns a deep copy of the PodInfo object.

type PostBindPlugin Uses

type PostBindPlugin interface {
    Plugin
    // PostBind is called after a pod is successfully bound. These plugins are
    // informational. A common application of this extension point is for cleaning
    // up. If a plugin needs to clean-up its state after a pod is scheduled and
    // bound, PostBind is the extension point that it should register.
    PostBind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string)
}

PostBindPlugin is an interface that must be implemented by "postbind" plugins. These plugins are called after a pod is successfully bound to a node.

type PostFilterPlugin Uses

type PostFilterPlugin interface {
    Plugin
    // PostFilter is called by the scheduling framework after a list of nodes
    // passed the filtering phase. All postfilter plugins must return success or
    // the pod will be rejected. The filteredNodesStatuses is the set of filtered nodes
    // and their filter status.
    PostFilter(ctx context.Context, state *CycleState, pod *v1.Pod, nodes []*v1.Node, filteredNodesStatuses NodeToStatusMap) *Status
}

PostFilterPlugin is an interface for Post-filter plugin. Post-filter is an informational extension point. Plugins will be called with a list of nodes that passed the filtering phase. A plugin may use this data to update internal state or to generate logs/metrics.

type PreBindPlugin Uses

type PreBindPlugin interface {
    Plugin
    // PreBind is called before binding a pod. All prebind plugins must return
    // success or the pod will be rejected and won't be sent for binding.
    PreBind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
}

PreBindPlugin is an interface that must be implemented by "prebind" plugins. These plugins are called before a pod being scheduled.

type PreFilterExtensions Uses

type PreFilterExtensions interface {
    // AddPod is called by the framework while trying to evaluate the impact
    // of adding podToAdd to the node while scheduling podToSchedule.
    AddPod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status
    // RemovePod is called by the framework while trying to evaluate the impact
    // of removing podToRemove from the node while scheduling podToSchedule.
    RemovePod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToRemove *v1.Pod, nodeInfo *schedulernodeinfo.NodeInfo) *Status
}

PreFilterExtensions is an interface that is included in plugins that allow specifying callbacks to make incremental updates to its supposedly pre-calculated state.

type PreFilterPlugin Uses

type PreFilterPlugin interface {
    Plugin
    // PreFilter is called at the beginning of the scheduling cycle. All PreFilter
    // plugins must return success or the pod will be rejected.
    PreFilter(ctx context.Context, state *CycleState, p *v1.Pod) *Status
    // PreFilterExtensions returns a PreFilterExtensions interface if the plugin implements one,
    // or nil if it does not. A Pre-filter plugin can provide extensions to incrementally
    // modify its pre-processed info. The framework guarantees that the extensions
    // AddPod/RemovePod will only be called after PreFilter, possibly on a cloned
    // CycleState, and may call those functions more than once before calling
    // Filter again on a specific node.
    PreFilterExtensions() PreFilterExtensions
}

PreFilterPlugin is an interface that must be implemented by "prefilter" plugins. These plugins are called at the beginning of the scheduling cycle.

type QueueSortPlugin Uses

type QueueSortPlugin interface {
    Plugin
    // Less are used to sort pods in the scheduling queue.
    Less(*PodInfo, *PodInfo) bool
}

QueueSortPlugin is an interface that must be implemented by "QueueSort" plugins. These plugins are used to sort pods in the scheduling queue. Only one queue sort plugin may be enabled at a time.

type Registry Uses

type Registry map[string]PluginFactory

Registry is a collection of all available plugins. The framework uses a registry to enable and initialize configured plugins. All plugins must be in the registry before initializing the framework.

func (Registry) Merge Uses

func (r Registry) Merge(in Registry) error

Merge merges the provided registry to the current one.

func (Registry) Register Uses

func (r Registry) Register(name string, factory PluginFactory) error

Register adds a new plugin to the registry. If a plugin with the same name exists, it returns an error.

func (Registry) Unregister Uses

func (r Registry) Unregister(name string) error

Unregister removes an existing plugin from the registry. If no plugin with the provided name exists, it returns an error.

type ReservePlugin Uses

type ReservePlugin interface {
    Plugin
    // Reserve is called by the scheduling framework when the scheduler cache is
    // updated.
    Reserve(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
}

ReservePlugin is an interface for Reserve plugins. These plugins are called at the reservation point. These are meant to update the state of the plugin. This concept used to be called 'assume' in the original scheduler. These plugins should return only Success or Error in Status.code. However, the scheduler accepts other valid codes as well. Anything other than Success will lead to rejection of the pod.

type ScoreExtensions Uses

type ScoreExtensions interface {
    // NormalizeScore is called for all node scores produced by the same plugin's "Score"
    // method. A successful run of NormalizeScore will update the scores list and return
    // a success status.
    NormalizeScore(ctx context.Context, state *CycleState, p *v1.Pod, scores NodeScoreList) *Status
}

ScoreExtensions is an interface for Score extended functionality.

type ScorePlugin Uses

type ScorePlugin interface {
    Plugin
    // Score is called on each filtered node. It must return success and an integer
    // indicating the rank of the node. All scoring plugins must return success or
    // the pod will be rejected.
    Score(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) (int64, *Status)

    // ScoreExtensions returns a ScoreExtensions interface if it implements one, or nil if does not.
    ScoreExtensions() ScoreExtensions
}

ScorePlugin is an interface that must be implemented by "score" plugins to rank nodes that passed the filtering phase.

type StateData Uses

type StateData interface {
    // Clone is an interface to make a copy of StateData. For performance reasons,
    // clone should make shallow copies for members (e.g., slices or maps) that are not
    // impacted by PreFilter's optional AddPod/RemovePod methods.
    Clone() StateData
}

StateData is a generic type for arbitrary data stored in CycleState.

type StateKey Uses

type StateKey string

StateKey is the type of keys stored in CycleState.

type Status Uses

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

Status indicates the result of running a plugin. It consists of a code and a message. When the status code is not `Success`, the status message should explain why. NOTE: A nil Status is also considered as Success.

func NewStatus Uses

func NewStatus(code Code, msg string) *Status

NewStatus makes a Status out of the given arguments and returns its pointer.

func (*Status) AsError Uses

func (s *Status) AsError() error

AsError returns an "error" object with the same message as that of the Status.

func (*Status) Code Uses

func (s *Status) Code() Code

Code returns code of the Status.

func (*Status) IsSuccess Uses

func (s *Status) IsSuccess() bool

IsSuccess returns true if and only if "Status" is nil or Code is "Success".

func (*Status) IsUnschedulable Uses

func (s *Status) IsUnschedulable() bool

IsUnschedulable returns true if "Status" is Unschedulable (Unschedulable or UnschedulableAndUnresolvable).

func (*Status) Message Uses

func (s *Status) Message() string

Message returns message of the Status.

type UnreservePlugin Uses

type UnreservePlugin interface {
    Plugin
    // Unreserve is called by the scheduling framework when a reserved pod was
    // rejected in a later phase.
    Unreserve(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string)
}

UnreservePlugin is an interface for Unreserve plugins. This is an informational extension point. If a pod was reserved and then rejected in a later phase, then un-reserve plugins will be notified. Un-reserve plugins should clean up state associated with the reserved Pod.

type WaitingPod Uses

type WaitingPod interface {
    // GetPod returns a reference to the waiting pod.
    GetPod() *v1.Pod
    // GetPendingPlugins returns a list of pending permit plugin's name.
    GetPendingPlugins() []string
    // Allow declares the waiting pod is allowed to be scheduled by plugin pluginName.
    // If this is the last remaining plugin to allow, then a success signal is delivered
    // to unblock the pod.
    // Returns true if the allow signal was successfully dealt with, false otherwise.
    Allow(pluginName string) bool
    // Reject declares the waiting pod unschedulable. Returns true if the reject signal
    // was successfully delivered, false otherwise.
    Reject(msg string) bool
}

WaitingPod represents a pod currently waiting in the permit phase.

Package v1alpha1 imports 23 packages (graph) and is imported by 80 packages. Updated 2019-11-17. Refresh now. Tools for package owners.