kubernetes: k8s.io/kubernetes/pkg/controller/volume/scheduling Index | Files | Directories

package scheduling

import "k8s.io/kubernetes/pkg/controller/volume/scheduling"

Index

Package Files

scheduler_assume_cache.go scheduler_binder.go scheduler_binder_fake.go

type AssumeCache Uses

type AssumeCache interface {
    // Assume updates the object in-memory only
    Assume(obj interface{}) error

    // Restore the informer cache's version of the object
    Restore(objName string)

    // Get the object by name
    Get(objName string) (interface{}, error)

    // Get the API object by name
    GetAPIObj(objName string) (interface{}, error)

    // List all the objects in the cache
    List(indexObj interface{}) []interface{}
}

AssumeCache is a cache on top of the informer that allows for updating objects outside of informer events and also restoring the informer cache's version of the object. Objects are assumed to be Kubernetes API objects that implement meta.Interface

func NewAssumeCache Uses

func NewAssumeCache(informer cache.SharedIndexInformer, description, indexName string, indexFunc cache.IndexFunc) AssumeCache

NewAssumeCache creates an assume cache for general objects.

type BindingInfo Uses

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

BindingInfo holds a binding between PV and PVC.

type CapacityCheck Uses

type CapacityCheck struct {
    CSIDriverInformer          storageinformers.CSIDriverInformer
    CSIStorageCapacityInformer storageinformersv1alpha1.CSIStorageCapacityInformer
}

CapacityCheck contains additional parameters for NewVolumeBinder that are only needed when checking volume sizes against available storage capacity is desired.

type ConflictReason Uses

type ConflictReason string

ConflictReason is used for the special strings which explain why volume binding is impossible for a node.

const (
    // ErrReasonBindConflict is used for VolumeBindingNoMatch predicate error.
    ErrReasonBindConflict ConflictReason = "node(s) didn't find available persistent volumes to bind"
    // ErrReasonNodeConflict is used for VolumeNodeAffinityConflict predicate error.
    ErrReasonNodeConflict ConflictReason = "node(s) had volume node affinity conflict"
    // ErrReasonNotEnoughSpace is used when a pod cannot start on a node because not enough storage space is available.
    ErrReasonNotEnoughSpace = "node(s) did not have enough free storage"
)

type ConflictReasons Uses

type ConflictReasons []ConflictReason

ConflictReasons contains all reasons that explain why volume binding is impossible for a node.

func (ConflictReasons) Len Uses

func (reasons ConflictReasons) Len() int

func (ConflictReasons) Less Uses

func (reasons ConflictReasons) Less(i, j int) bool

func (ConflictReasons) Swap Uses

func (reasons ConflictReasons) Swap(i, j int)

type FakeVolumeBinder Uses

type FakeVolumeBinder struct {
    AssumeCalled bool
    BindCalled   bool
    // contains filtered or unexported fields
}

FakeVolumeBinder represents a fake volume binder for testing.

func NewFakeVolumeBinder Uses

func NewFakeVolumeBinder(config *FakeVolumeBinderConfig) *FakeVolumeBinder

NewFakeVolumeBinder sets up all the caches needed for the scheduler to make topology-aware volume binding decisions.

func (*FakeVolumeBinder) AssumePodVolumes Uses

func (b *FakeVolumeBinder) AssumePodVolumes(assumedPod *v1.Pod, nodeName string, podVolumes *PodVolumes) (bool, error)

AssumePodVolumes implements SchedulerVolumeBinder.AssumePodVolumes.

func (*FakeVolumeBinder) BindPodVolumes Uses

func (b *FakeVolumeBinder) BindPodVolumes(assumedPod *v1.Pod, podVolumes *PodVolumes) error

BindPodVolumes implements SchedulerVolumeBinder.BindPodVolumes.

func (*FakeVolumeBinder) FindPodVolumes Uses

func (b *FakeVolumeBinder) FindPodVolumes(pod *v1.Pod, _, _ []*v1.PersistentVolumeClaim, node *v1.Node) (podVolumes *PodVolumes, reasons ConflictReasons, err error)

FindPodVolumes implements SchedulerVolumeBinder.FindPodVolumes.

func (*FakeVolumeBinder) GetPodVolumes Uses

func (b *FakeVolumeBinder) GetPodVolumes(pod *v1.Pod) (boundClaims, unboundClaimsDelayBinding, unboundClaimsImmediate []*v1.PersistentVolumeClaim, err error)

GetPodVolumes implements SchedulerVolumeBinder.GetPodVolumes.

func (*FakeVolumeBinder) RevertAssumedPodVolumes Uses

func (b *FakeVolumeBinder) RevertAssumedPodVolumes(_ *PodVolumes)

RevertAssumedPodVolumes implements SchedulerVolumeBinder.RevertAssumedPodVolumes

type FakeVolumeBinderConfig Uses

type FakeVolumeBinderConfig struct {
    AllBound    bool
    FindReasons ConflictReasons
    FindErr     error
    AssumeErr   error
    BindErr     error
}

FakeVolumeBinderConfig holds configurations for fake volume binder.

type InTreeToCSITranslator Uses

type InTreeToCSITranslator interface {
    IsPVMigratable(pv *v1.PersistentVolume) bool
    GetInTreePluginNameFromSpec(pv *v1.PersistentVolume, vol *v1.Volume) (string, error)
    TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error)
}

InTreeToCSITranslator contains methods required to check migratable status and perform translations from InTree PV's to CSI

type PVAssumeCache Uses

type PVAssumeCache interface {
    AssumeCache

    GetPV(pvName string) (*v1.PersistentVolume, error)
    GetAPIPV(pvName string) (*v1.PersistentVolume, error)
    ListPVs(storageClassName string) []*v1.PersistentVolume
}

PVAssumeCache is a AssumeCache for PersistentVolume objects

func NewPVAssumeCache Uses

func NewPVAssumeCache(informer cache.SharedIndexInformer) PVAssumeCache

NewPVAssumeCache creates a PV assume cache.

type PVCAssumeCache Uses

type PVCAssumeCache interface {
    AssumeCache

    // GetPVC returns the PVC from the cache with given pvcKey.
    // pvcKey is the result of MetaNamespaceKeyFunc on PVC obj
    GetPVC(pvcKey string) (*v1.PersistentVolumeClaim, error)
    GetAPIPVC(pvcKey string) (*v1.PersistentVolumeClaim, error)
}

PVCAssumeCache is a AssumeCache for PersistentVolumeClaim objects

func NewPVCAssumeCache Uses

func NewPVCAssumeCache(informer cache.SharedIndexInformer) PVCAssumeCache

NewPVCAssumeCache creates a PVC assume cache.

type PodVolumes Uses

type PodVolumes struct {
    // StaticBindings are binding decisions for PVCs which can be bound to
    // pre-provisioned static PVs.
    StaticBindings []*BindingInfo
    // DynamicProvisions are PVCs that require dynamic provisioning
    DynamicProvisions []*v1.PersistentVolumeClaim
}

PodVolumes holds pod's volumes information used in volume scheduling.

type SchedulerVolumeBinder Uses

type SchedulerVolumeBinder interface {
    // GetPodVolumes returns a pod's PVCs separated into bound, unbound with delayed binding (including provisioning)
    // and unbound with immediate binding (including prebound)
    GetPodVolumes(pod *v1.Pod) (boundClaims, unboundClaimsDelayBinding, unboundClaimsImmediate []*v1.PersistentVolumeClaim, err error)

    // FindPodVolumes checks if all of a Pod's PVCs can be satisfied by the
    // node and returns pod's volumes information.
    //
    // If a PVC is bound, it checks if the PV's NodeAffinity matches the Node.
    // Otherwise, it tries to find an available PV to bind to the PVC.
    //
    // It returns an error when something went wrong or a list of reasons why the node is
    // (currently) not usable for the pod.
    //
    // If the CSIStorageCapacity feature is enabled, then it also checks for sufficient storage
    // for volumes that still need to be created.
    //
    // This function is called by the scheduler VolumeBinding plugin and can be called in parallel
    FindPodVolumes(pod *v1.Pod, boundClaims, claimsToBind []*v1.PersistentVolumeClaim, node *v1.Node) (podVolumes *PodVolumes, reasons ConflictReasons, err error)

    // AssumePodVolumes will:
    // 1. Take the PV matches for unbound PVCs and update the PV cache assuming
    // that the PV is prebound to the PVC.
    // 2. Take the PVCs that need provisioning and update the PVC cache with related
    // annotations set.
    //
    // It returns true if all volumes are fully bound
    //
    // This function is called serially.
    AssumePodVolumes(assumedPod *v1.Pod, nodeName string, podVolumes *PodVolumes) (allFullyBound bool, err error)

    // RevertAssumedPodVolumes will revert assumed PV and PVC cache.
    RevertAssumedPodVolumes(podVolumes *PodVolumes)

    // BindPodVolumes will:
    // 1. Initiate the volume binding by making the API call to prebind the PV
    // to its matching PVC.
    // 2. Trigger the volume provisioning by making the API call to set related
    // annotations on the PVC
    // 3. Wait for PVCs to be completely bound by the PV controller
    //
    // This function can be called in parallel.
    BindPodVolumes(assumedPod *v1.Pod, podVolumes *PodVolumes) error
}

SchedulerVolumeBinder is used by the scheduler VolumeBinding plugin to handle PVC/PV binding and dynamic provisioning. The binding decisions are integrated into the pod scheduling workflow so that the PV NodeAffinity is also considered along with the pod's other scheduling requirements.

This integrates into the existing scheduler workflow as follows: 1. The scheduler takes a Pod off the scheduler queue and processes it serially:

a. Invokes all pre-filter plugins for the pod. GetPodVolumes() is invoked
here, pod volume information will be saved in current scheduling cycle state for later use.
b. Invokes all filter plugins, parallelized across nodes.  FindPodVolumes() is invoked here.
c. Invokes all score plugins.  Future/TBD
d. Selects the best node for the Pod.
e. Invokes all reserve plugins. AssumePodVolumes() is invoked here.
   i.  If PVC binding is required, cache in-memory only:
       * For manual binding: update PV objects for prebinding to the corresponding PVCs.
       * For dynamic provisioning: update PVC object with a selected node from c)
       * For the pod, which PVCs and PVs need API updates.
   ii. Afterwards, the main scheduler caches the Pod->Node binding in the scheduler's pod cache,
       This is handled in the scheduler and not here.
f. Asynchronously bind volumes and pod in a separate goroutine
    i.  BindPodVolumes() is called first in PreBind phase. It makes all the necessary API updates and waits for
        PV controller to fully bind and provision the PVCs. If binding fails, the Pod is sent
        back through the scheduler.
    ii. After BindPodVolumes() is complete, then the scheduler does the final Pod->Node binding.

2. Once all the assume operations are done in e), the scheduler processes the next Pod in the scheduler queue

while the actual binding operation occurs in the background.

func NewVolumeBinder Uses

func NewVolumeBinder(
    kubeClient clientset.Interface,
    podInformer coreinformers.PodInformer,
    nodeInformer coreinformers.NodeInformer,
    csiNodeInformer storageinformers.CSINodeInformer,
    pvcInformer coreinformers.PersistentVolumeClaimInformer,
    pvInformer coreinformers.PersistentVolumeInformer,
    storageClassInformer storageinformers.StorageClassInformer,
    capacityCheck *CapacityCheck,
    bindTimeout time.Duration) SchedulerVolumeBinder

NewVolumeBinder sets up all the caches needed for the scheduler to make volume binding decisions.

capacityCheck determines whether storage capacity is checked (CSIStorageCapacity feature).

Directories

PathSynopsis
metrics

Package scheduling imports 34 packages (graph) and is imported by 48 packages. Updated 2020-09-16. Refresh now. Tools for package owners.