kubernetes: k8s.io/kubernetes/pkg/scheduler/algorithm/predicates Index | Examples | Files

package predicates

import "k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"

Index

Examples

Package Files

error.go metadata.go predicates.go testing_helper.go utils.go

Constants

const (
    // MatchInterPodAffinityPred defines the name of predicate MatchInterPodAffinity.
    MatchInterPodAffinityPred = "MatchInterPodAffinity"
    // CheckVolumeBindingPred defines the name of predicate CheckVolumeBinding.
    CheckVolumeBindingPred = "CheckVolumeBinding"
    // CheckNodeConditionPred defines the name of predicate CheckNodeCondition.
    CheckNodeConditionPred = "CheckNodeCondition"
    // GeneralPred defines the name of predicate GeneralPredicates.
    GeneralPred = "GeneralPredicates"
    // HostNamePred defines the name of predicate HostName.
    HostNamePred = "HostName"
    // PodFitsHostPortsPred defines the name of predicate PodFitsHostPorts.
    PodFitsHostPortsPred = "PodFitsHostPorts"
    // MatchNodeSelectorPred defines the name of predicate MatchNodeSelector.
    MatchNodeSelectorPred = "MatchNodeSelector"
    // PodFitsResourcesPred defines the name of predicate PodFitsResources.
    PodFitsResourcesPred = "PodFitsResources"
    // NoDiskConflictPred defines the name of predicate NoDiskConflict.
    NoDiskConflictPred = "NoDiskConflict"
    // PodToleratesNodeTaintsPred defines the name of predicate PodToleratesNodeTaints.
    PodToleratesNodeTaintsPred = "PodToleratesNodeTaints"
    // CheckNodeUnschedulablePred defines the name of predicate CheckNodeUnschedulablePredicate.
    CheckNodeUnschedulablePred = "CheckNodeUnschedulable"
    // PodToleratesNodeNoExecuteTaintsPred defines the name of predicate PodToleratesNodeNoExecuteTaints.
    PodToleratesNodeNoExecuteTaintsPred = "PodToleratesNodeNoExecuteTaints"
    // CheckNodeLabelPresencePred defines the name of predicate CheckNodeLabelPresence.
    CheckNodeLabelPresencePred = "CheckNodeLabelPresence"
    // CheckServiceAffinityPred defines the name of predicate checkServiceAffinity.
    CheckServiceAffinityPred = "CheckServiceAffinity"
    // MaxEBSVolumeCountPred defines the name of predicate MaxEBSVolumeCount.
    MaxEBSVolumeCountPred = "MaxEBSVolumeCount"
    // MaxGCEPDVolumeCountPred defines the name of predicate MaxGCEPDVolumeCount.
    MaxGCEPDVolumeCountPred = "MaxGCEPDVolumeCount"
    // MaxAzureDiskVolumeCountPred defines the name of predicate MaxAzureDiskVolumeCount.
    MaxAzureDiskVolumeCountPred = "MaxAzureDiskVolumeCount"
    // NoVolumeZoneConflictPred defines the name of predicate NoVolumeZoneConflict.
    NoVolumeZoneConflictPred = "NoVolumeZoneConflict"
    // CheckNodeMemoryPressurePred defines the name of predicate CheckNodeMemoryPressure.
    CheckNodeMemoryPressurePred = "CheckNodeMemoryPressure"
    // CheckNodeDiskPressurePred defines the name of predicate CheckNodeDiskPressure.
    CheckNodeDiskPressurePred = "CheckNodeDiskPressure"
    // CheckNodePIDPressurePred defines the name of predicate CheckNodePIDPressure.
    CheckNodePIDPressurePred = "CheckNodePIDPressure"

    // DefaultMaxEBSVolumes is the limit for volumes attached to an instance.
    // Amazon recommends no more than 40; the system root volume uses at least one.
    // See http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/volume_limits.html#linux-specific-volume-limits
    DefaultMaxEBSVolumes = 39
    // DefaultMaxEBSM5VolumeLimit is default EBS volume limit on m5 and c5 instances
    DefaultMaxEBSM5VolumeLimit = 25
    // DefaultMaxGCEPDVolumes defines the maximum number of PD Volumes for GCE
    // GCE instances can have up to 16 PD volumes attached.
    DefaultMaxGCEPDVolumes = 16
    // DefaultMaxAzureDiskVolumes defines the maximum number of PD Volumes for Azure
    // Larger Azure VMs can actually have much more disks attached.
    // TODO We should determine the max based on VM size
    DefaultMaxAzureDiskVolumes = 16

    // KubeMaxPDVols defines the maximum number of PD Volumes per kubelet
    KubeMaxPDVols = "KUBE_MAX_PD_VOLS"

    // EBSVolumeFilterType defines the filter name for EBSVolumeFilter.
    EBSVolumeFilterType = "EBS"
    // GCEPDVolumeFilterType defines the filter name for GCEPDVolumeFilter.
    GCEPDVolumeFilterType = "GCE"
    // AzureDiskVolumeFilterType defines the filter name for AzureDiskVolumeFilter.
    AzureDiskVolumeFilterType = "AzureDisk"
)

Variables

var (

    // ErrDiskConflict is used for NoDiskConflict predicate error.
    ErrDiskConflict = newPredicateFailureError("NoDiskConflict", "node(s) had no available disk")
    // ErrVolumeZoneConflict is used for NoVolumeZoneConflict predicate error.
    ErrVolumeZoneConflict = newPredicateFailureError("NoVolumeZoneConflict", "node(s) had no available volume zone")
    // ErrNodeSelectorNotMatch is used for MatchNodeSelector predicate error.
    ErrNodeSelectorNotMatch = newPredicateFailureError("MatchNodeSelector", "node(s) didn't match node selector")
    // ErrPodAffinityNotMatch is used for MatchInterPodAffinity predicate error.
    ErrPodAffinityNotMatch = newPredicateFailureError("MatchInterPodAffinity", "node(s) didn't match pod affinity/anti-affinity")
    // ErrPodAffinityRulesNotMatch is used for PodAffinityRulesNotMatch predicate error.
    ErrPodAffinityRulesNotMatch = newPredicateFailureError("PodAffinityRulesNotMatch", "node(s) didn't match pod affinity rules")
    // ErrPodAntiAffinityRulesNotMatch is used for PodAntiAffinityRulesNotMatch predicate error.
    ErrPodAntiAffinityRulesNotMatch = newPredicateFailureError("PodAntiAffinityRulesNotMatch", "node(s) didn't match pod anti-affinity rules")
    // ErrExistingPodsAntiAffinityRulesNotMatch is used for ExistingPodsAntiAffinityRulesNotMatch predicate error.
    ErrExistingPodsAntiAffinityRulesNotMatch = newPredicateFailureError("ExistingPodsAntiAffinityRulesNotMatch", "node(s) didn't satisfy existing pods anti-affinity rules")
    // ErrTaintsTolerationsNotMatch is used for PodToleratesNodeTaints predicate error.
    ErrTaintsTolerationsNotMatch = newPredicateFailureError("PodToleratesNodeTaints", "node(s) had taints that the pod didn't tolerate")
    // ErrPodNotMatchHostName is used for HostName predicate error.
    ErrPodNotMatchHostName = newPredicateFailureError("HostName", "node(s) didn't match the requested hostname")
    // ErrPodNotFitsHostPorts is used for PodFitsHostPorts predicate error.
    ErrPodNotFitsHostPorts = newPredicateFailureError("PodFitsHostPorts", "node(s) didn't have free ports for the requested pod ports")
    // ErrNodeLabelPresenceViolated is used for CheckNodeLabelPresence predicate error.
    ErrNodeLabelPresenceViolated = newPredicateFailureError("CheckNodeLabelPresence", "node(s) didn't have the requested labels")
    // ErrServiceAffinityViolated is used for CheckServiceAffinity predicate error.
    ErrServiceAffinityViolated = newPredicateFailureError("CheckServiceAffinity", "node(s) didn't match service affinity")
    // ErrMaxVolumeCountExceeded is used for MaxVolumeCount predicate error.
    ErrMaxVolumeCountExceeded = newPredicateFailureError("MaxVolumeCount", "node(s) exceed max volume count")
    // ErrNodeUnderMemoryPressure is used for NodeUnderMemoryPressure predicate error.
    ErrNodeUnderMemoryPressure = newPredicateFailureError("NodeUnderMemoryPressure", "node(s) had memory pressure")
    // ErrNodeUnderDiskPressure is used for NodeUnderDiskPressure predicate error.
    ErrNodeUnderDiskPressure = newPredicateFailureError("NodeUnderDiskPressure", "node(s) had disk pressure")
    // ErrNodeUnderPIDPressure is used for NodeUnderPIDPressure predicate error.
    ErrNodeUnderPIDPressure = newPredicateFailureError("NodeUnderPIDPressure", "node(s) had pid pressure")
    // ErrNodeOutOfDisk is used for NodeOutOfDisk predicate error.
    ErrNodeOutOfDisk = newPredicateFailureError("NodeOutOfDisk", "node(s) were out of disk space")
    // ErrNodeNotReady is used for NodeNotReady predicate error.
    ErrNodeNotReady = newPredicateFailureError("NodeNotReady", "node(s) were not ready")
    // ErrNodeNetworkUnavailable is used for NodeNetworkUnavailable predicate error.
    ErrNodeNetworkUnavailable = newPredicateFailureError("NodeNetworkUnavailable", "node(s) had unavailable network")
    // ErrNodeUnschedulable is used for NodeUnschedulable predicate error.
    ErrNodeUnschedulable = newPredicateFailureError("NodeUnschedulable", "node(s) were unschedulable")
    // ErrNodeUnknownCondition is used for NodeUnknownCondition predicate error.
    ErrNodeUnknownCondition = newPredicateFailureError("NodeUnknownCondition", "node(s) had unknown conditions")
    // ErrVolumeNodeConflict is used for VolumeNodeAffinityConflict predicate error.
    ErrVolumeNodeConflict = newPredicateFailureError("VolumeNodeAffinityConflict", "node(s) had volume node affinity conflict")
    // ErrVolumeBindConflict is used for VolumeBindingNoMatch predicate error.
    ErrVolumeBindConflict = newPredicateFailureError("VolumeBindingNoMatch", "node(s) didn't find available persistent volumes to bind")
    // ErrFakePredicate is used for test only. The fake predicates returning false also returns error
    // as ErrFakePredicate.
    ErrFakePredicate = newPredicateFailureError("FakePredicateError", "Nodes failed the fake predicate")
)
var AzureDiskVolumeFilter = VolumeFilter{
    FilterVolume: func(vol *v1.Volume) (string, bool) {
        if vol.AzureDisk != nil {
            return vol.AzureDisk.DiskName, true
        }
        return "", false
    },

    FilterPersistentVolume: func(pv *v1.PersistentVolume) (string, bool) {
        if pv.Spec.AzureDisk != nil {
            return pv.Spec.AzureDisk.DiskName, true
        }
        return "", false
    },
}

AzureDiskVolumeFilter is a VolumeFilter for filtering Azure Disk Volumes

var EBSVolumeFilter = VolumeFilter{
    FilterVolume: func(vol *v1.Volume) (string, bool) {
        if vol.AWSElasticBlockStore != nil {
            return vol.AWSElasticBlockStore.VolumeID, true
        }
        return "", false
    },

    FilterPersistentVolume: func(pv *v1.PersistentVolume) (string, bool) {
        if pv.Spec.AWSElasticBlockStore != nil {
            return pv.Spec.AWSElasticBlockStore.VolumeID, true
        }
        return "", false
    },
}

EBSVolumeFilter is a VolumeFilter for filtering AWS ElasticBlockStore Volumes

var GCEPDVolumeFilter = VolumeFilter{
    FilterVolume: func(vol *v1.Volume) (string, bool) {
        if vol.GCEPersistentDisk != nil {
            return vol.GCEPersistentDisk.PDName, true
        }
        return "", false
    },

    FilterPersistentVolume: func(pv *v1.PersistentVolume) (string, bool) {
        if pv.Spec.GCEPersistentDisk != nil {
            return pv.Spec.GCEPersistentDisk.PDName, true
        }
        return "", false
    },
}

GCEPDVolumeFilter is a VolumeFilter for filtering GCE PersistentDisk Volumes

func AddUnsetLabelsToMap Uses

func AddUnsetLabelsToMap(aL map[string]string, labelsToAdd []string, labelSet labels.Set)

AddUnsetLabelsToMap backfills missing values with values we find in a map.

func CheckNodeConditionPredicate Uses

func CheckNodeConditionPredicate(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodeConditionPredicate checks if a pod can be scheduled on a node reporting out of disk, network unavailable and not ready condition. Only node conditions are accounted in this predicate.

func CheckNodeDiskPressurePredicate Uses

func CheckNodeDiskPressurePredicate(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodeDiskPressurePredicate checks if a pod can be scheduled on a node reporting disk pressure condition.

func CheckNodeMemoryPressurePredicate Uses

func CheckNodeMemoryPressurePredicate(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodeMemoryPressurePredicate checks if a pod can be scheduled on a node reporting memory pressure condition.

func CheckNodePIDPressurePredicate Uses

func CheckNodePIDPressurePredicate(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodePIDPressurePredicate checks if a pod can be scheduled on a node reporting pid pressure condition.

func CheckNodeUnschedulablePredicate Uses

func CheckNodeUnschedulablePredicate(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodeUnschedulablePredicate checks if a pod can be scheduled on a node with Unschedulable spec.

func CreateSelectorFromLabels Uses

func CreateSelectorFromLabels(aL map[string]string) labels.Selector

CreateSelectorFromLabels is used to define a selector that corresponds to the keys in a map.

func EssentialPredicates Uses

func EssentialPredicates(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

EssentialPredicates are the predicates that all pods, including critical pods, need

func FilterPodsByNamespace Uses

func FilterPodsByNamespace(pods []*v1.Pod, ns string) []*v1.Pod

FilterPodsByNamespace filters pods outside a namespace from the given list.

func FindLabelsInSet Uses

func FindLabelsInSet(labelsToKeep []string, selector labels.Set) map[string]string

FindLabelsInSet gets as many key/value pairs as possible out of a label set.

ExampleUtils is a https://blog.golang.org/examples styled unit test.

Code:

labelSubset := labels.Set{}
labelSubset["label1"] = "value1"
labelSubset["label2"] = "value2"
// Lets make believe that these pods are on the cluster.
// Utility functions will inspect their labels, filter them, and so on.
nsPods := []*v1.Pod{
    {
        ObjectMeta: metav1.ObjectMeta{
            Name:      "pod1",
            Namespace: "ns1",
            Labels: map[string]string{
                "label1": "wontSeeThis",
                "label2": "wontSeeThis",
                "label3": "will_see_this",
            },
        },
    },  // first pod which will be used via the utilities
    {
        ObjectMeta: metav1.ObjectMeta{
            Name:      "pod2",
            Namespace: "ns1",
        },
    },

    {
        ObjectMeta: metav1.ObjectMeta{
            Name: "pod3ThatWeWontSee",
        },
    },
}
fmt.Println(FindLabelsInSet([]string{"label1", "label2", "label3"}, nsPods[0].ObjectMeta.Labels)["label3"])
AddUnsetLabelsToMap(labelSubset, []string{"label1", "label2", "label3"}, nsPods[0].ObjectMeta.Labels)
fmt.Println(labelSubset)

for _, pod := range FilterPodsByNamespace(nsPods, "ns1") {
    fmt.Print(pod.Name, ",")
}

Output:

will_see_this
label1=value1,label2=value2,label3=will_see_this
pod1,pod2,

func GeneralPredicates Uses

func GeneralPredicates(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

GeneralPredicates checks whether noncriticalPredicates and EssentialPredicates pass. noncriticalPredicates are the predicates that only non-critical pods need and EssentialPredicates are the predicates that all pods, including critical pods, need

func GetPodAffinityTerms Uses

func GetPodAffinityTerms(podAffinity *v1.PodAffinity) (terms []v1.PodAffinityTerm)

GetPodAffinityTerms gets pod affinity terms by a pod affinity object.

func GetPodAntiAffinityTerms Uses

func GetPodAntiAffinityTerms(podAntiAffinity *v1.PodAntiAffinity) (terms []v1.PodAffinityTerm)

GetPodAntiAffinityTerms gets pod affinity terms by a pod anti-affinity.

func GetResourceRequest Uses

func GetResourceRequest(pod *v1.Pod) *schedulercache.Resource

GetResourceRequest returns a *schedulercache.Resource that covers the largest width in each resource dimension. Because init-containers run sequentially, we collect the max in each dimension iteratively. In contrast, we sum the resource vectors for regular containers since they run simultaneously.

Example:

Pod:

InitContainers
  IC1:
    CPU: 2
    Memory: 1G
  IC2:
    CPU: 2
    Memory: 3G
Containers
  C1:
    CPU: 2
    Memory: 1G
  C2:
    CPU: 1
    Memory: 1G

Result: CPU: 3, Memory: 3G

func NewMaxPDVolumeCountPredicate Uses

func NewMaxPDVolumeCountPredicate(
    filterName string, pvInfo PersistentVolumeInfo, pvcInfo PersistentVolumeClaimInfo) algorithm.FitPredicate

NewMaxPDVolumeCountPredicate creates a predicate which evaluates whether a pod can fit based on the number of volumes which match a filter that it requests, and those that are already present.

The predicate looks for both volumes used directly, as well as PVC volumes that are backed by relevant volume types, counts the number of unique volumes, and rejects the new pod if it would place the total count over the maximum.

func NewNodeLabelPredicate Uses

func NewNodeLabelPredicate(labels []string, presence bool) algorithm.FitPredicate

NewNodeLabelPredicate creates a predicate which evaluates whether a pod can fit based on the node labels which match a filter that it requests.

func NewPodAffinityPredicate Uses

func NewPodAffinityPredicate(info NodeInfo, podLister algorithm.PodLister) algorithm.FitPredicate

NewPodAffinityPredicate creates a PodAffinityChecker.

func NewPredicateMetadataFactory Uses

func NewPredicateMetadataFactory(podLister algorithm.PodLister) algorithm.PredicateMetadataProducer

NewPredicateMetadataFactory creates a PredicateMetadataFactory.

func NewServiceAffinityPredicate Uses

func NewServiceAffinityPredicate(podLister algorithm.PodLister, serviceLister algorithm.ServiceLister, nodeInfo NodeInfo, labels []string) (algorithm.FitPredicate, PredicateMetadataProducer)

NewServiceAffinityPredicate creates a ServiceAffinity.

func NewVolumeBindingPredicate Uses

func NewVolumeBindingPredicate(binder *volumebinder.VolumeBinder) algorithm.FitPredicate

NewVolumeBindingPredicate evaluates if a pod can fit due to the volumes it requests, for both bound and unbound PVCs.

For PVCs that are bound, then it checks that the corresponding PV's node affinity is satisfied by the given node.

For PVCs that are unbound, it tries to find available PVs that can satisfy the PVC requirements and that the PV node affinity is satisfied by the given node.

The predicate returns true if all bound PVCs have compatible PVs with the node, and if all unbound PVCs can be matched with an available and node-compatible PV.

func NewVolumeZonePredicate Uses

func NewVolumeZonePredicate(pvInfo PersistentVolumeInfo, pvcInfo PersistentVolumeClaimInfo, classInfo StorageClassInfo) algorithm.FitPredicate

NewVolumeZonePredicate evaluates if a pod can fit due to the volumes it requests, given that some volumes may have zone scheduling constraints. The requirement is that any volume zone-labels must match the equivalent zone-labels on the node. It is OK for the node to have more zone-label constraints (for example, a hypothetical replicated volume might allow region-wide access)

Currently this is only supported with PersistentVolumeClaims, and looks to the labels only on the bound PersistentVolume.

Working with volumes declared inline in the pod specification (i.e. not using a PersistentVolume) is likely to be harder, as it would require determining the zone of a volume during scheduling, and that is likely to require calling out to the cloud provider. It seems that we are moving away from inline volume declarations anyway.

func NoDiskConflict Uses

func NoDiskConflict(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

NoDiskConflict evaluates if a pod can fit due to the volumes it requests, and those that are already mounted. If there is already a volume mounted on that node, another pod that uses the same volume can't be scheduled there. This is GCE, Amazon EBS, and Ceph RBD specific for now: - GCE PD allows multiple mounts as long as they're all read-only - AWS EBS forbids any two pods mounting the same volume ID - Ceph RBD forbids if any two pods share at least same monitor, and match pool and image. - ISCSI forbids if any two pods share at least same IQN, LUN and Target TODO: migrate this into some per-volume specific code?

func Ordering Uses

func Ordering() []string

Ordering returns the ordering of predicates.

func PodFitsHost Uses

func PodFitsHost(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodFitsHost checks if a pod spec node name matches the current node.

func PodFitsHostPorts Uses

func PodFitsHostPorts(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodFitsHostPorts checks if a node has free ports for the requested pod ports.

func PodFitsResources Uses

func PodFitsResources(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodFitsResources checks if a node has sufficient resources, such as cpu, memory, gpu, opaque int resources etc to run a pod. First return value indicates whether a node has sufficient resources to run a pod while the second return value indicates the predicate failure reasons if the node has insufficient resources to run the pod.

func PodMatchNodeSelector Uses

func PodMatchNodeSelector(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodMatchNodeSelector checks if a pod node selector matches the node label.

func PodToleratesNodeNoExecuteTaints Uses

func PodToleratesNodeNoExecuteTaints(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodToleratesNodeNoExecuteTaints checks if a pod tolerations can tolerate the node's NoExecute taints

func PodToleratesNodeTaints Uses

func PodToleratesNodeTaints(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

PodToleratesNodeTaints checks if a pod tolerations can tolerate the node taints

func RegisterPredicateMetadataProducer Uses

func RegisterPredicateMetadataProducer(predicateName string, precomp PredicateMetadataProducer)

RegisterPredicateMetadataProducer registers a PredicateMetadataProducer.

func RegisterPredicateMetadataProducerWithExtendedResourceOptions Uses

func RegisterPredicateMetadataProducerWithExtendedResourceOptions(ignoredExtendedResources sets.String)

RegisterPredicateMetadataProducerWithExtendedResourceOptions registers a PredicateMetadataProducer that creates predicate metadata with the provided options for extended resources.

See the comments in "predicateMetadata" for the explanation of the options.

func SetPredicatesOrdering Uses

func SetPredicatesOrdering(names []string)

SetPredicatesOrdering sets the ordering of predicates.

type CachedNodeInfo Uses

type CachedNodeInfo struct {
    corelisters.NodeLister
}

CachedNodeInfo implements NodeInfo

func (*CachedNodeInfo) GetNodeInfo Uses

func (c *CachedNodeInfo) GetNodeInfo(id string) (*v1.Node, error)

GetNodeInfo returns cached data for the node 'id'.

type CachedPersistentVolumeClaimInfo Uses

type CachedPersistentVolumeClaimInfo struct {
    corelisters.PersistentVolumeClaimLister
}

CachedPersistentVolumeClaimInfo implements PersistentVolumeClaimInfo

func (*CachedPersistentVolumeClaimInfo) GetPersistentVolumeClaimInfo Uses

func (c *CachedPersistentVolumeClaimInfo) GetPersistentVolumeClaimInfo(namespace string, name string) (*v1.PersistentVolumeClaim, error)

GetPersistentVolumeClaimInfo fetches the claim in specified namespace with specified name

type CachedPersistentVolumeInfo Uses

type CachedPersistentVolumeInfo struct {
    corelisters.PersistentVolumeLister
}

CachedPersistentVolumeInfo implements PersistentVolumeInfo

func (*CachedPersistentVolumeInfo) GetPersistentVolumeInfo Uses

func (c *CachedPersistentVolumeInfo) GetPersistentVolumeInfo(pvID string) (*v1.PersistentVolume, error)

GetPersistentVolumeInfo returns a persistent volume object by PV ID.

type CachedStorageClassInfo Uses

type CachedStorageClassInfo struct {
    storagelisters.StorageClassLister
}

CachedStorageClassInfo implements StorageClassInfo

func (*CachedStorageClassInfo) GetStorageClassInfo Uses

func (c *CachedStorageClassInfo) GetStorageClassInfo(className string) (*storagev1.StorageClass, error)

GetStorageClassInfo get StorageClass by class name.

type FailureReason Uses

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

FailureReason describes a failure reason.

func NewFailureReason Uses

func NewFailureReason(msg string) *FailureReason

NewFailureReason creates a FailureReason with message.

func (*FailureReason) GetReason Uses

func (e *FailureReason) GetReason() string

GetReason returns the reason of the FailureReason.

type FakeNodeInfo Uses

type FakeNodeInfo v1.Node

FakeNodeInfo declares a v1.Node type for testing.

func (FakeNodeInfo) GetNodeInfo Uses

func (n FakeNodeInfo) GetNodeInfo(nodeName string) (*v1.Node, error)

GetNodeInfo return a fake node info object.

type FakeNodeListInfo Uses

type FakeNodeListInfo []v1.Node

FakeNodeListInfo declares a []v1.Node type for testing.

func (FakeNodeListInfo) GetNodeInfo Uses

func (nodes FakeNodeListInfo) GetNodeInfo(nodeName string) (*v1.Node, error)

GetNodeInfo returns a fake node object in the fake nodes.

type FakePersistentVolumeClaimInfo Uses

type FakePersistentVolumeClaimInfo []v1.PersistentVolumeClaim

FakePersistentVolumeClaimInfo declares a []v1.PersistentVolumeClaim type for testing.

func (FakePersistentVolumeClaimInfo) GetPersistentVolumeClaimInfo Uses

func (pvcs FakePersistentVolumeClaimInfo) GetPersistentVolumeClaimInfo(namespace string, pvcID string) (*v1.PersistentVolumeClaim, error)

GetPersistentVolumeClaimInfo gets PVC matching the namespace and PVC ID.

type FakePersistentVolumeInfo Uses

type FakePersistentVolumeInfo []v1.PersistentVolume

FakePersistentVolumeInfo declares a []v1.PersistentVolume type for testing.

func (FakePersistentVolumeInfo) GetPersistentVolumeInfo Uses

func (pvs FakePersistentVolumeInfo) GetPersistentVolumeInfo(pvID string) (*v1.PersistentVolume, error)

GetPersistentVolumeInfo returns a fake PV object in the fake PVs by PV ID.

type FakeStorageClassInfo Uses

type FakeStorageClassInfo []storagev1.StorageClass

FakeStorageClassInfo declares a []storagev1.StorageClass type for testing.

func (FakeStorageClassInfo) GetStorageClassInfo Uses

func (classes FakeStorageClassInfo) GetStorageClassInfo(name string) (*storagev1.StorageClass, error)

GetStorageClassInfo returns a fake storage class object in the fake storage classes by name.

type InsufficientResourceError Uses

type InsufficientResourceError struct {
    // resourceName is the name of the resource that is insufficient
    ResourceName v1.ResourceName
    // contains filtered or unexported fields
}

InsufficientResourceError is an error type that indicates what kind of resource limit is hit and caused the unfitting failure.

func NewInsufficientResourceError Uses

func NewInsufficientResourceError(resourceName v1.ResourceName, requested, used, capacity int64) *InsufficientResourceError

NewInsufficientResourceError returns an InsufficientResourceError.

func (*InsufficientResourceError) Error Uses

func (e *InsufficientResourceError) Error() string

func (*InsufficientResourceError) GetInsufficientAmount Uses

func (e *InsufficientResourceError) GetInsufficientAmount() int64

GetInsufficientAmount returns the amount of the insufficient resource of the error.

func (*InsufficientResourceError) GetReason Uses

func (e *InsufficientResourceError) GetReason() string

GetReason returns the reason of the InsufficientResourceError.

type MaxPDVolumeCountChecker Uses

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

MaxPDVolumeCountChecker contains information to check the max number of volumes for a predicate.

type NodeInfo Uses

type NodeInfo interface {
    GetNodeInfo(nodeID string) (*v1.Node, error)
}

NodeInfo interface represents anything that can get node object from node ID.

type NodeLabelChecker Uses

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

NodeLabelChecker contains information to check node labels for a predicate.

func (*NodeLabelChecker) CheckNodeLabelPresence Uses

func (n *NodeLabelChecker) CheckNodeLabelPresence(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

CheckNodeLabelPresence checks whether all of the specified labels exists on a node or not, regardless of their value If "presence" is false, then returns false if any of the requested labels matches any of the node's labels, otherwise returns true. If "presence" is true, then returns false if any of the requested labels does not match any of the node's labels, otherwise returns true.

Consider the cases where the nodes are placed in regions/zones/racks and these are identified by labels In some cases, it is required that only nodes that are part of ANY of the defined regions/zones/racks be selected

Alternately, eliminating nodes that have a certain label, regardless of value, is also useful A node may have a label with "retiring" as key and the date as the value and it may be desirable to avoid scheduling new pods on this node

type PersistentVolumeClaimInfo Uses

type PersistentVolumeClaimInfo interface {
    GetPersistentVolumeClaimInfo(namespace string, name string) (*v1.PersistentVolumeClaim, error)
}

PersistentVolumeClaimInfo interface represents anything that can get a PVC object in specified namespace with specified name.

type PersistentVolumeInfo Uses

type PersistentVolumeInfo interface {
    GetPersistentVolumeInfo(pvID string) (*v1.PersistentVolume, error)
}

PersistentVolumeInfo interface represents anything that can get persistent volume object by PV ID.

type PodAffinityChecker Uses

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

PodAffinityChecker contains information to check pod affinity.

func (*PodAffinityChecker) InterPodAffinityMatches Uses

func (c *PodAffinityChecker) InterPodAffinityMatches(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error)

InterPodAffinityMatches checks if a pod can be scheduled on the specified node with pod affinity/anti-affinity configuration. First return value indicates whether a pod can be scheduled on the specified node while the second return value indicates the predicate failure reasons if the pod cannot be scheduled on the specified node.

type PredicateFailureError Uses

type PredicateFailureError struct {
    PredicateName string
    PredicateDesc string
}

PredicateFailureError describes a failure error of predicate.

func (*PredicateFailureError) Error Uses

func (e *PredicateFailureError) Error() string

func (*PredicateFailureError) GetReason Uses

func (e *PredicateFailureError) GetReason() string

GetReason returns the reason of the PredicateFailureError.

type PredicateMetadataFactory Uses

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

PredicateMetadataFactory defines a factory of predicate metadata.

func (*PredicateMetadataFactory) GetMetadata Uses

func (pfactory *PredicateMetadataFactory) GetMetadata(pod *v1.Pod, nodeNameToInfoMap map[string]*schedulercache.NodeInfo) algorithm.PredicateMetadata

GetMetadata returns the predicateMetadata used which will be used by various predicates.

type PredicateMetadataProducer Uses

type PredicateMetadataProducer func(pm *predicateMetadata)

PredicateMetadataProducer function produces predicate metadata.

type ServiceAffinity Uses

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

ServiceAffinity defines a struct used for create service affinity predicates.

type StorageClassInfo Uses

type StorageClassInfo interface {
    GetStorageClassInfo(className string) (*storagev1.StorageClass, error)
}

StorageClassInfo interface represents anything that can get a storage class object by class name.

type VolumeBindingChecker Uses

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

VolumeBindingChecker contains information to check a volume binding.

type VolumeFilter Uses

type VolumeFilter struct {
    // Filter normal volumes
    FilterVolume           func(vol *v1.Volume) (id string, relevant bool)
    FilterPersistentVolume func(pv *v1.PersistentVolume) (id string, relevant bool)
}

VolumeFilter contains information on how to filter PD Volumes when checking PD Volume caps

type VolumeZoneChecker Uses

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

VolumeZoneChecker contains information to check the volume zone for a predicate.

Package predicates imports 29 packages (graph) and is imported by 131 packages. Updated 2018-07-23. Refresh now. Tools for package owners.