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

package v1alpha1

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

Index

Package Files

context.go framework.go interface.go registry.go waiting_pods_map.go

Constants

const (
    // NotFound is the not found error message.
    NotFound = "not found"
)

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 accompanying status message should explain why the pod is unschedulable.
    Unschedulable
    // Wait is used when a permit plugin finds a pod scheduling should wait.
    Wait
)

These are predefined codes used in a Status.

type ContextData Uses

type ContextData interface{}

ContextData is a generic type for arbitrary data stored in PluginContext.

type ContextKey Uses

type ContextKey string

ContextKey is the type of keys stored in PluginContext.

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(pc *PluginContext, pod *v1.Pod) *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(pc *PluginContext, pod *v1.Pod, nodeName string) *Status

    // RunPostbindPlugins runs the set of configured postbind plugins.
    RunPostbindPlugins(pc *PluginContext, 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(pc *PluginContext, pod *v1.Pod, nodeName string) *Status

    // RunUnreservePlugins runs the set of configured unreserve plugins.
    RunUnreservePlugins(pc *PluginContext, 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(pc *PluginContext, pod *v1.Pod, nodeName string) *Status
}

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) (Framework, error)

NewFramework initializes plugins given the configuration and the registry.

type FrameworkHandle Uses

type FrameworkHandle interface {
    // NodeInfoSnapshot return 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.
    NodeInfoSnapshot() *internalcache.NodeInfoSnapshot

    // 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
}

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 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(pc *PluginContext, 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 PluginContext Uses

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

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

func NewPluginContext Uses

func NewPluginContext() *PluginContext

NewPluginContext initializes a new PluginContext and returns its pointer.

func (*PluginContext) Delete Uses

func (c *PluginContext) Delete(key ContextKey)

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

func (*PluginContext) Lock Uses

func (c *PluginContext) Lock()

Lock acquires PluginContext lock.

func (*PluginContext) RLock Uses

func (c *PluginContext) RLock()

RLock acquires PluginContext read lock.

func (*PluginContext) RUnlock Uses

func (c *PluginContext) RUnlock()

RUnlock releases PluginContext read lock.

func (*PluginContext) Read Uses

func (c *PluginContext) Read(key ContextKey) (ContextData, error)

Read retrieves data with the given "key" from PluginContext. 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 (*PluginContext) Unlock Uses

func (c *PluginContext) Unlock()

Unlock releases PluginContext lock.

func (*PluginContext) Write Uses

func (c *PluginContext) Write(key ContextKey, val ContextData)

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

type PluginFactory Uses

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

PluginFactory is a function that builds a plugin.

type PodInfo Uses

type PodInfo struct {
    Pod *v1.Pod
    // The time pod added to the scheduling queue.
    Timestamp time.Time
}

PodInfo is minimum cell in the scheduling queue.

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(pc *PluginContext, 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 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(pc *PluginContext, 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 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(pc *PluginContext, p *v1.Pod) *Status
}

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 NewRegistry Uses

func NewRegistry() Registry

NewRegistry builds a default registry with all the default plugins. This is the registry that Kubernetes default scheduler uses. A scheduler that runs custom plugins, can pass a different Registry and when initializing the scheduler.

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(pc *PluginContext, 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 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) 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(pc *PluginContext, 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
    // Allow the waiting pod to be scheduled. Returns true if the allow signal was
    // successfully delivered, false otherwise.
    Allow() bool
    // Reject declares the waiting pod unschedulable. Returns true if the allow signal
    // was successfully delivered, false otherwise.
    Reject(msg string) bool
}

WaitingPod represents a pod currently waiting in the permit phase.

Package v1alpha1 imports 10 packages (graph) and is imported by 38 packages. Updated 2019-07-15. Refresh now. Tools for package owners.