Replace godep with dep

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/BUILD

@@ -0,0 +1,81 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["scheduler_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/core:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/testing:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "scheduler.go",
+        "testutil.go",
+    ],
+    deps = [
+        "//pkg/features:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/core:go_default_library",
+        "//plugin/pkg/scheduler/metrics:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//plugin/pkg/scheduler/algorithm:all-srcs",
+        "//plugin/pkg/scheduler/algorithmprovider:all-srcs",
+        "//plugin/pkg/scheduler/api:all-srcs",
+        "//plugin/pkg/scheduler/core:all-srcs",
+        "//plugin/pkg/scheduler/factory:all-srcs",
+        "//plugin/pkg/scheduler/metrics:all-srcs",
+        "//plugin/pkg/scheduler/schedulercache:all-srcs",
+        "//plugin/pkg/scheduler/testing:all-srcs",
+        "//plugin/pkg/scheduler/util:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/OWNERS

@@ -0,0 +1,4 @@
+approvers:
+- sig-scheduling-maintainers
+reviewers:
+- sig-scheduling

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/BUILD

@@ -0,0 +1,56 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "scheduler_interface.go",
+        "types.go",
+        "well_known_labels.go",
+    ],
+    deps = [
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "scheduler_interface_test.go",
+        "types_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//plugin/pkg/scheduler/algorithm/predicates:all-srcs",
+        "//plugin/pkg/scheduler/algorithm/priorities:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package scheduler contains a generic Scheduler interface and several
+// implementations.
+package algorithm // import "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/BUILD

@@ -0,0 +1,72 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "error.go",
+        "metadata.go",
+        "predicates.go",
+        "utils.go",
+    ],
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//pkg/api/v1/helper/qos:go_default_library",
+        "//pkg/features:go_default_library",
+        "//pkg/kubelet/apis:go_default_library",
+        "//pkg/volume/util:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/clientset_generated/clientset:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "metadata_test.go",
+        "predicates_test.go",
+        "utils_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//pkg/kubelet/apis:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/testing:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/error.go

@@ -0,0 +1,114 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package predicates
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+)
+
+var (
+	// The predicateName tries to be consistent as the predicate name used in DefaultAlgorithmProvider defined in
+	// defaults.go (which tend to be stable for backward compatibility)
+
+	// NOTE: If you add a new predicate failure error for a predicate that can never
+	// be made to pass by removing pods, or you change an existing predicate so that
+	// it can never be made to pass by removing pods, you need to add the predicate
+	// failure error in nodesWherePreemptionMightHelp() in scheduler/core/generic_scheduler.go
+	ErrDiskConflict              = newPredicateFailureError("NoDiskConflict")
+	ErrVolumeZoneConflict        = newPredicateFailureError("NoVolumeZoneConflict")
+	ErrNodeSelectorNotMatch      = newPredicateFailureError("MatchNodeSelector")
+	ErrPodAffinityNotMatch       = newPredicateFailureError("MatchInterPodAffinity")
+	ErrTaintsTolerationsNotMatch = newPredicateFailureError("PodToleratesNodeTaints")
+	ErrPodNotMatchHostName       = newPredicateFailureError("HostName")
+	ErrPodNotFitsHostPorts       = newPredicateFailureError("PodFitsHostPorts")
+	ErrNodeLabelPresenceViolated = newPredicateFailureError("CheckNodeLabelPresence")
+	ErrServiceAffinityViolated   = newPredicateFailureError("CheckServiceAffinity")
+	ErrMaxVolumeCountExceeded    = newPredicateFailureError("MaxVolumeCount")
+	ErrNodeUnderMemoryPressure   = newPredicateFailureError("NodeUnderMemoryPressure")
+	ErrNodeUnderDiskPressure     = newPredicateFailureError("NodeUnderDiskPressure")
+	ErrNodeOutOfDisk             = newPredicateFailureError("NodeOutOfDisk")
+	ErrNodeNotReady              = newPredicateFailureError("NodeNotReady")
+	ErrNodeNetworkUnavailable    = newPredicateFailureError("NodeNetworkUnavailable")
+	ErrNodeUnschedulable         = newPredicateFailureError("NodeUnschedulable")
+	ErrNodeUnknownCondition      = newPredicateFailureError("NodeUnknownCondition")
+	ErrVolumeNodeConflict        = newPredicateFailureError("NoVolumeNodeConflict")
+	// ErrFakePredicate is used for test only. The fake predicates returning false also returns error
+	// as ErrFakePredicate.
+	ErrFakePredicate = newPredicateFailureError("FakePredicateError")
+)
+
+// InsufficientResourceError is an error type that indicates what kind of resource limit is
+// hit and caused the unfitting failure.
+type InsufficientResourceError struct {
+	// resourceName is the name of the resource that is insufficient
+	ResourceName v1.ResourceName
+	requested    int64
+	used         int64
+	capacity     int64
+}
+
+func NewInsufficientResourceError(resourceName v1.ResourceName, requested, used, capacity int64) *InsufficientResourceError {
+	return &InsufficientResourceError{
+		ResourceName: resourceName,
+		requested:    requested,
+		used:         used,
+		capacity:     capacity,
+	}
+}
+
+func (e *InsufficientResourceError) Error() string {
+	return fmt.Sprintf("Node didn't have enough resource: %s, requested: %d, used: %d, capacity: %d",
+		e.ResourceName, e.requested, e.used, e.capacity)
+}
+
+func (e *InsufficientResourceError) GetReason() string {
+	return fmt.Sprintf("Insufficient %v", e.ResourceName)
+}
+
+func (e *InsufficientResourceError) GetInsufficientAmount() int64 {
+	return e.requested - (e.capacity - e.used)
+}
+
+type PredicateFailureError struct {
+	PredicateName string
+}
+
+func newPredicateFailureError(predicateName string) *PredicateFailureError {
+	return &PredicateFailureError{PredicateName: predicateName}
+}
+
+func (e *PredicateFailureError) Error() string {
+	return fmt.Sprintf("Predicate %s failed", e.PredicateName)
+}
+
+func (e *PredicateFailureError) GetReason() string {
+	return e.PredicateName
+}
+
+type FailureReason struct {
+	reason string
+}
+
+func NewFailureReason(msg string) *FailureReason {
+	return &FailureReason{reason: msg}
+}
+
+func (e *FailureReason) GetReason() string {
+	return e.reason
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/metadata.go

@@ -0,0 +1,188 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package predicates
+
+import (
+	"fmt"
+	"sync"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedutil "k8s.io/kubernetes/plugin/pkg/scheduler/util"
+
+	"github.com/golang/glog"
+)
+
+type PredicateMetadataFactory struct {
+	podLister algorithm.PodLister
+}
+
+//  Note that predicateMetadata and matchingPodAntiAffinityTerm need to be declared in the same file
+//  due to the way declarations are processed in predicate declaration unit tests.
+type matchingPodAntiAffinityTerm struct {
+	term *v1.PodAffinityTerm
+	node *v1.Node
+}
+
+// NOTE: When new fields are added/removed or logic is changed, please make sure that
+// RemovePod, AddPod, and ShallowCopy functions are updated to work with the new changes.
+type predicateMetadata struct {
+	pod           *v1.Pod
+	podBestEffort bool
+	podRequest    *schedulercache.Resource
+	podPorts      map[int]bool
+	//key is a pod full name with the anti-affinity rules.
+	matchingAntiAffinityTerms          map[string][]matchingPodAntiAffinityTerm
+	serviceAffinityInUse               bool
+	serviceAffinityMatchingPodList     []*v1.Pod
+	serviceAffinityMatchingPodServices []*v1.Service
+}
+
+// Ensure that predicateMetadata implements algorithm.PredicateMetadata.
+var _ algorithm.PredicateMetadata = &predicateMetadata{}
+
+// PredicateMetadataProducer: Helper types/variables...
+type PredicateMetadataProducer func(pm *predicateMetadata)
+
+var predicateMetaProducerRegisterLock sync.Mutex
+var predicateMetadataProducers map[string]PredicateMetadataProducer = make(map[string]PredicateMetadataProducer)
+
+func RegisterPredicateMetadataProducer(predicateName string, precomp PredicateMetadataProducer) {
+	predicateMetaProducerRegisterLock.Lock()
+	defer predicateMetaProducerRegisterLock.Unlock()
+	predicateMetadataProducers[predicateName] = precomp
+}
+
+func NewPredicateMetadataFactory(podLister algorithm.PodLister) algorithm.PredicateMetadataProducer {
+	factory := &PredicateMetadataFactory{
+		podLister,
+	}
+	return factory.GetMetadata
+}
+
+// GetMetadata returns the predicateMetadata used which will be used by various predicates.
+func (pfactory *PredicateMetadataFactory) GetMetadata(pod *v1.Pod, nodeNameToInfoMap map[string]*schedulercache.NodeInfo) algorithm.PredicateMetadata {
+	// If we cannot compute metadata, just return nil
+	if pod == nil {
+		return nil
+	}
+	matchingTerms, err := getMatchingAntiAffinityTerms(pod, nodeNameToInfoMap)
+	if err != nil {
+		return nil
+	}
+	predicateMetadata := &predicateMetadata{
+		pod:                       pod,
+		podBestEffort:             isPodBestEffort(pod),
+		podRequest:                GetResourceRequest(pod),
+		podPorts:                  schedutil.GetUsedPorts(pod),
+		matchingAntiAffinityTerms: matchingTerms,
+	}
+	for predicateName, precomputeFunc := range predicateMetadataProducers {
+		glog.V(10).Infof("Precompute: %v", predicateName)
+		precomputeFunc(predicateMetadata)
+	}
+	return predicateMetadata
+}
+
+// RemovePod changes predicateMetadata assuming that the given `deletedPod` is
+// deleted from the system.
+func (meta *predicateMetadata) RemovePod(deletedPod *v1.Pod) error {
+	deletedPodFullName := schedutil.GetPodFullName(deletedPod)
+	if deletedPodFullName == schedutil.GetPodFullName(meta.pod) {
+		return fmt.Errorf("deletedPod and meta.pod must not be the same.")
+	}
+	// Delete any anti-affinity rule from the deletedPod.
+	delete(meta.matchingAntiAffinityTerms, deletedPodFullName)
+	// All pods in the serviceAffinityMatchingPodList are in the same namespace.
+	// So, if the namespace of the first one is not the same as the namespace of the
+	// deletedPod, we don't need to check the list, as deletedPod isn't in the list.
+	if meta.serviceAffinityInUse &&
+		len(meta.serviceAffinityMatchingPodList) > 0 &&
+		deletedPod.Namespace == meta.serviceAffinityMatchingPodList[0].Namespace {
+		for i, pod := range meta.serviceAffinityMatchingPodList {
+			if schedutil.GetPodFullName(pod) == deletedPodFullName {
+				meta.serviceAffinityMatchingPodList = append(
+					meta.serviceAffinityMatchingPodList[:i],
+					meta.serviceAffinityMatchingPodList[i+1:]...)
+				break
+			}
+		}
+	}
+	return nil
+}
+
+// AddPod changes predicateMetadata assuming that `newPod` is added to the
+// system.
+func (meta *predicateMetadata) AddPod(addedPod *v1.Pod, nodeInfo *schedulercache.NodeInfo) error {
+	addedPodFullName := schedutil.GetPodFullName(addedPod)
+	if addedPodFullName == schedutil.GetPodFullName(meta.pod) {
+		return fmt.Errorf("addedPod and meta.pod must not be the same.")
+	}
+	if nodeInfo.Node() == nil {
+		return fmt.Errorf("Invalid node in nodeInfo.")
+	}
+	// Add matching anti-affinity terms of the addedPod to the map.
+	podMatchingTerms, err := getMatchingAntiAffinityTermsOfExistingPod(meta.pod, addedPod, nodeInfo.Node())
+	if err != nil {
+		return err
+	}
+	if len(podMatchingTerms) > 0 {
+		existingTerms, found := meta.matchingAntiAffinityTerms[addedPodFullName]
+		if found {
+			meta.matchingAntiAffinityTerms[addedPodFullName] = append(existingTerms,
+				podMatchingTerms...)
+		} else {
+			meta.matchingAntiAffinityTerms[addedPodFullName] = podMatchingTerms
+		}
+	}
+	// If addedPod is in the same namespace as the meta.pod, update the list
+	// of matching pods if applicable.
+	if meta.serviceAffinityInUse && addedPod.Namespace == meta.pod.Namespace {
+		selector := CreateSelectorFromLabels(meta.pod.Labels)
+		if selector.Matches(labels.Set(addedPod.Labels)) {
+			meta.serviceAffinityMatchingPodList = append(meta.serviceAffinityMatchingPodList,
+				addedPod)
+		}
+	}
+	return nil
+}
+
+// ShallowCopy copies a metadata struct into a new struct and creates a copy of
+// its maps and slices, but it does not copy the contents of pointer values.
+func (meta *predicateMetadata) ShallowCopy() algorithm.PredicateMetadata {
+	newPredMeta := &predicateMetadata{
+		pod:                  meta.pod,
+		podBestEffort:        meta.podBestEffort,
+		podRequest:           meta.podRequest,
+		serviceAffinityInUse: meta.serviceAffinityInUse,
+	}
+	newPredMeta.podPorts = map[int]bool{}
+	for k, v := range meta.podPorts {
+		newPredMeta.podPorts[k] = v
+	}
+	newPredMeta.matchingAntiAffinityTerms = map[string][]matchingPodAntiAffinityTerm{}
+	for k, v := range meta.matchingAntiAffinityTerms {
+		newPredMeta.matchingAntiAffinityTerms[k] = append([]matchingPodAntiAffinityTerm(nil), v...)
+	}
+	newPredMeta.serviceAffinityMatchingPodServices = append([]*v1.Service(nil),
+		meta.serviceAffinityMatchingPodServices...)
+	newPredMeta.serviceAffinityMatchingPodList = append([]*v1.Pod(nil),
+		meta.serviceAffinityMatchingPodList...)
+	return (algorithm.PredicateMetadata)(newPredMeta)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/metadata_test.go

@@ -0,0 +1,400 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package predicates
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedulertesting "k8s.io/kubernetes/plugin/pkg/scheduler/testing"
+)
+
+// sortableAntiAffinityTerms lets us to sort anti-affinity terms.
+type sortableAntiAffinityTerms []matchingPodAntiAffinityTerm
+
+// Less establishes some ordering between two matchingPodAntiAffinityTerms for
+// sorting.
+func (s sortableAntiAffinityTerms) Less(i, j int) bool {
+	t1, t2 := s[i], s[j]
+	if t1.node.Name != t2.node.Name {
+		return t1.node.Name < t2.node.Name
+	}
+	if len(t1.term.Namespaces) != len(t2.term.Namespaces) {
+		return len(t1.term.Namespaces) < len(t2.term.Namespaces)
+	}
+	if t1.term.TopologyKey != t2.term.TopologyKey {
+		return t1.term.TopologyKey < t2.term.TopologyKey
+	}
+	if len(t1.term.LabelSelector.MatchLabels) != len(t2.term.LabelSelector.MatchLabels) {
+		return len(t1.term.LabelSelector.MatchLabels) < len(t2.term.LabelSelector.MatchLabels)
+	}
+	return false
+}
+func (s sortableAntiAffinityTerms) Len() int { return len(s) }
+func (s sortableAntiAffinityTerms) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+var _ = sort.Interface(sortableAntiAffinityTerms{})
+
+func sortAntiAffinityTerms(terms map[string][]matchingPodAntiAffinityTerm) {
+	for k, v := range terms {
+		sortableTerms := sortableAntiAffinityTerms(v)
+		sort.Sort(sortableTerms)
+		terms[k] = sortableTerms
+	}
+}
+
+// sortablePods lets us to sort pods.
+type sortablePods []*v1.Pod
+
+func (s sortablePods) Less(i, j int) bool {
+	return s[i].Namespace < s[j].Namespace ||
+		(s[i].Namespace == s[j].Namespace && s[i].Name < s[j].Name)
+}
+func (s sortablePods) Len() int      { return len(s) }
+func (s sortablePods) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+var _ = sort.Interface(&sortablePods{})
+
+// sortableServices allows us to sort services.
+type sortableServices []*v1.Service
+
+func (s sortableServices) Less(i, j int) bool {
+	return s[i].Namespace < s[j].Namespace ||
+		(s[i].Namespace == s[j].Namespace && s[i].Name < s[j].Name)
+}
+func (s sortableServices) Len() int      { return len(s) }
+func (s sortableServices) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+var _ = sort.Interface(&sortableServices{})
+
+// predicateMetadataEquivalent returns true if the two metadata are equivalent.
+// Note: this function does not compare podRequest.
+func predicateMetadataEquivalent(meta1, meta2 *predicateMetadata) error {
+	if !reflect.DeepEqual(meta1.pod, meta2.pod) {
+		return fmt.Errorf("pods are not the same.")
+	}
+	if meta1.podBestEffort != meta2.podBestEffort {
+		return fmt.Errorf("podBestEfforts are not equal.")
+	}
+	if meta1.serviceAffinityInUse != meta1.serviceAffinityInUse {
+		return fmt.Errorf("serviceAffinityInUses are not equal.")
+	}
+	if len(meta1.podPorts) != len(meta2.podPorts) {
+		return fmt.Errorf("podPorts are not equal.")
+	}
+	for !reflect.DeepEqual(meta1.podPorts, meta2.podPorts) {
+		return fmt.Errorf("podPorts are not equal.")
+	}
+	sortAntiAffinityTerms(meta1.matchingAntiAffinityTerms)
+	sortAntiAffinityTerms(meta2.matchingAntiAffinityTerms)
+	if !reflect.DeepEqual(meta1.matchingAntiAffinityTerms, meta2.matchingAntiAffinityTerms) {
+		return fmt.Errorf("matchingAntiAffinityTerms are not euqal.")
+	}
+	if meta1.serviceAffinityInUse {
+		sortablePods1 := sortablePods(meta1.serviceAffinityMatchingPodList)
+		sort.Sort(sortablePods1)
+		sortablePods2 := sortablePods(meta2.serviceAffinityMatchingPodList)
+		sort.Sort(sortablePods2)
+		if !reflect.DeepEqual(sortablePods1, sortablePods2) {
+			return fmt.Errorf("serviceAffinityMatchingPodLists are not euqal.")
+		}
+
+		sortableServices1 := sortableServices(meta1.serviceAffinityMatchingPodServices)
+		sort.Sort(sortableServices1)
+		sortableServices2 := sortableServices(meta2.serviceAffinityMatchingPodServices)
+		sort.Sort(sortableServices2)
+		if !reflect.DeepEqual(sortableServices1, sortableServices2) {
+			return fmt.Errorf("serviceAffinityMatchingPodServices are not euqal.")
+		}
+	}
+	return nil
+}
+
+func TestPredicateMetadata_AddRemovePod(t *testing.T) {
+	var label1 = map[string]string{
+		"region": "r1",
+		"zone":   "z11",
+	}
+	var label2 = map[string]string{
+		"region": "r1",
+		"zone":   "z12",
+	}
+	var label3 = map[string]string{
+		"region": "r2",
+		"zone":   "z21",
+	}
+	selector1 := map[string]string{"foo": "bar"}
+	antiAffinityFooBar := &v1.PodAntiAffinity{
+		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "foo",
+							Operator: metav1.LabelSelectorOpIn,
+							Values:   []string{"bar"},
+						},
+					},
+				},
+				TopologyKey: "region",
+			},
+		},
+	}
+	antiAffinityComplex := &v1.PodAntiAffinity{
+		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "foo",
+							Operator: metav1.LabelSelectorOpIn,
+							Values:   []string{"bar", "buzz"},
+						},
+					},
+				},
+				TopologyKey: "region",
+			},
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "service",
+							Operator: metav1.LabelSelectorOpNotIn,
+							Values:   []string{"bar", "security", "test"},
+						},
+					},
+				},
+				TopologyKey: "zone",
+			},
+		},
+	}
+
+	tests := []struct {
+		description  string
+		pendingPod   *v1.Pod
+		addedPod     *v1.Pod
+		existingPods []*v1.Pod
+		nodes        []*v1.Node
+		services     []*v1.Service
+	}{
+		{
+			description: "no anti-affinity or service affinity exist",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{NodeName: "nodeC"},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec:       v1.PodSpec{NodeName: "nodeB"},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			description: "metadata anti-affinity terms are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{
+						NodeName: "nodeC",
+						Affinity: &v1.Affinity{
+							PodAntiAffinity: antiAffinityFooBar,
+						},
+					},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec: v1.PodSpec{
+					NodeName: "nodeB",
+					Affinity: &v1.Affinity{
+						PodAntiAffinity: antiAffinityFooBar,
+					},
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			description: "metadata service-affinity data are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{NodeName: "nodeC"},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec:       v1.PodSpec{NodeName: "nodeB"},
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			description: "metadata anti-affinity terms and service affinity data are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{
+						NodeName: "nodeC",
+						Affinity: &v1.Affinity{
+							PodAntiAffinity: antiAffinityFooBar,
+						},
+					},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec: v1.PodSpec{
+					NodeName: "nodeA",
+					Affinity: &v1.Affinity{
+						PodAntiAffinity: antiAffinityComplex,
+					},
+				},
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		allPodLister := schedulertesting.FakePodLister(append(test.existingPods, test.addedPod))
+		// getMeta creates predicate meta data given the list of pods.
+		getMeta := func(lister schedulertesting.FakePodLister) (*predicateMetadata, map[string]*schedulercache.NodeInfo) {
+			nodeInfoMap := schedulercache.CreateNodeNameToInfoMap(lister, test.nodes)
+			// nodeList is a list of non-pointer nodes to feed to FakeNodeListInfo.
+			nodeList := []v1.Node{}
+			for _, n := range test.nodes {
+				nodeList = append(nodeList, *n)
+			}
+			_, precompute := NewServiceAffinityPredicate(lister, schedulertesting.FakeServiceLister(test.services), FakeNodeListInfo(nodeList), nil)
+			RegisterPredicateMetadataProducer("ServiceAffinityMetaProducer", precompute)
+			pmf := PredicateMetadataFactory{lister}
+			meta := pmf.GetMetadata(test.pendingPod, nodeInfoMap)
+			return meta.(*predicateMetadata), nodeInfoMap
+		}
+
+		// allPodsMeta is meta data produced when all pods, including test.addedPod
+		// are given to the metadata producer.
+		allPodsMeta, _ := getMeta(allPodLister)
+		// existingPodsMeta1 is meta data produced for test.existingPods (without test.addedPod).
+		existingPodsMeta1, nodeInfoMap := getMeta(schedulertesting.FakePodLister(test.existingPods))
+		// Add test.addedPod to existingPodsMeta1 and make sure meta is equal to allPodsMeta
+		nodeInfo := nodeInfoMap[test.addedPod.Spec.NodeName]
+		if err := existingPodsMeta1.AddPod(test.addedPod, nodeInfo); err != nil {
+			t.Errorf("test [%v]: error adding pod to meta: %v", test.description, err)
+		}
+		if err := predicateMetadataEquivalent(allPodsMeta, existingPodsMeta1); err != nil {
+			t.Errorf("test [%v]: meta data are not equivalent: %v", test.description, err)
+		}
+		// Remove the added pod and from existingPodsMeta1 an make sure it is equal
+		// to meta generated for existing pods.
+		existingPodsMeta2, _ := getMeta(schedulertesting.FakePodLister(test.existingPods))
+		if err := existingPodsMeta1.RemovePod(test.addedPod); err != nil {
+			t.Errorf("test [%v]: error removing pod from meta: %v", test.description, err)
+		}
+		if err := predicateMetadataEquivalent(existingPodsMeta1, existingPodsMeta2); err != nil {
+			t.Errorf("test [%v]: meta data are not equivalent: %v", test.description, err)
+		}
+	}
+}
+
+// TestPredicateMetadata_ShallowCopy tests the ShallowCopy function. It is based
+// on the idea that shallow-copy should produce an object that is deep-equal to the original
+// object.
+func TestPredicateMetadata_ShallowCopy(t *testing.T) {
+	source := predicateMetadata{
+		pod: &v1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test",
+				Namespace: "testns",
+			},
+		},
+		podBestEffort: true,
+		podRequest: &schedulercache.Resource{
+			MilliCPU:         1000,
+			Memory:           300,
+			AllowedPodNumber: 4,
+		},
+		podPorts: map[int]bool{1234: true, 456: false},
+		matchingAntiAffinityTerms: map[string][]matchingPodAntiAffinityTerm{
+			"term1": {
+				{
+					term: &v1.PodAffinityTerm{TopologyKey: "node"},
+					node: &v1.Node{
+						ObjectMeta: metav1.ObjectMeta{Name: "machine1"},
+					},
+				},
+			},
+		},
+		serviceAffinityInUse: true,
+		serviceAffinityMatchingPodList: []*v1.Pod{
+			{ObjectMeta: metav1.ObjectMeta{Name: "pod1"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "pod2"}},
+		},
+		serviceAffinityMatchingPodServices: []*v1.Service{
+			{ObjectMeta: metav1.ObjectMeta{Name: "service1"}},
+		},
+	}
+
+	if !reflect.DeepEqual(source.ShallowCopy().(*predicateMetadata), &source) {
+		t.Errorf("Copy is not equal to source!")
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/utils.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package predicates
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+// FindLabelsInSet gets as many key/value pairs as possible out of a label set.
+func FindLabelsInSet(labelsToKeep []string, selector labels.Set) map[string]string {
+	aL := make(map[string]string)
+	for _, l := range labelsToKeep {
+		if selector.Has(l) {
+			aL[l] = selector.Get(l)
+		}
+	}
+	return aL
+}
+
+// AddUnsetLabelsToMap backfills missing values with values we find in a map.
+func AddUnsetLabelsToMap(aL map[string]string, labelsToAdd []string, labelSet labels.Set) {
+	for _, l := range labelsToAdd {
+		// if the label is already there, dont overwrite it.
+		if _, exists := aL[l]; exists {
+			continue
+		}
+		// otherwise, backfill this label.
+		if labelSet.Has(l) {
+			aL[l] = labelSet.Get(l)
+		}
+	}
+}
+
+// FilterPodsByNamespace filters pods outside a namespace from the given list.
+func FilterPodsByNamespace(pods []*v1.Pod, ns string) []*v1.Pod {
+	filtered := []*v1.Pod{}
+	for _, nsPod := range pods {
+		if nsPod.Namespace == ns {
+			filtered = append(filtered, nsPod)
+		}
+	}
+	return filtered
+}
+
+// CreateSelectorFromLabels is used to define a selector that corresponds to the keys in a map.
+func CreateSelectorFromLabels(aL map[string]string) labels.Selector {
+	if aL == nil || len(aL) == 0 {
+		return labels.Everything()
+	}
+	return labels.Set(aL).AsSelector()
+}
+
+// GetEquivalencePod returns a EquivalencePod which contains a group of pod attributes which can be reused.
+func GetEquivalencePod(pod *v1.Pod) interface{} {
+	// For now we only consider pods:
+	// 1. OwnerReferences is Controller
+	// 2. with same OwnerReferences
+	// to be equivalent
+	if len(pod.OwnerReferences) != 0 {
+		for _, ref := range pod.OwnerReferences {
+			if *ref.Controller {
+				// a pod can only belongs to one controller
+				return &EquivalencePod{
+					ControllerRef: ref,
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// EquivalencePod is a group of pod attributes which can be reused as equivalence to schedule other pods.
+type EquivalencePod struct {
+	ControllerRef metav1.OwnerReference
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates/utils_test.go

@@ -0,0 +1,70 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package predicates
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+// ExampleUtils is a https://blog.golang.org/examples styled unit test.
+func ExampleFindLabelsInSet() {
+	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,
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/BUILD

@@ -0,0 +1,87 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "balanced_resource_allocation.go",
+        "image_locality.go",
+        "interpod_affinity.go",
+        "least_requested.go",
+        "metadata.go",
+        "most_requested.go",
+        "node_affinity.go",
+        "node_label.go",
+        "node_prefer_avoid_pods.go",
+        "selector_spreading.go",
+        "taint_toleration.go",
+        "test_util.go",
+    ],
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//pkg/kubelet/apis:go_default_library",
+        "//pkg/util/node:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "balanced_resource_allocation_test.go",
+        "image_locality_test.go",
+        "interpod_affinity_test.go",
+        "least_requested_test.go",
+        "metadata_test.go",
+        "most_requested_test.go",
+        "node_affinity_test.go",
+        "node_label_test.go",
+        "node_prefer_avoid_pods_test.go",
+        "selector_spreading_test.go",
+        "taint_toleration_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/kubelet/apis:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/testing:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/balanced_resource_allocation.go

@@ -0,0 +1,116 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+	"math"
+
+	"k8s.io/api/core/v1"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// This is a reasonable size range of all container images. 90%ile of images on dockerhub drops into this range.
+const (
+	mb         int64 = 1024 * 1024
+	minImgSize int64 = 23 * mb
+	maxImgSize int64 = 1000 * mb
+)
+
+// Also used in most/least_requested nad metadata.
+// TODO: despaghettify it
+func getNonZeroRequests(pod *v1.Pod) *schedulercache.Resource {
+	result := &schedulercache.Resource{}
+	for i := range pod.Spec.Containers {
+		container := &pod.Spec.Containers[i]
+		cpu, memory := priorityutil.GetNonzeroRequests(&container.Resources.Requests)
+		result.MilliCPU += cpu
+		result.Memory += memory
+	}
+	return result
+}
+
+func calculateBalancedResourceAllocation(pod *v1.Pod, podRequests *schedulercache.Resource, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	allocatableResources := nodeInfo.AllocatableResource()
+	totalResources := *podRequests
+	totalResources.MilliCPU += nodeInfo.NonZeroRequest().MilliCPU
+	totalResources.Memory += nodeInfo.NonZeroRequest().Memory
+
+	cpuFraction := fractionOfCapacity(totalResources.MilliCPU, allocatableResources.MilliCPU)
+	memoryFraction := fractionOfCapacity(totalResources.Memory, allocatableResources.Memory)
+	score := int(0)
+	if cpuFraction >= 1 || memoryFraction >= 1 {
+		// if requested >= capacity, the corresponding host should never be preferred.
+		score = 0
+	} else {
+		// Upper and lower boundary of difference between cpuFraction and memoryFraction are -1 and 1
+		// respectively. Multilying the absolute value of the difference by 10 scales the value to
+		// 0-10 with 0 representing well balanced allocation and 10 poorly balanced. Subtracting it from
+		// 10 leads to the score which also scales from 0 to 10 while 10 representing well balanced.
+		diff := math.Abs(cpuFraction - memoryFraction)
+		score = int((1 - diff) * float64(schedulerapi.MaxPriority))
+	}
+	if glog.V(10) {
+		// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+		// not logged. There is visible performance gain from it.
+		glog.V(10).Infof(
+			"%v -> %v: Balanced Resource Allocation, capacity %d millicores %d memory bytes, total request %d millicores %d memory bytes, score %d",
+			pod.Name, node.Name,
+			allocatableResources.MilliCPU, allocatableResources.Memory,
+			totalResources.MilliCPU, totalResources.Memory,
+			score,
+		)
+	}
+
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: score,
+	}, nil
+}
+
+func fractionOfCapacity(requested, capacity int64) float64 {
+	if capacity == 0 {
+		return 1
+	}
+	return float64(requested) / float64(capacity)
+}
+
+// BalancedResourceAllocationMap favors nodes with balanced resource usage rate.
+// BalancedResourceAllocationMap should **NOT** be used alone, and **MUST** be used together with LeastRequestedPriority.
+// It calculates the difference between the cpu and memory fracion of capacity, and prioritizes the host based on how
+// close the two metrics are to each other.
+// Detail: score = 10 - abs(cpuFraction-memoryFraction)*10. The algorithm is partly inspired by:
+// "Wei Huang et al. An Energy Efficient Virtual Machine Placement Algorithm with Balanced Resource Utilization"
+func BalancedResourceAllocationMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	var nonZeroRequest *schedulercache.Resource
+	if priorityMeta, ok := meta.(*priorityMetadata); ok {
+		nonZeroRequest = priorityMeta.nonZeroRequest
+	} else {
+		// We couldn't parse metadatat - fallback to computing it.
+		nonZeroRequest = getNonZeroRequests(pod)
+	}
+	return calculateBalancedResourceAllocation(pod, nonZeroRequest, nodeInfo)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/balanced_resource_allocation_test.go

@@ -0,0 +1,264 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestBalancedResourceAllocation(t *testing.T) {
+	labels1 := map[string]string{
+		"foo": "bar",
+		"baz": "blah",
+	}
+	labels2 := map[string]string{
+		"bar": "foo",
+		"baz": "blah",
+	}
+	machine1Spec := v1.PodSpec{
+		NodeName: "machine1",
+	}
+	machine2Spec := v1.PodSpec{
+		NodeName: "machine2",
+	}
+	noResources := v1.PodSpec{
+		Containers: []v1.Container{},
+	}
+	cpuOnly := v1.PodSpec{
+		NodeName: "machine1",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+		},
+	}
+	cpuOnly2 := cpuOnly
+	cpuOnly2.NodeName = "machine2"
+	cpuAndMemory := v1.PodSpec{
+		NodeName: "machine2",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("2000"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("3000"),
+					},
+				},
+			},
+		},
+	}
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			/*
+				Node1 scores (remaining resources) on 0-10 scale
+				CPU Fraction: 0 / 4000 = 0%
+				Memory Fraction: 0 / 10000 = 0%
+				Node1 Score: 10 - (0-0)*10 = 10
+
+				Node2 scores (remaining resources) on 0-10 scale
+				CPU Fraction: 0 / 4000 = 0 %
+				Memory Fraction: 0 / 10000 = 0%
+				Node2 Score: 10 - (0-0)*10 = 10
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "nothing scheduled, nothing requested",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 3000 / 4000= 75%
+				Memory Fraction: 5000 / 10000 = 50%
+				Node1 Score: 10 - (0.75-0.5)*10 = 7
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 3000 / 6000= 50%
+				Memory Fraction: 5000/10000 = 50%
+				Node2 Score: 10 - (0.5-0.5)*10 = 10
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 7}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "nothing scheduled, resources requested, differently sized machines",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 0 / 4000= 0%
+				Memory Fraction: 0 / 10000 = 0%
+				Node1 Score: 10 - (0-0)*10 = 10
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 0 / 4000= 0%
+				Memory Fraction: 0 / 10000 = 0%
+				Node2 Score: 10 - (0-0)*10 = 10
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "no resources requested, pods scheduled",
+			pods: []*v1.Pod{
+				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: machine2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: machine2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 0 / 20000 = 0%
+				Node1 Score: 10 - (0.6-0)*10 = 4
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 5000 / 20000 = 25%
+				Node2 Score: 10 - (0.6-0.25)*10 = 6
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 6}},
+			test:         "no resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuOnly2, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuAndMemory, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 5000 / 20000 = 25%
+				Node1 Score: 10 - (0.6-0.25)*10 = 6
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 10000 / 20000 = 50%
+				Node2 Score: 10 - (0.6-0.5)*10 = 9
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 9}},
+			test:         "resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 5000 / 20000 = 25%
+				Node1 Score: 10 - (0.6-0.25)*10 = 6
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 6000 / 10000 = 60%
+				Memory Fraction: 10000 / 50000 = 20%
+				Node2 Score: 10 - (0.6-0.2)*10 = 6
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 50000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 6}},
+			test:         "resources requested, pods scheduled with resources, differently sized machines",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Fraction: 6000 / 4000 > 100% ==> Score := 0
+				Memory Fraction: 0 / 10000 = 0
+				Node1 Score: 0
+
+				Node2 scores on 0-10 scale
+				CPU Fraction: 6000 / 4000 > 100% ==> Score := 0
+				Memory Fraction 5000 / 10000 = 50%
+				Node2 Score: 0
+			*/
+			pod:          &v1.Pod{Spec: cpuOnly},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "requested resources exceed node capacity",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 0, 0), makeNode("machine2", 0, 0)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "zero node resources, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		list, err := priorityFunction(BalancedResourceAllocationMap, nil)(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/image_locality.go

@@ -0,0 +1,79 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// ImageLocalityPriorityMap is a priority function that favors nodes that already have requested pod container's images.
+// It will detect whether the requested images are present on a node, and then calculate a score ranging from 0 to 10
+// based on the total size of those images.
+// - If none of the images are present, this node will be given the lowest priority.
+// - If some of the images are present on a node, the larger their sizes' sum, the higher the node's priority.
+func ImageLocalityPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	var sumSize int64
+	for i := range pod.Spec.Containers {
+		sumSize += checkContainerImageOnNode(node, &pod.Spec.Containers[i])
+	}
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: calculateScoreFromSize(sumSize),
+	}, nil
+}
+
+// calculateScoreFromSize calculates the priority of a node. sumSize is sum size of requested images on this node.
+// 1. Split image size range into 10 buckets.
+// 2. Decide the priority of a given sumSize based on which bucket it belongs to.
+func calculateScoreFromSize(sumSize int64) int {
+	var score int
+	switch {
+	case sumSize == 0 || sumSize < minImgSize:
+		// score == 0 means none of the images required by this pod are present on this
+		// node or the total size of the images present is too small to be taken into further consideration.
+		score = 0
+	// If existing images' total size is larger than max, just make it highest priority.
+	case sumSize >= maxImgSize:
+		score = schedulerapi.MaxPriority
+	default:
+		score = int((int64(schedulerapi.MaxPriority) * (sumSize - minImgSize) / (maxImgSize - minImgSize)) + 1)
+	}
+	// Return which bucket the given size belongs to
+	return score
+}
+
+// checkContainerImageOnNode checks if a container image is present on a node and returns its size.
+func checkContainerImageOnNode(node *v1.Node, container *v1.Container) int64 {
+	for _, image := range node.Status.Images {
+		for _, name := range image.Names {
+			if container.Image == name {
+				// Should return immediately.
+				return image.SizeBytes
+			}
+		}
+	}
+	return 0
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/image_locality_test.go

@@ -0,0 +1,183 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestImageLocalityPriority(t *testing.T) {
+	test_40_250 := v1.PodSpec{
+		Containers: []v1.Container{
+			{
+				Image: "gcr.io/40",
+			},
+			{
+				Image: "gcr.io/250",
+			},
+		},
+	}
+
+	test_40_140 := v1.PodSpec{
+		Containers: []v1.Container{
+			{
+				Image: "gcr.io/40",
+			},
+			{
+				Image: "gcr.io/140",
+			},
+		},
+	}
+
+	test_min_max := v1.PodSpec{
+		Containers: []v1.Container{
+			{
+				Image: "gcr.io/10",
+			},
+			{
+				Image: "gcr.io/2000",
+			},
+		},
+	}
+
+	node_40_140_2000 := v1.NodeStatus{
+		Images: []v1.ContainerImage{
+			{
+				Names: []string{
+					"gcr.io/40",
+					"gcr.io/40:v1",
+					"gcr.io/40:v1",
+				},
+				SizeBytes: int64(40 * mb),
+			},
+			{
+				Names: []string{
+					"gcr.io/140",
+					"gcr.io/140:v1",
+				},
+				SizeBytes: int64(140 * mb),
+			},
+			{
+				Names: []string{
+					"gcr.io/2000",
+				},
+				SizeBytes: int64(2000 * mb),
+			},
+		},
+	}
+
+	node_250_10 := v1.NodeStatus{
+		Images: []v1.ContainerImage{
+			{
+				Names: []string{
+					"gcr.io/250",
+				},
+				SizeBytes: int64(250 * mb),
+			},
+			{
+				Names: []string{
+					"gcr.io/10",
+					"gcr.io/10:v1",
+				},
+				SizeBytes: int64(10 * mb),
+			},
+		},
+	}
+
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			// Pod: gcr.io/40 gcr.io/250
+
+			// Node1
+			// Image: gcr.io/40 40MB
+			// Score: (40M-23M)/97.7M + 1 = 1
+
+			// Node2
+			// Image: gcr.io/250 250MB
+			// Score: (250M-23M)/97.7M + 1 = 3
+			pod:          &v1.Pod{Spec: test_40_250},
+			nodes:        []*v1.Node{makeImageNode("machine1", node_40_140_2000), makeImageNode("machine2", node_250_10)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine2", Score: 3}},
+			test:         "two images spread on two nodes, prefer the larger image one",
+		},
+		{
+			// Pod: gcr.io/40 gcr.io/140
+
+			// Node1
+			// Image: gcr.io/40 40MB, gcr.io/140 140MB
+			// Score: (40M+140M-23M)/97.7M + 1 = 2
+
+			// Node2
+			// Image: not present
+			// Score: 0
+			pod:          &v1.Pod{Spec: test_40_140},
+			nodes:        []*v1.Node{makeImageNode("machine1", node_40_140_2000), makeImageNode("machine2", node_250_10)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 2}, {Host: "machine2", Score: 0}},
+			test:         "two images on one node, prefer this node",
+		},
+		{
+			// Pod: gcr.io/2000 gcr.io/10
+
+			// Node1
+			// Image: gcr.io/2000 2000MB
+			// Score: 2000 > max score = 10
+
+			// Node2
+			// Image: gcr.io/10 10MB
+			// Score: 10 < min score = 0
+			pod:          &v1.Pod{Spec: test_min_max},
+			nodes:        []*v1.Node{makeImageNode("machine1", node_40_140_2000), makeImageNode("machine2", node_250_10)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "if exceed limit, use limit",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		list, err := priorityFunction(ImageLocalityPriorityMap, nil)(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		sort.Sort(test.expectedList)
+		sort.Sort(list)
+
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}
+
+func makeImageNode(node string, status v1.NodeStatus) *v1.Node {
+	return &v1.Node{
+		ObjectMeta: metav1.ObjectMeta{Name: node},
+		Status:     status,
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/interpod_affinity.go

@@ -0,0 +1,238 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"strings"
+	"sync"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/util/workqueue"
+	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+type InterPodAffinity struct {
+	info                  predicates.NodeInfo
+	nodeLister            algorithm.NodeLister
+	podLister             algorithm.PodLister
+	hardPodAffinityWeight int
+}
+
+func NewInterPodAffinityPriority(
+	info predicates.NodeInfo,
+	nodeLister algorithm.NodeLister,
+	podLister algorithm.PodLister,
+	hardPodAffinityWeight int) algorithm.PriorityFunction {
+	interPodAffinity := &InterPodAffinity{
+		info:                  info,
+		nodeLister:            nodeLister,
+		podLister:             podLister,
+		hardPodAffinityWeight: hardPodAffinityWeight,
+	}
+	return interPodAffinity.CalculateInterPodAffinityPriority
+}
+
+type podAffinityPriorityMap struct {
+	sync.Mutex
+
+	// nodes contain all nodes that should be considered
+	nodes []*v1.Node
+	// counts store the mapping from node name to so-far computed score of
+	// the node.
+	counts map[string]float64
+	// failureDomains contain default failure domains keys
+	failureDomains priorityutil.Topologies
+	// The first error that we faced.
+	firstError error
+}
+
+func newPodAffinityPriorityMap(nodes []*v1.Node) *podAffinityPriorityMap {
+	return &podAffinityPriorityMap{
+		nodes:          nodes,
+		counts:         make(map[string]float64, len(nodes)),
+		failureDomains: priorityutil.Topologies{DefaultKeys: strings.Split(kubeletapis.DefaultFailureDomains, ",")},
+	}
+}
+
+func (p *podAffinityPriorityMap) setError(err error) {
+	p.Lock()
+	defer p.Unlock()
+	if p.firstError == nil {
+		p.firstError = err
+	}
+}
+
+func (p *podAffinityPriorityMap) processTerm(term *v1.PodAffinityTerm, podDefiningAffinityTerm, podToCheck *v1.Pod, fixedNode *v1.Node, weight float64) {
+	namespaces := priorityutil.GetNamespacesFromPodAffinityTerm(podDefiningAffinityTerm, term)
+	selector, err := metav1.LabelSelectorAsSelector(term.LabelSelector)
+	if err != nil {
+		p.setError(err)
+		return
+	}
+	match := priorityutil.PodMatchesTermsNamespaceAndSelector(podToCheck, namespaces, selector)
+	if match {
+		func() {
+			p.Lock()
+			defer p.Unlock()
+			for _, node := range p.nodes {
+				if p.failureDomains.NodesHaveSameTopologyKey(node, fixedNode, term.TopologyKey) {
+					p.counts[node.Name] += weight
+				}
+			}
+		}()
+	}
+}
+
+func (p *podAffinityPriorityMap) processTerms(terms []v1.WeightedPodAffinityTerm, podDefiningAffinityTerm, podToCheck *v1.Pod, fixedNode *v1.Node, multiplier int) {
+	for i := range terms {
+		term := &terms[i]
+		p.processTerm(&term.PodAffinityTerm, podDefiningAffinityTerm, podToCheck, fixedNode, float64(term.Weight*int32(multiplier)))
+	}
+}
+
+// CalculateInterPodAffinityPriority compute a sum by iterating through the elements of weightedPodAffinityTerm and adding
+// "weight" to the sum if the corresponding PodAffinityTerm is satisfied for
+// that node; the node(s) with the highest sum are the most preferred.
+// Symmetry need to be considered for preferredDuringSchedulingIgnoredDuringExecution from podAffinity & podAntiAffinity,
+// symmetry need to be considered for hard requirements from podAffinity
+func (ipa *InterPodAffinity) CalculateInterPodAffinityPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	affinity := pod.Spec.Affinity
+	hasAffinityConstraints := affinity != nil && affinity.PodAffinity != nil
+	hasAntiAffinityConstraints := affinity != nil && affinity.PodAntiAffinity != nil
+
+	allNodeNames := make([]string, 0, len(nodeNameToInfo))
+	for name := range nodeNameToInfo {
+		allNodeNames = append(allNodeNames, name)
+	}
+
+	// convert the topology key based weights to the node name based weights
+	var maxCount float64
+	var minCount float64
+	// priorityMap stores the mapping from node name to so-far computed score of
+	// the node.
+	pm := newPodAffinityPriorityMap(nodes)
+
+	processPod := func(existingPod *v1.Pod) error {
+		existingPodNode, err := ipa.info.GetNodeInfo(existingPod.Spec.NodeName)
+		if err != nil {
+			return err
+		}
+		existingPodAffinity := existingPod.Spec.Affinity
+		existingHasAffinityConstraints := existingPodAffinity != nil && existingPodAffinity.PodAffinity != nil
+		existingHasAntiAffinityConstraints := existingPodAffinity != nil && existingPodAffinity.PodAntiAffinity != nil
+
+		if hasAffinityConstraints {
+			// For every soft pod affinity term of <pod>, if <existingPod> matches the term,
+			// increment <pm.counts> for every node in the cluster with the same <term.TopologyKey>
+			// value as that of <existingPods>`s node by the term`s weight.
+			terms := affinity.PodAffinity.PreferredDuringSchedulingIgnoredDuringExecution
+			pm.processTerms(terms, pod, existingPod, existingPodNode, 1)
+		}
+		if hasAntiAffinityConstraints {
+			// For every soft pod anti-affinity term of <pod>, if <existingPod> matches the term,
+			// decrement <pm.counts> for every node in the cluster with the same <term.TopologyKey>
+			// value as that of <existingPod>`s node by the term`s weight.
+			terms := affinity.PodAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution
+			pm.processTerms(terms, pod, existingPod, existingPodNode, -1)
+		}
+
+		if existingHasAffinityConstraints {
+			// For every hard pod affinity term of <existingPod>, if <pod> matches the term,
+			// increment <pm.counts> for every node in the cluster with the same <term.TopologyKey>
+			// value as that of <existingPod>'s node by the constant <ipa.hardPodAffinityWeight>
+			if ipa.hardPodAffinityWeight > 0 {
+				terms := existingPodAffinity.PodAffinity.RequiredDuringSchedulingIgnoredDuringExecution
+				// TODO: Uncomment this block when implement RequiredDuringSchedulingRequiredDuringExecution.
+				//if len(existingPodAffinity.PodAffinity.RequiredDuringSchedulingRequiredDuringExecution) != 0 {
+				//	terms = append(terms, existingPodAffinity.PodAffinity.RequiredDuringSchedulingRequiredDuringExecution...)
+				//}
+				for _, term := range terms {
+					pm.processTerm(&term, existingPod, pod, existingPodNode, float64(ipa.hardPodAffinityWeight))
+				}
+			}
+			// For every soft pod affinity term of <existingPod>, if <pod> matches the term,
+			// increment <pm.counts> for every node in the cluster with the same <term.TopologyKey>
+			// value as that of <existingPod>'s node by the term's weight.
+			terms := existingPodAffinity.PodAffinity.PreferredDuringSchedulingIgnoredDuringExecution
+			pm.processTerms(terms, existingPod, pod, existingPodNode, 1)
+		}
+		if existingHasAntiAffinityConstraints {
+			// For every soft pod anti-affinity term of <existingPod>, if <pod> matches the term,
+			// decrement <pm.counts> for every node in the cluster with the same <term.TopologyKey>
+			// value as that of <existingPod>'s node by the term's weight.
+			terms := existingPodAffinity.PodAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution
+			pm.processTerms(terms, existingPod, pod, existingPodNode, -1)
+		}
+		return nil
+	}
+	processNode := func(i int) {
+		nodeInfo := nodeNameToInfo[allNodeNames[i]]
+		if hasAffinityConstraints || hasAntiAffinityConstraints {
+			// We need to process all the nodes.
+			for _, existingPod := range nodeInfo.Pods() {
+				if err := processPod(existingPod); err != nil {
+					pm.setError(err)
+				}
+			}
+		} else {
+			// The pod doesn't have any constraints - we need to check only existing
+			// ones that have some.
+			for _, existingPod := range nodeInfo.PodsWithAffinity() {
+				if err := processPod(existingPod); err != nil {
+					pm.setError(err)
+				}
+			}
+		}
+	}
+	workqueue.Parallelize(16, len(allNodeNames), processNode)
+	if pm.firstError != nil {
+		return nil, pm.firstError
+	}
+
+	for _, node := range nodes {
+		if pm.counts[node.Name] > maxCount {
+			maxCount = pm.counts[node.Name]
+		}
+		if pm.counts[node.Name] < minCount {
+			minCount = pm.counts[node.Name]
+		}
+	}
+
+	// calculate final priority score for each node
+	result := make(schedulerapi.HostPriorityList, 0, len(nodes))
+	for _, node := range nodes {
+		fScore := float64(0)
+		if (maxCount - minCount) > 0 {
+			fScore = float64(schedulerapi.MaxPriority) * ((pm.counts[node.Name] - minCount) / (maxCount - minCount))
+		}
+		result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: int(fScore)})
+		if glog.V(10) {
+			// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+			// not logged. There is visible performance gain from it.
+			glog.V(10).Infof("%v -> %v: InterPodAffinityPriority, Score: (%d)", pod.Name, node.Name, int(fScore))
+		}
+	}
+	return result, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/interpod_affinity_test.go

@@ -0,0 +1,615 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedulertesting "k8s.io/kubernetes/plugin/pkg/scheduler/testing"
+)
+
+type FakeNodeListInfo []*v1.Node
+
+func (nodes FakeNodeListInfo) GetNodeInfo(nodeName string) (*v1.Node, error) {
+	for _, node := range nodes {
+		if node.Name == nodeName {
+			return node, nil
+		}
+	}
+	return nil, fmt.Errorf("Unable to find node: %s", nodeName)
+}
+
+func TestInterPodAffinityPriority(t *testing.T) {
+	labelRgChina := map[string]string{
+		"region": "China",
+	}
+	labelRgIndia := map[string]string{
+		"region": "India",
+	}
+	labelAzAz1 := map[string]string{
+		"az": "az1",
+	}
+	labelAzAz2 := map[string]string{
+		"az": "az2",
+	}
+	labelRgChinaAzAz1 := map[string]string{
+		"region": "China",
+		"az":     "az1",
+	}
+	podLabelSecurityS1 := map[string]string{
+		"security": "S1",
+	}
+	podLabelSecurityS2 := map[string]string{
+		"security": "S2",
+	}
+	// considered only preferredDuringSchedulingIgnoredDuringExecution in pod affinity
+	stayWithS1InRegion := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 5,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S1"},
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				},
+			},
+		},
+	}
+	stayWithS2InRegion := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 6,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S2"},
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				},
+			},
+		},
+	}
+	affinity3 := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 8,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpNotIn,
+									Values:   []string{"S1"},
+								}, {
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S2"},
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				}, {
+					Weight: 2,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpExists,
+								}, {
+									Key:      "wrongkey",
+									Operator: metav1.LabelSelectorOpDoesNotExist,
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				},
+			},
+		},
+	}
+	hardAffinity := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+				{
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "security",
+								Operator: metav1.LabelSelectorOpIn,
+								Values:   []string{"S1", "value2"},
+							},
+						},
+					},
+					TopologyKey: "region",
+				}, {
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "security",
+								Operator: metav1.LabelSelectorOpExists,
+							}, {
+								Key:      "wrongkey",
+								Operator: metav1.LabelSelectorOpDoesNotExist,
+							},
+						},
+					},
+					TopologyKey: "region",
+				},
+			},
+		},
+	}
+	awayFromS1InAz := &v1.Affinity{
+		PodAntiAffinity: &v1.PodAntiAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 5,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S1"},
+								},
+							},
+						},
+						TopologyKey: "az",
+					},
+				},
+			},
+		},
+	}
+	// to stay away from security S2 in any az.
+	awayFromS2InAz := &v1.Affinity{
+		PodAntiAffinity: &v1.PodAntiAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 5,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S2"},
+								},
+							},
+						},
+						TopologyKey: "az",
+					},
+				},
+			},
+		},
+	}
+	// to stay with security S1 in same region, stay away from security S2 in any az.
+	stayWithS1InRegionAwayFromS2InAz := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 8,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S1"},
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				},
+			},
+		},
+		PodAntiAffinity: &v1.PodAntiAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 5,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S2"},
+								},
+							},
+						},
+						TopologyKey: "az",
+					},
+				},
+			},
+		},
+	}
+
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test:         "all machines are same priority as Affinity is nil",
+		},
+		// the node(machine1) that have the label {"region": "China"} (match the topology key) and that have existing pods that match the labelSelector get high score
+		// the node(machine3) that don't have the label {"region": "whatever the value is"} (mismatch the topology key) but that have existing pods that match the labelSelector get low score
+		// the node(machine2) that have the label {"region": "China"} (match the topology key) but that have existing pods that mismatch the labelSelector get low score
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS1InRegion}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine3"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test: "Affinity: pod that matches topology key & pods in nodes will get high score comparing to others" +
+				"which doesn't match either pods in nodes or in topology key",
+		},
+		// the node1(machine1) that have the label {"region": "China"} (match the topology key) and that have existing pods that match the labelSelector get high score
+		// the node2(machine2) that have the label {"region": "China"}, match the topology key and have the same label value with node1, get the same high score with node1
+		// the node3(machine3) that have the label {"region": "India"}, match the topology key but have a different label value, don't have existing pods that match the labelSelector,
+		// get a low score.
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS1InRegion}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgChinaAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelRgIndia}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: 0}},
+			test:         "All the nodes that have the same topology key & label value with one of them has an existing pod that match the affinity rules, have the same score",
+		},
+		// there are 2 regions, say regionChina(machine1,machine3,machine4) and regionIndia(machine2,machine5), both regions have nodes that match the preference.
+		// But there are more nodes(actually more existing pods) in regionChina that match the preference than regionIndia.
+		// Then, nodes in regionChina get higher score than nodes in regionIndia, and all the nodes in regionChina should get a same score(high score),
+		// while all the nodes in regionIndia should get another same score(low score).
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS2InRegion}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine3"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine4"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine5"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine4", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine5", Labels: labelRgIndia}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 5}, {Host: "machine3", Score: schedulerapi.MaxPriority}, {Host: "machine4", Score: schedulerapi.MaxPriority}, {Host: "machine5", Score: 5}},
+			test:         "Affinity: nodes in one region has more matching pods comparing to other reqion, so the region which has more macthes will get high score",
+		},
+		// Test with the different operators and values for pod affinity scheduling preference, including some match failures.
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: affinity3}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine3"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 2}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: 0}},
+			test:         "Affinity: different Label operators and values for pod affinity scheduling preference, including some match failures ",
+		},
+		// Test the symmetry cases for affinity, the difference between affinity and symmetry is not the pod wants to run together with some existing pods,
+		// but the existing pods have the inter pod affinity preference while the pod to schedule satisfy the preference.
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1", Affinity: stayWithS1InRegion}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2", Affinity: stayWithS2InRegion}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: 0}},
+			test:         "Affinity symmetry: considred only the preferredDuringSchedulingIgnoredDuringExecution in pod affinity symmetry",
+		},
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1", Affinity: hardAffinity}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2", Affinity: hardAffinity}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: 0}},
+			test:         "Affinity symmetry: considred RequiredDuringSchedulingIgnoredDuringExecution in pod affinity symmetry",
+		},
+
+		// The pod to schedule prefer to stay away from some existing pods at node level using the pod anti affinity.
+		// the nodes that have the label {"node": "bar"} (match the topology key) and that have existing pods that match the labelSelector get low score
+		// the nodes that don't have the label {"node": "whatever the value is"} (mismatch the topology key) but that have existing pods that match the labelSelector get high score
+		// the nodes that have the label {"node": "bar"} (match the topology key) but that have existing pods that mismatch the labelSelector get high score
+		// there are 2 nodes, say node1 and node2, both nodes have pods that match the labelSelector and have topology-key in node.Labels.
+		// But there are more pods on node1 that match the preference than node2. Then, node1 get a lower score than node2.
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: awayFromS1InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgChina}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "Anti Affinity: pod that doesnot match existing pods in node will get high score ",
+		},
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: awayFromS1InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgChina}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "Anti Affinity: pod that does not matches topology key & matches the pods in nodes will get higher score comparing to others ",
+		},
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: awayFromS1InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "Anti Affinity: one node has more matching pods comparing to other node, so the node which has more unmacthes will get high score",
+		},
+		// Test the symmetry cases for anti affinity
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1", Affinity: awayFromS2InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2", Affinity: awayFromS1InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelAzAz2}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "Anti Affinity symmetry: the existing pods in node which has anti affinity match will get high score",
+		},
+		// Test both  affinity and anti-affinity
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS1InRegionAwayFromS2InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelAzAz1}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "Affinity and Anti Affinity: considered only preferredDuringSchedulingIgnoredDuringExecution in both pod affinity & anti affinity",
+		},
+		// Combined cases considering both affinity and anti-affinity, the pod to schedule and existing pods have the same labels (they are in the same RC/service),
+		// the pod prefer to run together with its brother pods in the same region, but wants to stay away from them at node level,
+		// so that all the pods of a RC/service can stay in a same region but trying to separate with each other
+		// machine-1,machine-3,machine-4 are in ChinaRegion others machin-2,machine-5 are in IndiaRegion
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS1InRegionAwayFromS2InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine3"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine3"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine4"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine5"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChinaAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine4", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine5", Labels: labelRgIndia}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 4}, {Host: "machine3", Score: schedulerapi.MaxPriority}, {Host: "machine4", Score: schedulerapi.MaxPriority}, {Host: "machine5", Score: 4}},
+			test:         "Affinity and Anti Affinity: considering both affinity and anti-affinity, the pod to schedule and existing pods have the same labels",
+		},
+		// Consider Affinity, Anti Affinity and symmetry together.
+		// for Affinity, the weights are:                8,  0,  0,  0
+		// for Anti Affinity, the weights are:           0, -5,  0,  0
+		// for Affinity symmetry, the weights are:       0,  0,  8,  0
+		// for Anti Affinity symmetry, the weights are:  0,  0,  0, -5
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: "", Affinity: stayWithS1InRegionAwayFromS2InAz}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS1}},
+				{Spec: v1.PodSpec{NodeName: "machine2"}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelSecurityS2}},
+				{Spec: v1.PodSpec{NodeName: "machine3", Affinity: stayWithS1InRegionAwayFromS2InAz}},
+				{Spec: v1.PodSpec{NodeName: "machine4", Affinity: awayFromS1InAz}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelAzAz1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine4", Labels: labelAzAz2}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: schedulerapi.MaxPriority}, {Host: "machine4", Score: 0}},
+			test:         "Affinity and Anti Affinity and symmetry: considered only preferredDuringSchedulingIgnoredDuringExecution in both pod affinity & anti affinity & symmetry",
+		},
+	}
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		interPodAffinity := InterPodAffinity{
+			info:                  FakeNodeListInfo(test.nodes),
+			nodeLister:            schedulertesting.FakeNodeLister(test.nodes),
+			podLister:             schedulertesting.FakePodLister(test.pods),
+			hardPodAffinityWeight: v1.DefaultHardPodAffinitySymmetricWeight,
+		}
+		list, err := interPodAffinity.CalculateInterPodAffinityPriority(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: \nexpected \n\t%#v, \ngot \n\t%#v\n", test.test, test.expectedList, list)
+		}
+	}
+}
+
+func TestHardPodAffinitySymmetricWeight(t *testing.T) {
+	podLabelServiceS1 := map[string]string{
+		"service": "S1",
+	}
+	labelRgChina := map[string]string{
+		"region": "China",
+	}
+	labelRgIndia := map[string]string{
+		"region": "India",
+	}
+	labelAzAz1 := map[string]string{
+		"az": "az1",
+	}
+	hardPodAffinity := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+				{
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "service",
+								Operator: metav1.LabelSelectorOpIn,
+								Values:   []string{"S1"},
+							},
+						},
+					},
+					TopologyKey: "region",
+				},
+			},
+		},
+	}
+	tests := []struct {
+		pod                   *v1.Pod
+		pods                  []*v1.Pod
+		nodes                 []*v1.Node
+		hardPodAffinityWeight int
+		expectedList          schedulerapi.HostPriorityList
+		test                  string
+	}{
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelServiceS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1", Affinity: hardPodAffinity}},
+				{Spec: v1.PodSpec{NodeName: "machine2", Affinity: hardPodAffinity}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			hardPodAffinityWeight: v1.DefaultHardPodAffinitySymmetricWeight,
+			expectedList:          []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: 0}},
+			test:                  "Hard Pod Affinity symmetry: hard pod affinity symmetry weights 1 by default, then nodes that match the hard pod affinity symmetry rules, get a high score",
+		},
+		{
+			pod: &v1.Pod{Spec: v1.PodSpec{NodeName: ""}, ObjectMeta: metav1.ObjectMeta{Labels: podLabelServiceS1}},
+			pods: []*v1.Pod{
+				{Spec: v1.PodSpec{NodeName: "machine1", Affinity: hardPodAffinity}},
+				{Spec: v1.PodSpec{NodeName: "machine2", Affinity: hardPodAffinity}},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: labelRgChina}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: labelRgIndia}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: labelAzAz1}},
+			},
+			hardPodAffinityWeight: 0,
+			expectedList:          []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test:                  "Hard Pod Affinity symmetry: hard pod affinity symmetry is closed(weights 0), then nodes that match the hard pod affinity symmetry rules, get same score with those not match",
+		},
+	}
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		ipa := InterPodAffinity{
+			info:                  FakeNodeListInfo(test.nodes),
+			nodeLister:            schedulertesting.FakeNodeLister(test.nodes),
+			podLister:             schedulertesting.FakePodLister(test.pods),
+			hardPodAffinityWeight: test.hardPodAffinityWeight,
+		}
+		list, err := ipa.CalculateInterPodAffinityPriority(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: \nexpected \n\t%#v, \ngot \n\t%#v\n", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/least_requested.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// LeastRequestedPriority is a priority function that favors nodes with fewer requested resources.
+// It calculates the percentage of memory and CPU requested by pods scheduled on the node, and prioritizes
+// based on the minimum of the average of the fraction of requested to capacity.
+// Details: cpu((capacity - sum(requested)) * 10 / capacity) + memory((capacity - sum(requested)) * 10 / capacity) / 2
+func LeastRequestedPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	var nonZeroRequest *schedulercache.Resource
+	if priorityMeta, ok := meta.(*priorityMetadata); ok {
+		nonZeroRequest = priorityMeta.nonZeroRequest
+	} else {
+		// We couldn't parse metadata - fallback to computing it.
+		nonZeroRequest = getNonZeroRequests(pod)
+	}
+	return calculateUnusedPriority(pod, nonZeroRequest, nodeInfo)
+}
+
+// The unused capacity is calculated on a scale of 0-10
+// 0 being the lowest priority and 10 being the highest.
+// The more unused resources the higher the score is.
+func calculateUnusedScore(requested int64, capacity int64, node string) int64 {
+	if capacity == 0 {
+		return 0
+	}
+	if requested > capacity {
+		glog.V(10).Infof("Combined requested resources %d from existing pods exceeds capacity %d on node %s",
+			requested, capacity, node)
+		return 0
+	}
+	return ((capacity - requested) * int64(schedulerapi.MaxPriority)) / capacity
+}
+
+// Calculates host priority based on the amount of unused resources.
+// 'node' has information about the resources on the node.
+// 'pods' is a list of pods currently scheduled on the node.
+func calculateUnusedPriority(pod *v1.Pod, podRequests *schedulercache.Resource, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	allocatableResources := nodeInfo.AllocatableResource()
+	totalResources := *podRequests
+	totalResources.MilliCPU += nodeInfo.NonZeroRequest().MilliCPU
+	totalResources.Memory += nodeInfo.NonZeroRequest().Memory
+
+	cpuScore := calculateUnusedScore(totalResources.MilliCPU, allocatableResources.MilliCPU, node.Name)
+	memoryScore := calculateUnusedScore(totalResources.Memory, allocatableResources.Memory, node.Name)
+	if glog.V(10) {
+		// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+		// not logged. There is visible performance gain from it.
+		glog.V(10).Infof(
+			"%v -> %v: Least Requested Priority, capacity %d millicores %d memory bytes, total request %d millicores %d memory bytes, score %d CPU %d memory",
+			pod.Name, node.Name,
+			allocatableResources.MilliCPU, allocatableResources.Memory,
+			totalResources.MilliCPU, totalResources.Memory,
+			cpuScore, memoryScore,
+		)
+	}
+
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: int((cpuScore + memoryScore) / 2),
+	}, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/least_requested_test.go

@@ -0,0 +1,264 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestLeastRequested(t *testing.T) {
+	labels1 := map[string]string{
+		"foo": "bar",
+		"baz": "blah",
+	}
+	labels2 := map[string]string{
+		"bar": "foo",
+		"baz": "blah",
+	}
+	machine1Spec := v1.PodSpec{
+		NodeName: "machine1",
+	}
+	machine2Spec := v1.PodSpec{
+		NodeName: "machine2",
+	}
+	noResources := v1.PodSpec{
+		Containers: []v1.Container{},
+	}
+	cpuOnly := v1.PodSpec{
+		NodeName: "machine1",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+		},
+	}
+	cpuOnly2 := cpuOnly
+	cpuOnly2.NodeName = "machine2"
+	cpuAndMemory := v1.PodSpec{
+		NodeName: "machine2",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("2000"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("3000"),
+					},
+				},
+			},
+		},
+	}
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			/*
+				Node1 scores (remaining resources) on 0-10 scale
+				CPU Score: ((4000 - 0) *10) / 4000 = 10
+				Memory Score: ((10000 - 0) *10) / 10000 = 10
+				Node1 Score: (10 + 10) / 2 = 10
+
+				Node2 scores (remaining resources) on 0-10 scale
+				CPU Score: ((4000 - 0) *10) / 4000 = 10
+				Memory Score: ((10000 - 0) *10) / 10000 = 10
+				Node2 Score: (10 + 10) / 2 = 10
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "nothing scheduled, nothing requested",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((4000 - 3000) *10) / 4000 = 2.5
+				Memory Score: ((10000 - 5000) *10) / 10000 = 5
+				Node1 Score: (2.5 + 5) / 2 = 3
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((6000 - 3000) *10) / 6000 = 5
+				Memory Score: ((10000 - 5000) *10) / 10000 = 5
+				Node2 Score: (5 + 5) / 2 = 5
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 3}, {Host: "machine2", Score: 5}},
+			test:         "nothing scheduled, resources requested, differently sized machines",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((4000 - 0) *10) / 4000 = 10
+				Memory Score: ((10000 - 0) *10) / 10000 = 10
+				Node1 Score: (10 + 10) / 2 = 10
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((4000 - 0) *10) / 4000 = 10
+				Memory Score: ((10000 - 0) *10) / 10000 = 10
+				Node2 Score: (10 + 10) / 2 = 10
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "no resources requested, pods scheduled",
+			pods: []*v1.Pod{
+				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: machine2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: machine2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((20000 - 0) *10) / 20000 = 10
+				Node1 Score: (4 + 10) / 2 = 7
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((20000 - 5000) *10) / 20000 = 7.5
+				Node2 Score: (4 + 7.5) / 2 = 5
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 7}, {Host: "machine2", Score: 5}},
+			test:         "no resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuOnly2, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuAndMemory, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((20000 - 5000) *10) / 20000 = 7.5
+				Node1 Score: (4 + 7.5) / 2 = 5
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((20000 - 10000) *10) / 20000 = 5
+				Node2 Score: (4 + 5) / 2 = 4
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 4}},
+			test:         "resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((20000 - 5000) *10) / 20000 = 7.5
+				Node1 Score: (4 + 7.5) / 2 = 5
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((10000 - 6000) *10) / 10000 = 4
+				Memory Score: ((50000 - 10000) *10) / 50000 = 8
+				Node2 Score: (4 + 8) / 2 = 6
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 50000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 6}},
+			test:         "resources requested, pods scheduled with resources, differently sized machines",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: ((4000 - 6000) *10) / 4000 = 0
+				Memory Score: ((10000 - 0) *10) / 10000 = 10
+				Node1 Score: (0 + 10) / 2 = 5
+
+				Node2 scores on 0-10 scale
+				CPU Score: ((4000 - 6000) *10) / 4000 = 0
+				Memory Score: ((10000 - 5000) *10) / 10000 = 5
+				Node2 Score: (0 + 5) / 2 = 2
+			*/
+			pod:          &v1.Pod{Spec: cpuOnly},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 2}},
+			test:         "requested resources exceed node capacity",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 0, 0), makeNode("machine2", 0, 0)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "zero node resources, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		list, err := priorityFunction(LeastRequestedPriorityMap, nil)(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/metadata.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// priorityMetadata is a type that is passed as metadata for priority functions
+type priorityMetadata struct {
+	nonZeroRequest *schedulercache.Resource
+	podTolerations []v1.Toleration
+	affinity       *v1.Affinity
+}
+
+// PriorityMetadata is a MetadataProducer.  Node info can be nil.
+func PriorityMetadata(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) interface{} {
+	// If we cannot compute metadata, just return nil
+	if pod == nil {
+		return nil
+	}
+	tolerationsPreferNoSchedule := getAllTolerationPreferNoSchedule(pod.Spec.Tolerations)
+	return &priorityMetadata{
+		nonZeroRequest: getNonZeroRequests(pod),
+		podTolerations: tolerationsPreferNoSchedule,
+		affinity:       pod.Spec.Affinity,
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/metadata_test.go

@@ -0,0 +1,132 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestPriorityMetadata(t *testing.T) {
+	nonZeroReqs := &schedulercache.Resource{}
+	nonZeroReqs.MilliCPU = priorityutil.DefaultMilliCpuRequest
+	nonZeroReqs.Memory = priorityutil.DefaultMemoryRequest
+
+	specifiedReqs := &schedulercache.Resource{}
+	specifiedReqs.MilliCPU = 200
+	specifiedReqs.Memory = 2000
+
+	tolerations := []v1.Toleration{{
+		Key:      "foo",
+		Operator: v1.TolerationOpEqual,
+		Value:    "bar",
+		Effect:   v1.TaintEffectPreferNoSchedule,
+	}}
+	podAffinity := &v1.Affinity{
+		PodAffinity: &v1.PodAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.WeightedPodAffinityTerm{
+				{
+					Weight: 5,
+					PodAffinityTerm: v1.PodAffinityTerm{
+						LabelSelector: &metav1.LabelSelector{
+							MatchExpressions: []metav1.LabelSelectorRequirement{
+								{
+									Key:      "security",
+									Operator: metav1.LabelSelectorOpIn,
+									Values:   []string{"S1"},
+								},
+							},
+						},
+						TopologyKey: "region",
+					},
+				},
+			},
+		},
+	}
+	podWithTolerationsAndAffinity := &v1.Pod{
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:            "container",
+					Image:           "image",
+					ImagePullPolicy: "Always",
+				},
+			},
+			Affinity:    podAffinity,
+			Tolerations: tolerations,
+		},
+	}
+	podWithTolerationsAndRequests := &v1.Pod{
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:            "container",
+					Image:           "image",
+					ImagePullPolicy: "Always",
+					Resources: v1.ResourceRequirements{
+						Requests: v1.ResourceList{
+							v1.ResourceCPU:    resource.MustParse("200m"),
+							v1.ResourceMemory: resource.MustParse("2000"),
+						},
+					},
+				},
+			},
+			Tolerations: tolerations,
+		},
+	}
+	tests := []struct {
+		pod      *v1.Pod
+		test     string
+		expected interface{}
+	}{
+		{
+			pod:      nil,
+			expected: nil,
+			test:     "pod is nil , priorityMetadata is nil",
+		},
+		{
+			pod: podWithTolerationsAndAffinity,
+			expected: &priorityMetadata{
+				nonZeroRequest: nonZeroReqs,
+				podTolerations: tolerations,
+				affinity:       podAffinity,
+			},
+			test: "Produce a priorityMetadata with default requests",
+		},
+		{
+			pod: podWithTolerationsAndRequests,
+			expected: &priorityMetadata{
+				nonZeroRequest: specifiedReqs,
+				podTolerations: tolerations,
+				affinity:       nil,
+			},
+			test: "Produce a priorityMetadata with specified requests",
+		},
+	}
+	for _, test := range tests {
+		ptData := PriorityMetadata(test.pod, nil)
+		if !reflect.DeepEqual(test.expected, ptData) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expected, ptData)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/most_requested.go

@@ -0,0 +1,94 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// MostRequestedPriority is a priority function that favors nodes with most requested resources.
+// It calculates the percentage of memory and CPU requested by pods scheduled on the node, and prioritizes
+// based on the maximum of the average of the fraction of requested to capacity.
+// Details: (cpu(10 * sum(requested) / capacity) + memory(10 * sum(requested) / capacity)) / 2
+func MostRequestedPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	var nonZeroRequest *schedulercache.Resource
+	if priorityMeta, ok := meta.(*priorityMetadata); ok {
+		nonZeroRequest = priorityMeta.nonZeroRequest
+	} else {
+		// We couldn't parse metadatat - fallback to computing it.
+		nonZeroRequest = getNonZeroRequests(pod)
+	}
+	return calculateUsedPriority(pod, nonZeroRequest, nodeInfo)
+}
+
+// The used capacity is calculated on a scale of 0-10
+// 0 being the lowest priority and 10 being the highest.
+// The more resources are used the higher the score is. This function
+// is almost a reversed version of least_requested_priority.calculatUnusedScore
+// (10 - calculateUnusedScore). The main difference is in rounding. It was added to
+// keep the final formula clean and not to modify the widely used (by users
+// in their default scheduling policies) calculateUSedScore.
+func calculateUsedScore(requested int64, capacity int64, node string) int64 {
+	if capacity == 0 {
+		return 0
+	}
+	if requested > capacity {
+		glog.V(10).Infof("Combined requested resources %d from existing pods exceeds capacity %d on node %s",
+			requested, capacity, node)
+		return 0
+	}
+	return (requested * schedulerapi.MaxPriority) / capacity
+}
+
+// Calculate the resource used on a node.  'node' has information about the resources on the node.
+// 'pods' is a list of pods currently scheduled on the node.
+func calculateUsedPriority(pod *v1.Pod, podRequests *schedulercache.Resource, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	allocatableResources := nodeInfo.AllocatableResource()
+	totalResources := *podRequests
+	totalResources.MilliCPU += nodeInfo.NonZeroRequest().MilliCPU
+	totalResources.Memory += nodeInfo.NonZeroRequest().Memory
+
+	cpuScore := calculateUsedScore(totalResources.MilliCPU, allocatableResources.MilliCPU, node.Name)
+	memoryScore := calculateUsedScore(totalResources.Memory, allocatableResources.Memory, node.Name)
+	if glog.V(10) {
+		// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+		// not logged. There is visible performance gain from it.
+		glog.V(10).Infof(
+			"%v -> %v: Most Requested Priority, capacity %d millicores %d memory bytes, total request %d millicores %d memory bytes, score %d CPU %d memory",
+			pod.Name, node.Name,
+			allocatableResources.MilliCPU, allocatableResources.Memory,
+			totalResources.MilliCPU, totalResources.Memory,
+			cpuScore, memoryScore,
+		)
+	}
+
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: int((cpuScore + memoryScore) / 2),
+	}, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/most_requested_test.go

@@ -0,0 +1,221 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestMostRequested(t *testing.T) {
+	labels1 := map[string]string{
+		"foo": "bar",
+		"baz": "blah",
+	}
+	labels2 := map[string]string{
+		"bar": "foo",
+		"baz": "blah",
+	}
+	noResources := v1.PodSpec{
+		Containers: []v1.Container{},
+	}
+	cpuOnly := v1.PodSpec{
+		NodeName: "machine1",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("0"),
+					},
+				},
+			},
+		},
+	}
+	cpuOnly2 := cpuOnly
+	cpuOnly2.NodeName = "machine2"
+	cpuAndMemory := v1.PodSpec{
+		NodeName: "machine2",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("1000m"),
+						v1.ResourceMemory: resource.MustParse("2000"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("3000"),
+					},
+				},
+			},
+		},
+	}
+	bigCpuAndMemory := v1.PodSpec{
+		NodeName: "machine1",
+		Containers: []v1.Container{
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("2000m"),
+						v1.ResourceMemory: resource.MustParse("4000"),
+					},
+				},
+			},
+			{
+				Resources: v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						v1.ResourceCPU:    resource.MustParse("3000m"),
+						v1.ResourceMemory: resource.MustParse("5000"),
+					},
+				},
+			},
+		},
+	}
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			/*
+				Node1 scores (used resources) on 0-10 scale
+				CPU Score: (0 * 10  / 4000 = 0
+				Memory Score: (0 * 10) / 10000 = 0
+				Node1 Score: (0 + 0) / 2 = 0
+
+				Node2 scores (used resources) on 0-10 scale
+				CPU Score: (0 * 10 / 4000 = 0
+				Memory Score: (0 * 10 / 10000 = 0
+				Node2 Score: (0 + 0) / 2 = 0
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "nothing scheduled, nothing requested",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: (3000 * 10 / 4000 = 7.5
+				Memory Score: (5000 * 10) / 10000 = 5
+				Node1 Score: (7.5 + 5) / 2 = 6
+
+				Node2 scores on 0-10 scale
+				CPU Score: (3000 * 10 / 6000 = 5
+				Memory Score: (5000 * 10 / 10000 = 5
+				Node2 Score: (5 + 5) / 2 = 5
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 5}},
+			test:         "nothing scheduled, resources requested, differently sized machines",
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: (6000 * 10) / 10000 = 6
+				Memory Score: (0 * 10) / 20000 = 10
+				Node1 Score: (6 + 0) / 2 = 3
+
+				Node2 scores on 0-10 scale
+				CPU Score: (6000 * 10) / 10000 = 6
+				Memory Score: (5000 * 10) / 20000 = 2.5
+				Node2 Score: (6 + 2.5) / 2 = 4
+			*/
+			pod:          &v1.Pod{Spec: noResources},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 3}, {Host: "machine2", Score: 4}},
+			test:         "no resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuOnly2, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: cpuAndMemory, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: (6000 * 10) / 10000 = 6
+				Memory Score: (5000 * 10) / 20000 = 2.5
+				Node1 Score: (6 + 2.5) / 2 = 4
+
+				Node2 scores on 0-10 scale
+				CPU Score: (6000 * 10) / 10000 = 6
+				Memory Score: (10000 * 10) / 20000 = 5
+				Node2 Score: (6 + 5) / 2 = 5
+			*/
+			pod:          &v1.Pod{Spec: cpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 5}},
+			test:         "resources requested, pods scheduled with resources",
+			pods: []*v1.Pod{
+				{Spec: cpuOnly},
+				{Spec: cpuAndMemory},
+			},
+		},
+		{
+			/*
+				Node1 scores on 0-10 scale
+				CPU Score: 5000 > 4000 return 0
+				Memory Score: (9000 * 10) / 10000 = 9
+				Node1 Score: (0 + 9) / 2 = 4
+
+				Node2 scores on 0-10 scale
+				CPU Score: (5000 * 10) / 10000 = 5
+				Memory Score: 9000 > 8000 return 0
+				Node2 Score: (5 + 0) / 2 = 2
+			*/
+			pod:          &v1.Pod{Spec: bigCpuAndMemory},
+			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 10000, 8000)},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 2}},
+			test:         "resources requested with more than the node, pods scheduled with resources",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+		list, err := priorityFunction(MostRequestedPriorityMap, nil)(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_affinity.go

@@ -0,0 +1,103 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// CalculateNodeAffinityPriority prioritizes nodes according to node affinity scheduling preferences
+// indicated in PreferredDuringSchedulingIgnoredDuringExecution. Each time a node match a preferredSchedulingTerm,
+// it will a get an add of preferredSchedulingTerm.Weight. Thus, the more preferredSchedulingTerms
+// the node satisfies and the more the preferredSchedulingTerm that is satisfied weights, the higher
+// score the node gets.
+func CalculateNodeAffinityPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	var affinity *v1.Affinity
+	if priorityMeta, ok := meta.(*priorityMetadata); ok {
+		affinity = priorityMeta.affinity
+	} else {
+		// We couldn't parse metadata - fallback to the podspec.
+		affinity = pod.Spec.Affinity
+	}
+
+	var count int32
+	// A nil element of PreferredDuringSchedulingIgnoredDuringExecution matches no objects.
+	// An element of PreferredDuringSchedulingIgnoredDuringExecution that refers to an
+	// empty PreferredSchedulingTerm matches all objects.
+	if affinity != nil && affinity.NodeAffinity != nil && affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution != nil {
+		// Match PreferredDuringSchedulingIgnoredDuringExecution term by term.
+		for i := range affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution {
+			preferredSchedulingTerm := &affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution[i]
+			if preferredSchedulingTerm.Weight == 0 {
+				continue
+			}
+
+			// TODO: Avoid computing it for all nodes if this becomes a performance problem.
+			nodeSelector, err := v1helper.NodeSelectorRequirementsAsSelector(preferredSchedulingTerm.Preference.MatchExpressions)
+			if err != nil {
+				return schedulerapi.HostPriority{}, err
+			}
+			if nodeSelector.Matches(labels.Set(node.Labels)) {
+				count += preferredSchedulingTerm.Weight
+			}
+		}
+	}
+
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: int(count),
+	}, nil
+}
+
+func CalculateNodeAffinityPriorityReduce(pod *v1.Pod, meta interface{}, nodeNameToInfo map[string]*schedulercache.NodeInfo, result schedulerapi.HostPriorityList) error {
+	var maxCount int
+	for i := range result {
+		if result[i].Score > maxCount {
+			maxCount = result[i].Score
+		}
+	}
+	maxCountFloat := float64(maxCount)
+
+	var fScore float64
+	for i := range result {
+		if maxCount > 0 {
+			fScore = float64(schedulerapi.MaxPriority) * (float64(result[i].Score) / maxCountFloat)
+		} else {
+			fScore = 0
+		}
+		if glog.V(10) {
+			// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+			// not logged. There is visible performance gain from it.
+			glog.Infof("%v -> %v: NodeAffinityPriority, Score: (%d)", pod.Name, result[i].Host, int(fScore))
+		}
+		result[i].Score = int(fScore)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_affinity_test.go

@@ -0,0 +1,179 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestNodeAffinityPriority(t *testing.T) {
+	label1 := map[string]string{"foo": "bar"}
+	label2 := map[string]string{"key": "value"}
+	label3 := map[string]string{"az": "az1"}
+	label4 := map[string]string{"abc": "az11", "def": "az22"}
+	label5 := map[string]string{"foo": "bar", "key": "value", "az": "az1"}
+
+	affinity1 := &v1.Affinity{
+		NodeAffinity: &v1.NodeAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{{
+				Weight: 2,
+				Preference: v1.NodeSelectorTerm{
+					MatchExpressions: []v1.NodeSelectorRequirement{{
+						Key:      "foo",
+						Operator: v1.NodeSelectorOpIn,
+						Values:   []string{"bar"},
+					}},
+				},
+			}},
+		},
+	}
+
+	affinity2 := &v1.Affinity{
+		NodeAffinity: &v1.NodeAffinity{
+			PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{
+				{
+					Weight: 2,
+					Preference: v1.NodeSelectorTerm{
+						MatchExpressions: []v1.NodeSelectorRequirement{
+							{
+								Key:      "foo",
+								Operator: v1.NodeSelectorOpIn,
+								Values:   []string{"bar"},
+							},
+						},
+					},
+				},
+				{
+					Weight: 4,
+					Preference: v1.NodeSelectorTerm{
+						MatchExpressions: []v1.NodeSelectorRequirement{
+							{
+								Key:      "key",
+								Operator: v1.NodeSelectorOpIn,
+								Values:   []string{"value"},
+							},
+						},
+					},
+				},
+				{
+					Weight: 5,
+					Preference: v1.NodeSelectorTerm{
+						MatchExpressions: []v1.NodeSelectorRequirement{
+							{
+								Key:      "foo",
+								Operator: v1.NodeSelectorOpIn,
+								Values:   []string{"bar"},
+							},
+							{
+								Key:      "key",
+								Operator: v1.NodeSelectorOpIn,
+								Values:   []string{"value"},
+							},
+							{
+								Key:      "az",
+								Operator: v1.NodeSelectorOpIn,
+								Values:   []string{"az1"},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	tests := []struct {
+		pod          *v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Annotations: map[string]string{},
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test:         "all machines are same priority as NodeAffinity is nil",
+		},
+		{
+			pod: &v1.Pod{
+				Spec: v1.PodSpec{
+					Affinity: affinity1,
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label4}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test:         "no machine macthes preferred scheduling requirements in NodeAffinity of pod so all machines' priority is zero",
+		},
+		{
+			pod: &v1.Pod{
+				Spec: v1.PodSpec{
+					Affinity: affinity1,
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			test:         "only machine1 matches the preferred scheduling requirements of pod",
+		},
+		{
+			pod: &v1.Pod{
+				Spec: v1.PodSpec{
+					Affinity: affinity2,
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine5", Labels: label5}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine5", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 3}},
+			test:         "all machines matches the preferred scheduling requirements of pod but with different priorities ",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+		nap := priorityFunction(CalculateNodeAffinityPriorityMap, CalculateNodeAffinityPriorityReduce)
+		list, err := nap(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: \nexpected %#v, \ngot      %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_label.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+type NodeLabelPrioritizer struct {
+	label    string
+	presence bool
+}
+
+func NewNodeLabelPriority(label string, presence bool) (algorithm.PriorityMapFunction, algorithm.PriorityReduceFunction) {
+	labelPrioritizer := &NodeLabelPrioritizer{
+		label:    label,
+		presence: presence,
+	}
+	return labelPrioritizer.CalculateNodeLabelPriorityMap, nil
+}
+
+// CalculateNodeLabelPriority checks whether a particular label exists on a node or not, regardless of its value.
+// If presence is true, prioritizes nodes that have the specified label, regardless of value.
+// If presence is false, prioritizes nodes that do not have the specified label.
+func (n *NodeLabelPrioritizer) CalculateNodeLabelPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	exists := labels.Set(node.Labels).Has(n.label)
+	score := 0
+	if (exists && n.presence) || (!exists && !n.presence) {
+		score = schedulerapi.MaxPriority
+	}
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: score,
+	}, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_label_test.go

@@ -0,0 +1,122 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestNewNodeLabelPriority(t *testing.T) {
+	label1 := map[string]string{"foo": "bar"}
+	label2 := map[string]string{"bar": "foo"}
+	label3 := map[string]string{"bar": "baz"}
+	tests := []struct {
+		nodes        []*v1.Node
+		label        string
+		presence     bool
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			label:        "baz",
+			presence:     true,
+			test:         "no match found, presence true",
+		},
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			label:        "baz",
+			presence:     false,
+			test:         "no match found, presence false",
+		},
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			label:        "foo",
+			presence:     true,
+			test:         "one match found, presence true",
+		},
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			label:        "foo",
+			presence:     false,
+			test:         "one match found, presence false",
+		},
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			label:        "bar",
+			presence:     true,
+			test:         "two matches found, presence true",
+		},
+		{
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine1", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
+			},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
+			label:        "bar",
+			presence:     false,
+			test:         "two matches found, presence false",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+		list, err := priorityFunction(NewNodeLabelPriority(test.label, test.presence))(nil, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		// sort the two lists to avoid failures on account of different ordering
+		sort.Sort(test.expectedList)
+		sort.Sort(list)
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_prefer_avoid_pods.go

@@ -0,0 +1,59 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func CalculateNodePreferAvoidPodsPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+
+	controllerRef := priorityutil.GetControllerRef(pod)
+	if controllerRef != nil {
+		// Ignore pods that are owned by other controller than ReplicationController
+		// or ReplicaSet.
+		if controllerRef.Kind != "ReplicationController" && controllerRef.Kind != "ReplicaSet" {
+			controllerRef = nil
+		}
+	}
+	if controllerRef == nil {
+		return schedulerapi.HostPriority{Host: node.Name, Score: schedulerapi.MaxPriority}, nil
+	}
+
+	avoids, err := v1helper.GetAvoidPodsFromNodeAnnotations(node.Annotations)
+	if err != nil {
+		// If we cannot get annotation, assume it's schedulable there.
+		return schedulerapi.HostPriority{Host: node.Name, Score: schedulerapi.MaxPriority}, nil
+	}
+	for i := range avoids.PreferAvoidPods {
+		avoid := &avoids.PreferAvoidPods[i]
+		if avoid.PodSignature.PodController.Kind == controllerRef.Kind && avoid.PodSignature.PodController.UID == controllerRef.UID {
+			return schedulerapi.HostPriority{Host: node.Name, Score: 0}, nil
+		}
+	}
+	return schedulerapi.HostPriority{Host: node.Name, Score: schedulerapi.MaxPriority}, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/node_prefer_avoid_pods_test.go

@@ -0,0 +1,156 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func TestNodePreferAvoidPriority(t *testing.T) {
+	annotations1 := map[string]string{
+		v1.PreferAvoidPodsAnnotationKey: `
+							{
+							    "preferAvoidPods": [
+							        {
+							            "podSignature": {
+							                "podController": {
+							                    "apiVersion": "v1",
+							                    "kind": "ReplicationController",
+							                    "name": "foo",
+							                    "uid": "abcdef123456",
+							                    "controller": true
+							                }
+							            },
+							            "reason": "some reason",
+							            "message": "some message"
+							        }
+							    ]
+							}`,
+	}
+	annotations2 := map[string]string{
+		v1.PreferAvoidPodsAnnotationKey: `
+							{
+							    "preferAvoidPods": [
+							        {
+							            "podSignature": {
+							                "podController": {
+							                    "apiVersion": "v1",
+							                    "kind": "ReplicaSet",
+							                    "name": "foo",
+							                    "uid": "qwert12345",
+							                    "controller": true
+							                }
+							            },
+							            "reason": "some reason",
+							            "message": "some message"
+							        }
+							    ]
+							}`,
+	}
+	testNodes := []*v1.Node{
+		{
+			ObjectMeta: metav1.ObjectMeta{Name: "machine1", Annotations: annotations1},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{Name: "machine2", Annotations: annotations2},
+		},
+		{
+			ObjectMeta: metav1.ObjectMeta{Name: "machine3"},
+		},
+	}
+	trueVar := true
+	tests := []struct {
+		pod          *v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					OwnerReferences: []metav1.OwnerReference{
+						{Kind: "ReplicationController", Name: "foo", UID: "abcdef123456", Controller: &trueVar},
+					},
+				},
+			},
+			nodes:        testNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			test:         "pod managed by ReplicationController should avoid a node, this node get lowest priority score",
+		},
+		{
+			pod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					OwnerReferences: []metav1.OwnerReference{
+						{Kind: "RandomController", Name: "foo", UID: "abcdef123456", Controller: &trueVar},
+					},
+				},
+			},
+			nodes:        testNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			test:         "ownership by random controller should be ignored",
+		},
+		{
+			pod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					OwnerReferences: []metav1.OwnerReference{
+						{Kind: "ReplicationController", Name: "foo", UID: "abcdef123456"},
+					},
+				},
+			},
+			nodes:        testNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			test:         "owner without Controller field set should be ignored",
+		},
+		{
+			pod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					OwnerReferences: []metav1.OwnerReference{
+						{Kind: "ReplicaSet", Name: "foo", UID: "qwert12345", Controller: &trueVar},
+					},
+				},
+			},
+			nodes:        testNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
+			test:         "pod managed by ReplicaSet should avoid a node, this node get lowest priority score",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+		list, err := priorityFunction(CalculateNodePreferAvoidPodsPriorityMap, nil)(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		// sort the two lists to avoid failures on account of different ordering
+		sort.Sort(test.expectedList)
+		sort.Sort(list)
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/selector_spreading.go

@@ -0,0 +1,269 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"sync"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/util/workqueue"
+	utilnode "k8s.io/kubernetes/pkg/util/node"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// When zone information is present, give 2/3 of the weighting to zone spreading, 1/3 to node spreading
+// TODO: Any way to justify this weighting?
+const zoneWeighting float64 = 2.0 / 3.0
+
+type SelectorSpread struct {
+	serviceLister     algorithm.ServiceLister
+	controllerLister  algorithm.ControllerLister
+	replicaSetLister  algorithm.ReplicaSetLister
+	statefulSetLister algorithm.StatefulSetLister
+}
+
+func NewSelectorSpreadPriority(
+	serviceLister algorithm.ServiceLister,
+	controllerLister algorithm.ControllerLister,
+	replicaSetLister algorithm.ReplicaSetLister,
+	statefulSetLister algorithm.StatefulSetLister) algorithm.PriorityFunction {
+	selectorSpread := &SelectorSpread{
+		serviceLister:     serviceLister,
+		controllerLister:  controllerLister,
+		replicaSetLister:  replicaSetLister,
+		statefulSetLister: statefulSetLister,
+	}
+	return selectorSpread.CalculateSpreadPriority
+}
+
+// Returns selectors of services, RCs and RSs matching the given pod.
+func getSelectors(pod *v1.Pod, sl algorithm.ServiceLister, cl algorithm.ControllerLister, rsl algorithm.ReplicaSetLister, ssl algorithm.StatefulSetLister) []labels.Selector {
+	var selectors []labels.Selector
+	if services, err := sl.GetPodServices(pod); err == nil {
+		for _, service := range services {
+			selectors = append(selectors, labels.SelectorFromSet(service.Spec.Selector))
+		}
+	}
+	if rcs, err := cl.GetPodControllers(pod); err == nil {
+		for _, rc := range rcs {
+			selectors = append(selectors, labels.SelectorFromSet(rc.Spec.Selector))
+		}
+	}
+	if rss, err := rsl.GetPodReplicaSets(pod); err == nil {
+		for _, rs := range rss {
+			if selector, err := metav1.LabelSelectorAsSelector(rs.Spec.Selector); err == nil {
+				selectors = append(selectors, selector)
+			}
+		}
+	}
+	if sss, err := ssl.GetPodStatefulSets(pod); err == nil {
+		for _, ss := range sss {
+			if selector, err := metav1.LabelSelectorAsSelector(ss.Spec.Selector); err == nil {
+				selectors = append(selectors, selector)
+			}
+		}
+	}
+	return selectors
+}
+
+func (s *SelectorSpread) getSelectors(pod *v1.Pod) []labels.Selector {
+	return getSelectors(pod, s.serviceLister, s.controllerLister, s.replicaSetLister, s.statefulSetLister)
+}
+
+// CalculateSpreadPriority spreads pods across hosts and zones, considering pods belonging to the same service or replication controller.
+// When a pod is scheduled, it looks for services, RCs or RSs that match the pod, then finds existing pods that match those selectors.
+// It favors nodes that have fewer existing matching pods.
+// i.e. it pushes the scheduler towards a node where there's the smallest number of
+// pods which match the same service, RC or RS selectors as the pod being scheduled.
+// Where zone information is included on the nodes, it favors nodes in zones with fewer existing matching pods.
+func (s *SelectorSpread) CalculateSpreadPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	selectors := s.getSelectors(pod)
+
+	// Count similar pods by node
+	countsByNodeName := make(map[string]float64, len(nodes))
+	countsByZone := make(map[string]float64, 10)
+	maxCountByNodeName := float64(0)
+	countsByNodeNameLock := sync.Mutex{}
+
+	if len(selectors) > 0 {
+		processNodeFunc := func(i int) {
+			nodeName := nodes[i].Name
+			count := float64(0)
+			for _, nodePod := range nodeNameToInfo[nodeName].Pods() {
+				if pod.Namespace != nodePod.Namespace {
+					continue
+				}
+				// When we are replacing a failed pod, we often see the previous
+				// deleted version while scheduling the replacement.
+				// Ignore the previous deleted version for spreading purposes
+				// (it can still be considered for resource restrictions etc.)
+				if nodePod.DeletionTimestamp != nil {
+					glog.V(4).Infof("skipping pending-deleted pod: %s/%s", nodePod.Namespace, nodePod.Name)
+					continue
+				}
+				matches := false
+				for _, selector := range selectors {
+					if selector.Matches(labels.Set(nodePod.ObjectMeta.Labels)) {
+						matches = true
+						break
+					}
+				}
+				if matches {
+					count++
+				}
+			}
+			zoneId := utilnode.GetZoneKey(nodes[i])
+
+			countsByNodeNameLock.Lock()
+			defer countsByNodeNameLock.Unlock()
+			countsByNodeName[nodeName] = count
+			if count > maxCountByNodeName {
+				maxCountByNodeName = count
+			}
+			if zoneId != "" {
+				countsByZone[zoneId] += count
+			}
+		}
+		workqueue.Parallelize(16, len(nodes), processNodeFunc)
+	}
+
+	// Aggregate by-zone information
+	// Compute the maximum number of pods hosted in any zone
+	haveZones := len(countsByZone) != 0
+	maxCountByZone := float64(0)
+	for _, count := range countsByZone {
+		if count > maxCountByZone {
+			maxCountByZone = count
+		}
+	}
+
+	result := make(schedulerapi.HostPriorityList, 0, len(nodes))
+	//score int - scale of 0-maxPriority
+	// 0 being the lowest priority and maxPriority being the highest
+	for _, node := range nodes {
+		// initializing to the default/max node score of maxPriority
+		fScore := float64(schedulerapi.MaxPriority)
+		if maxCountByNodeName > 0 {
+			fScore = float64(schedulerapi.MaxPriority) * ((maxCountByNodeName - countsByNodeName[node.Name]) / maxCountByNodeName)
+		}
+
+		// If there is zone information present, incorporate it
+		if haveZones {
+			zoneId := utilnode.GetZoneKey(node)
+			if zoneId != "" {
+				zoneScore := float64(schedulerapi.MaxPriority) * ((maxCountByZone - countsByZone[zoneId]) / maxCountByZone)
+				fScore = (fScore * (1.0 - zoneWeighting)) + (zoneWeighting * zoneScore)
+			}
+		}
+
+		result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: int(fScore)})
+		if glog.V(10) {
+			// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+			// not logged. There is visible performance gain from it.
+			glog.V(10).Infof(
+				"%v -> %v: SelectorSpreadPriority, Score: (%d)", pod.Name, node.Name, int(fScore),
+			)
+		}
+	}
+	return result, nil
+}
+
+type ServiceAntiAffinity struct {
+	podLister     algorithm.PodLister
+	serviceLister algorithm.ServiceLister
+	label         string
+}
+
+func NewServiceAntiAffinityPriority(podLister algorithm.PodLister, serviceLister algorithm.ServiceLister, label string) algorithm.PriorityFunction {
+	antiAffinity := &ServiceAntiAffinity{
+		podLister:     podLister,
+		serviceLister: serviceLister,
+		label:         label,
+	}
+	return antiAffinity.CalculateAntiAffinityPriority
+}
+
+// Classifies nodes into ones with labels and without labels.
+func (s *ServiceAntiAffinity) getNodeClassificationByLabels(nodes []*v1.Node) (map[string]string, []string) {
+	labeledNodes := map[string]string{}
+	nonLabeledNodes := []string{}
+	for _, node := range nodes {
+		if labels.Set(node.Labels).Has(s.label) {
+			label := labels.Set(node.Labels).Get(s.label)
+			labeledNodes[node.Name] = label
+		} else {
+			nonLabeledNodes = append(nonLabeledNodes, node.Name)
+		}
+	}
+	return labeledNodes, nonLabeledNodes
+}
+
+// CalculateAntiAffinityPriority spreads pods by minimizing the number of pods belonging to the same service
+// on machines with the same value for a particular label.
+// The label to be considered is provided to the struct (ServiceAntiAffinity).
+func (s *ServiceAntiAffinity) CalculateAntiAffinityPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	var nsServicePods []*v1.Pod
+	if services, err := s.serviceLister.GetPodServices(pod); err == nil && len(services) > 0 {
+		// just use the first service and get the other pods within the service
+		// TODO: a separate predicate can be created that tries to handle all services for the pod
+		selector := labels.SelectorFromSet(services[0].Spec.Selector)
+		pods, err := s.podLister.List(selector)
+		if err != nil {
+			return nil, err
+		}
+		// consider only the pods that belong to the same namespace
+		for _, nsPod := range pods {
+			if nsPod.Namespace == pod.Namespace {
+				nsServicePods = append(nsServicePods, nsPod)
+			}
+		}
+	}
+
+	// separate out the nodes that have the label from the ones that don't
+	labeledNodes, nonLabeledNodes := s.getNodeClassificationByLabels(nodes)
+	podCounts := map[string]int{}
+	for _, pod := range nsServicePods {
+		label, exists := labeledNodes[pod.Spec.NodeName]
+		if !exists {
+			continue
+		}
+		podCounts[label]++
+	}
+	numServicePods := len(nsServicePods)
+	result := []schedulerapi.HostPriority{}
+	//score int - scale of 0-maxPriority
+	// 0 being the lowest priority and maxPriority being the highest
+	for node := range labeledNodes {
+		// initializing to the default/max node score of maxPriority
+		fScore := float64(schedulerapi.MaxPriority)
+		if numServicePods > 0 {
+			fScore = float64(schedulerapi.MaxPriority) * (float64(numServicePods-podCounts[labeledNodes[node]]) / float64(numServicePods))
+		}
+		result = append(result, schedulerapi.HostPriority{Host: node, Score: int(fScore)})
+	}
+	// add the open nodes with a score of 0
+	for _, node := range nonLabeledNodes {
+		result = append(result, schedulerapi.HostPriority{Host: node, Score: 0})
+	}
+	return result, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/selector_spreading_test.go

@@ -0,0 +1,780 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	apps "k8s.io/api/apps/v1beta1"
+	"k8s.io/api/core/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedulertesting "k8s.io/kubernetes/plugin/pkg/scheduler/testing"
+)
+
+func controllerRef(kind, name, uid string) []metav1.OwnerReference {
+	// TODO: When ControllerRef will be implemented uncomment code below.
+	return nil
+	//trueVar := true
+	//return []metav1.OwnerReference{
+	//	{Kind: kind, Name: name, UID: types.UID(uid), Controller: &trueVar},
+	//}
+}
+
+func TestSelectorSpreadPriority(t *testing.T) {
+	labels1 := map[string]string{
+		"foo": "bar",
+		"baz": "blah",
+	}
+	labels2 := map[string]string{
+		"bar": "foo",
+		"baz": "blah",
+	}
+	zone1Spec := v1.PodSpec{
+		NodeName: "machine1",
+	}
+	zone2Spec := v1.PodSpec{
+		NodeName: "machine2",
+	}
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []string
+		rcs          []*v1.ReplicationController
+		rss          []*extensions.ReplicaSet
+		services     []*v1.Service
+		sss          []*apps.StatefulSet
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod:          new(v1.Pod),
+			nodes:        []string{"machine1", "machine2"},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "nothing scheduled",
+		},
+		{
+			pod:          &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods:         []*v1.Pod{{Spec: zone1Spec}},
+			nodes:        []string{"machine1", "machine2"},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "no services",
+		},
+		{
+			pod:          &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods:         []*v1.Pod{{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}}},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"key": "value"}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
+			test:         "different services",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "two pods, one service pod",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns1"}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "five pods, one service pod in no namespace",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns1"}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}, ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "four pods, one service pod in default namespace",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns1"}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns2"}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns1"}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}, ObjectMeta: metav1.ObjectMeta{Namespace: "ns1"}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
+			test:         "five pods, one service pod in specific namespace",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "three pods, two service pods on different machines",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 0}},
+			test:         "four pods, three service pods",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"baz": "blah"}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "service with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			},
+			nodes:    []string{"machine1", "machine2"},
+			rcs:      []*v1.ReplicationController{{Spec: v1.ReplicationControllerSpec{Selector: map[string]string{"foo": "bar"}}}},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"baz": "blah"}}}},
+			// "baz=blah" matches both labels1 and labels2, and "foo=bar" matches only labels 1. This means that we assume that we want to
+			// do spreading between all pods. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "service with partial pod label matches with service and replication controller",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			},
+			nodes:    []string{"machine1", "machine2"},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"baz": "blah"}}}},
+			rss:      []*extensions.ReplicaSet{{Spec: extensions.ReplicaSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			// We use ReplicaSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "service with partial pod label matches with service and replica set",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"baz": "blah"}}}},
+			sss:          []*apps.StatefulSet{{Spec: apps.StatefulSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "service with partial pod label matches with service and replica set",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar", "bar": "foo"}, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			},
+			nodes:    []string{"machine1", "machine2"},
+			rcs:      []*v1.ReplicationController{{Spec: v1.ReplicationControllerSpec{Selector: map[string]string{"foo": "bar"}}}},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"bar": "foo"}}}},
+			// Taken together Service and Replication Controller should match all Pods, hence result should be equal to one above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "disjoined service and replication controller should be treated equally",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar", "bar": "foo"}, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			},
+			nodes:    []string{"machine1", "machine2"},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"bar": "foo"}}}},
+			rss:      []*extensions.ReplicaSet{{Spec: extensions.ReplicaSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			// We use ReplicaSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "disjoined service and replica set should be treated equally",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar", "bar": "foo"}, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			services:     []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"bar": "foo"}}}},
+			sss:          []*apps.StatefulSet{{Spec: apps.StatefulSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "disjoined service and replica set should be treated equally",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			},
+			nodes: []string{"machine1", "machine2"},
+			rcs:   []*v1.ReplicationController{{Spec: v1.ReplicationControllerSpec{Selector: map[string]string{"foo": "bar"}}}},
+			// Both Nodes have one pod from the given RC, hence both get 0 score.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "Replication controller with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			},
+			nodes: []string{"machine1", "machine2"},
+			rss:   []*extensions.ReplicaSet{{Spec: extensions.ReplicaSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			// We use ReplicaSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "Replica set with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			},
+			nodes: []string{"machine1", "machine2"},
+			sss:   []*apps.StatefulSet{{Spec: apps.StatefulSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}}}},
+			// We use StatefulSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
+			test:         "StatefulSet with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicationController", "name", "abc123")}},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			rcs:          []*v1.ReplicationController{{Spec: v1.ReplicationControllerSpec{Selector: map[string]string{"baz": "blah"}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "Another replication controller with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("ReplicaSet", "name", "abc123")}},
+			},
+			nodes: []string{"machine1", "machine2"},
+			rss:   []*extensions.ReplicaSet{{Spec: extensions.ReplicaSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"baz": "blah"}}}}},
+			// We use ReplicaSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "Another replication set with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, OwnerReferences: controllerRef("StatefulSet", "name", "abc123")}},
+			},
+			nodes: []string{"machine1", "machine2"},
+			sss:   []*apps.StatefulSet{{Spec: apps.StatefulSetSpec{Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"baz": "blah"}}}}},
+			// We use StatefulSet, instead of ReplicationController. The result should be exactly as above.
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 5}},
+			test:         "Another stateful set with partial pod label matches",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, nil)
+		selectorSpread := SelectorSpread{
+			serviceLister:     schedulertesting.FakeServiceLister(test.services),
+			controllerLister:  schedulertesting.FakeControllerLister(test.rcs),
+			replicaSetLister:  schedulertesting.FakeReplicaSetLister(test.rss),
+			statefulSetLister: schedulertesting.FakeStatefulSetLister(test.sss),
+		}
+		list, err := selectorSpread.CalculateSpreadPriority(test.pod, nodeNameToInfo, makeNodeList(test.nodes))
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}
+
+func buildPod(nodeName string, labels map[string]string, ownerRefs []metav1.OwnerReference) *v1.Pod {
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Labels: labels, OwnerReferences: ownerRefs},
+		Spec:       v1.PodSpec{NodeName: nodeName},
+	}
+}
+
+func TestZoneSelectorSpreadPriority(t *testing.T) {
+	labels1 := map[string]string{
+		"label1": "l1",
+		"baz":    "blah",
+	}
+	labels2 := map[string]string{
+		"label2": "l2",
+		"baz":    "blah",
+	}
+
+	const nodeMachine1Zone1 = "machine1.zone1"
+	const nodeMachine1Zone2 = "machine1.zone2"
+	const nodeMachine2Zone2 = "machine2.zone2"
+	const nodeMachine1Zone3 = "machine1.zone3"
+	const nodeMachine2Zone3 = "machine2.zone3"
+	const nodeMachine3Zone3 = "machine3.zone3"
+
+	buildNodeLabels := func(failureDomain string) map[string]string {
+		labels := map[string]string{
+			kubeletapis.LabelZoneFailureDomain: failureDomain,
+		}
+		return labels
+	}
+	labeledNodes := map[string]map[string]string{
+		nodeMachine1Zone1: buildNodeLabels("zone1"),
+		nodeMachine1Zone2: buildNodeLabels("zone2"),
+		nodeMachine2Zone2: buildNodeLabels("zone2"),
+		nodeMachine1Zone3: buildNodeLabels("zone3"),
+		nodeMachine2Zone3: buildNodeLabels("zone3"),
+		nodeMachine3Zone3: buildNodeLabels("zone3"),
+	}
+
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        []string
+		rcs          []*v1.ReplicationController
+		rss          []*extensions.ReplicaSet
+		services     []*v1.Service
+		sss          []*apps.StatefulSet
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod: new(v1.Pod),
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine3Zone3, Score: schedulerapi.MaxPriority},
+			},
+			test: "nothing scheduled",
+		},
+		{
+			pod:  buildPod("", labels1, nil),
+			pods: []*v1.Pod{buildPod(nodeMachine1Zone1, nil, nil)},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine3Zone3, Score: schedulerapi.MaxPriority},
+			},
+			test: "no services",
+		},
+		{
+			pod:      buildPod("", labels1, nil),
+			pods:     []*v1.Pod{buildPod(nodeMachine1Zone1, labels2, nil)},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"key": "value"}}}},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone2, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine3Zone3, Score: schedulerapi.MaxPriority},
+			},
+			test: "different services",
+		},
+		{
+			pod: buildPod("", labels1, nil),
+			pods: []*v1.Pod{
+				buildPod(nodeMachine1Zone1, labels2, nil),
+				buildPod(nodeMachine1Zone2, labels1, nil),
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone2, Score: 0}, // Already have pod on machine
+				{Host: nodeMachine2Zone2, Score: 3}, // Already have pod in zone
+				{Host: nodeMachine1Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine2Zone3, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine3Zone3, Score: schedulerapi.MaxPriority},
+			},
+			test: "two pods, 1 matching (in z2)",
+		},
+		{
+			pod: buildPod("", labels1, nil),
+			pods: []*v1.Pod{
+				buildPod(nodeMachine1Zone1, labels2, nil),
+				buildPod(nodeMachine1Zone2, labels1, nil),
+				buildPod(nodeMachine2Zone2, labels1, nil),
+				buildPod(nodeMachine1Zone3, labels2, nil),
+				buildPod(nodeMachine2Zone3, labels1, nil),
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority},
+				{Host: nodeMachine1Zone2, Score: 0}, // Pod on node
+				{Host: nodeMachine2Zone2, Score: 0}, // Pod on node
+				{Host: nodeMachine1Zone3, Score: 6}, // Pod in zone
+				{Host: nodeMachine2Zone3, Score: 3}, // Pod on node
+				{Host: nodeMachine3Zone3, Score: 6}, // Pod in zone
+			},
+			test: "five pods, 3 matching (z2=2, z3=1)",
+		},
+		{
+			pod: buildPod("", labels1, nil),
+			pods: []*v1.Pod{
+				buildPod(nodeMachine1Zone1, labels1, nil),
+				buildPod(nodeMachine1Zone2, labels1, nil),
+				buildPod(nodeMachine2Zone2, labels2, nil),
+				buildPod(nodeMachine1Zone3, labels1, nil),
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: 0}, // Pod on node
+				{Host: nodeMachine1Zone2, Score: 0}, // Pod on node
+				{Host: nodeMachine2Zone2, Score: 3}, // Pod in zone
+				{Host: nodeMachine1Zone3, Score: 0}, // Pod on node
+				{Host: nodeMachine2Zone3, Score: 3}, // Pod in zone
+				{Host: nodeMachine3Zone3, Score: 3}, // Pod in zone
+			},
+			test: "four pods, 3 matching (z1=1, z2=1, z3=1)",
+		},
+		{
+			pod: buildPod("", labels1, nil),
+			pods: []*v1.Pod{
+				buildPod(nodeMachine1Zone1, labels1, nil),
+				buildPod(nodeMachine1Zone2, labels1, nil),
+				buildPod(nodeMachine1Zone3, labels1, nil),
+				buildPod(nodeMachine2Zone2, labels2, nil),
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: nodeMachine1Zone1, Score: 0}, // Pod on node
+				{Host: nodeMachine1Zone2, Score: 0}, // Pod on node
+				{Host: nodeMachine2Zone2, Score: 3}, // Pod in zone
+				{Host: nodeMachine1Zone3, Score: 0}, // Pod on node
+				{Host: nodeMachine2Zone3, Score: 3}, // Pod in zone
+				{Host: nodeMachine3Zone3, Score: 3}, // Pod in zone
+			},
+			test: "four pods, 3 matching (z1=1, z2=1, z3=1)",
+		},
+		{
+			pod: buildPod("", labels1, controllerRef("ReplicationController", "name", "abc123")),
+			pods: []*v1.Pod{
+				buildPod(nodeMachine1Zone3, labels1, controllerRef("ReplicationController", "name", "abc123")),
+				buildPod(nodeMachine1Zone2, labels1, controllerRef("ReplicationController", "name", "abc123")),
+				buildPod(nodeMachine1Zone3, labels1, controllerRef("ReplicationController", "name", "abc123")),
+			},
+			rcs: []*v1.ReplicationController{{Spec: v1.ReplicationControllerSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{
+				// Note that because we put two pods on the same node (nodeMachine1Zone3),
+				// the values here are questionable for zone2, in particular for nodeMachine1Zone2.
+				// However they kind of make sense; zone1 is still most-highly favored.
+				// zone3 is in general least favored, and m1.z3 particularly low priority.
+				// We would probably prefer to see a bigger gap between putting a second
+				// pod on m1.z2 and putting a pod on m2.z2, but the ordering is correct.
+				// This is also consistent with what we have already.
+				{Host: nodeMachine1Zone1, Score: schedulerapi.MaxPriority}, // No pods in zone
+				{Host: nodeMachine1Zone2, Score: 5},                        // Pod on node
+				{Host: nodeMachine2Zone2, Score: 6},                        // Pod in zone
+				{Host: nodeMachine1Zone3, Score: 0},                        // Two pods on node
+				{Host: nodeMachine2Zone3, Score: 3},                        // Pod in zone
+				{Host: nodeMachine3Zone3, Score: 3},                        // Pod in zone
+			},
+			test: "Replication controller spreading (z1=0, z2=1, z3=2)",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, nil)
+		selectorSpread := SelectorSpread{
+			serviceLister:     schedulertesting.FakeServiceLister(test.services),
+			controllerLister:  schedulertesting.FakeControllerLister(test.rcs),
+			replicaSetLister:  schedulertesting.FakeReplicaSetLister(test.rss),
+			statefulSetLister: schedulertesting.FakeStatefulSetLister(test.sss),
+		}
+		list, err := selectorSpread.CalculateSpreadPriority(test.pod, nodeNameToInfo, makeLabeledNodeList(labeledNodes))
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		// sort the two lists to avoid failures on account of different ordering
+		sort.Sort(test.expectedList)
+		sort.Sort(list)
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}
+
+func TestZoneSpreadPriority(t *testing.T) {
+	labels1 := map[string]string{
+		"foo": "bar",
+		"baz": "blah",
+	}
+	labels2 := map[string]string{
+		"bar": "foo",
+		"baz": "blah",
+	}
+	zone1 := map[string]string{
+		"zone": "zone1",
+	}
+	zone2 := map[string]string{
+		"zone": "zone2",
+	}
+	nozone := map[string]string{
+		"name": "value",
+	}
+	zone0Spec := v1.PodSpec{
+		NodeName: "machine01",
+	}
+	zone1Spec := v1.PodSpec{
+		NodeName: "machine11",
+	}
+	zone2Spec := v1.PodSpec{
+		NodeName: "machine21",
+	}
+	labeledNodes := map[string]map[string]string{
+		"machine01": nozone, "machine02": nozone,
+		"machine11": zone1, "machine12": zone1,
+		"machine21": zone2, "machine22": zone2,
+	}
+	tests := []struct {
+		pod          *v1.Pod
+		pods         []*v1.Pod
+		nodes        map[string]map[string]string
+		services     []*v1.Service
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		{
+			pod:   new(v1.Pod),
+			nodes: labeledNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: schedulerapi.MaxPriority}, {Host: "machine12", Score: schedulerapi.MaxPriority},
+				{Host: "machine21", Score: schedulerapi.MaxPriority}, {Host: "machine22", Score: schedulerapi.MaxPriority},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "nothing scheduled",
+		},
+		{
+			pod:   &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods:  []*v1.Pod{{Spec: zone1Spec}},
+			nodes: labeledNodes,
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: schedulerapi.MaxPriority}, {Host: "machine12", Score: schedulerapi.MaxPriority},
+				{Host: "machine21", Score: schedulerapi.MaxPriority}, {Host: "machine22", Score: schedulerapi.MaxPriority},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "no services",
+		},
+		{
+			pod:      &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods:     []*v1.Pod{{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}}},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"key": "value"}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: schedulerapi.MaxPriority}, {Host: "machine12", Score: schedulerapi.MaxPriority},
+				{Host: "machine21", Score: schedulerapi.MaxPriority}, {Host: "machine22", Score: schedulerapi.MaxPriority},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "different services",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone0Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: schedulerapi.MaxPriority}, {Host: "machine12", Score: schedulerapi.MaxPriority},
+				{Host: "machine21", Score: 0}, {Host: "machine22", Score: 0},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "three pods, one service pod",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: 5}, {Host: "machine12", Score: 5},
+				{Host: "machine21", Score: 5}, {Host: "machine22", Score: 5},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "three pods, two service pods on different machines",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: metav1.NamespaceDefault}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1, Namespace: "ns1"}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}, ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: 0}, {Host: "machine12", Score: 0},
+				{Host: "machine21", Score: schedulerapi.MaxPriority}, {Host: "machine22", Score: schedulerapi.MaxPriority},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "three service label match pods in different namespaces",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: 6}, {Host: "machine12", Score: 6},
+				{Host: "machine21", Score: 3}, {Host: "machine22", Score: 3},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "four pods, three service pods",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: map[string]string{"baz": "blah"}}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: 3}, {Host: "machine12", Score: 3},
+				{Host: "machine21", Score: 6}, {Host: "machine22", Score: 6},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "service with partial pod label matches",
+		},
+		{
+			pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			pods: []*v1.Pod{
+				{Spec: zone0Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+				{Spec: zone2Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
+			},
+			nodes:    labeledNodes,
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: labels1}}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine11", Score: 7}, {Host: "machine12", Score: 7},
+				{Host: "machine21", Score: 5}, {Host: "machine22", Score: 5},
+				{Host: "machine01", Score: 0}, {Host: "machine02", Score: 0}},
+			test: "service pod on non-zoned node",
+		},
+	}
+
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, nil)
+		zoneSpread := ServiceAntiAffinity{podLister: schedulertesting.FakePodLister(test.pods), serviceLister: schedulertesting.FakeServiceLister(test.services), label: "zone"}
+		list, err := zoneSpread.CalculateAntiAffinityPriority(test.pod, nodeNameToInfo, makeLabeledNodeList(test.nodes))
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		// sort the two lists to avoid failures on account of different ordering
+		sort.Sort(test.expectedList)
+		sort.Sort(list)
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
+		}
+	}
+}
+
+func TestGetNodeClassificationByLabels(t *testing.T) {
+	const machine01 = "machine01"
+	const machine02 = "machine02"
+	const zoneA = "zoneA"
+	zone1 := map[string]string{
+		"zone": zoneA,
+	}
+	labeledNodes := map[string]map[string]string{
+		machine01: zone1,
+	}
+	expectedNonLabeledNodes := []string{machine02}
+	serviceAffinity := ServiceAntiAffinity{label: "zone"}
+	newLabeledNodes, noNonLabeledNodes := serviceAffinity.getNodeClassificationByLabels(makeLabeledNodeList(labeledNodes))
+	noLabeledNodes, newnonLabeledNodes := serviceAffinity.getNodeClassificationByLabels(makeNodeList(expectedNonLabeledNodes))
+	label, _ := newLabeledNodes[machine01]
+	if label != zoneA && len(noNonLabeledNodes) != 0 {
+		t.Errorf("Expected only labeled node with label zoneA and no noNonLabeledNodes")
+	}
+	if len(noLabeledNodes) != 0 && newnonLabeledNodes[0] != machine02 {
+		t.Errorf("Expected only non labled nodes")
+	}
+}
+
+func makeLabeledNodeList(nodeMap map[string]map[string]string) []*v1.Node {
+	nodes := make([]*v1.Node, 0, len(nodeMap))
+	for nodeName, labels := range nodeMap {
+		nodes = append(nodes, &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: nodeName, Labels: labels}})
+	}
+	return nodes
+}
+
+func makeNodeList(nodeNames []string) []*v1.Node {
+	nodes := make([]*v1.Node, 0, len(nodeNames))
+	for _, nodeName := range nodeNames {
+		nodes = append(nodes, &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: nodeName}})
+	}
+	return nodes
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/taint_toleration.go

@@ -0,0 +1,100 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+
+	"github.com/golang/glog"
+)
+
+// CountIntolerableTaintsPreferNoSchedule gives the count of intolerable taints of a pod with effect PreferNoSchedule
+func countIntolerableTaintsPreferNoSchedule(taints []v1.Taint, tolerations []v1.Toleration) (intolerableTaints int) {
+	for _, taint := range taints {
+		// check only on taints that have effect PreferNoSchedule
+		if taint.Effect != v1.TaintEffectPreferNoSchedule {
+			continue
+		}
+
+		if !v1helper.TolerationsTolerateTaint(tolerations, &taint) {
+			intolerableTaints++
+		}
+	}
+	return
+}
+
+// getAllTolerationEffectPreferNoSchedule gets the list of all Tolerations with Effect PreferNoSchedule or with no effect.
+func getAllTolerationPreferNoSchedule(tolerations []v1.Toleration) (tolerationList []v1.Toleration) {
+	for _, toleration := range tolerations {
+		// Empty effect means all effects which includes PreferNoSchedule, so we need to collect it as well.
+		if len(toleration.Effect) == 0 || toleration.Effect == v1.TaintEffectPreferNoSchedule {
+			tolerationList = append(tolerationList, toleration)
+		}
+	}
+	return
+}
+
+// ComputeTaintTolerationPriorityMap prepares the priority list for all the nodes based on the number of intolerable taints on the node
+func ComputeTaintTolerationPriorityMap(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+	// To hold all the tolerations with Effect PreferNoSchedule
+	var tolerationsPreferNoSchedule []v1.Toleration
+	if priorityMeta, ok := meta.(*priorityMetadata); ok {
+		tolerationsPreferNoSchedule = priorityMeta.podTolerations
+
+	} else {
+		tolerationsPreferNoSchedule = getAllTolerationPreferNoSchedule(pod.Spec.Tolerations)
+	}
+
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: countIntolerableTaintsPreferNoSchedule(node.Spec.Taints, tolerationsPreferNoSchedule),
+	}, nil
+}
+
+// ComputeTaintTolerationPriorityReduce calculates the source of each node based on the number of intolerable taints on the node
+func ComputeTaintTolerationPriorityReduce(pod *v1.Pod, meta interface{}, nodeNameToInfo map[string]*schedulercache.NodeInfo, result schedulerapi.HostPriorityList) error {
+	var maxCount int
+	for i := range result {
+		if result[i].Score > maxCount {
+			maxCount = result[i].Score
+		}
+	}
+	maxCountFloat := float64(maxCount)
+
+	for i := range result {
+		fScore := float64(schedulerapi.MaxPriority)
+		if maxCountFloat > 0 {
+			fScore = (1.0 - float64(result[i].Score)/maxCountFloat) * float64(schedulerapi.MaxPriority)
+		}
+		if glog.V(10) {
+			// We explicitly don't do glog.V(10).Infof() to avoid computing all the parameters if this is
+			// not logged. There is visible performance gain from it.
+			glog.Infof("%v -> %v: Taint Toleration Priority, Score: (%d)", pod.Name, result[i].Host, int(fScore))
+		}
+		result[i].Score = int(fScore)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/taint_toleration_test.go

@@ -0,0 +1,241 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func nodeWithTaints(nodeName string, taints []v1.Taint) *v1.Node {
+	return &v1.Node{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: nodeName,
+		},
+		Spec: v1.NodeSpec{
+			Taints: taints,
+		},
+	}
+}
+
+func podWithTolerations(tolerations []v1.Toleration) *v1.Pod {
+	return &v1.Pod{
+		Spec: v1.PodSpec{
+			Tolerations: tolerations,
+		},
+	}
+}
+
+// This function will create a set of nodes and pods and test the priority
+// Nodes with zero,one,two,three,four and hundred taints are created
+// Pods with zero,one,two,three,four and hundred tolerations are created
+
+func TestTaintAndToleration(t *testing.T) {
+	tests := []struct {
+		pod          *v1.Pod
+		nodes        []*v1.Node
+		expectedList schedulerapi.HostPriorityList
+		test         string
+	}{
+		// basic test case
+		{
+			test: "node with taints tolerated by the pod, gets a higher score than those node with intolerable taints",
+			pod: podWithTolerations([]v1.Toleration{{
+				Key:      "foo",
+				Operator: v1.TolerationOpEqual,
+				Value:    "bar",
+				Effect:   v1.TaintEffectPreferNoSchedule,
+			}}),
+			nodes: []*v1.Node{
+				nodeWithTaints("nodeA", []v1.Taint{{
+					Key:    "foo",
+					Value:  "bar",
+					Effect: v1.TaintEffectPreferNoSchedule,
+				}}),
+				nodeWithTaints("nodeB", []v1.Taint{{
+					Key:    "foo",
+					Value:  "blah",
+					Effect: v1.TaintEffectPreferNoSchedule,
+				}}),
+			},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: "nodeA", Score: schedulerapi.MaxPriority},
+				{Host: "nodeB", Score: 0},
+			},
+		},
+		// the count of taints that are tolerated by pod, does not matter.
+		{
+			test: "the nodes that all of their taints are tolerated by the pod, get the same score, no matter how many tolerable taints a node has",
+			pod: podWithTolerations([]v1.Toleration{
+				{
+					Key:      "cpu-type",
+					Operator: v1.TolerationOpEqual,
+					Value:    "arm64",
+					Effect:   v1.TaintEffectPreferNoSchedule,
+				}, {
+					Key:      "disk-type",
+					Operator: v1.TolerationOpEqual,
+					Value:    "ssd",
+					Effect:   v1.TaintEffectPreferNoSchedule,
+				},
+			}),
+			nodes: []*v1.Node{
+				nodeWithTaints("nodeA", []v1.Taint{}),
+				nodeWithTaints("nodeB", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+				nodeWithTaints("nodeC", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					}, {
+						Key:    "disk-type",
+						Value:  "ssd",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+			},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: "nodeA", Score: schedulerapi.MaxPriority},
+				{Host: "nodeB", Score: schedulerapi.MaxPriority},
+				{Host: "nodeC", Score: schedulerapi.MaxPriority},
+			},
+		},
+		// the count of taints on a node that are not tolerated by pod, matters.
+		{
+			test: "the more intolerable taints a node has, the lower score it gets.",
+			pod: podWithTolerations([]v1.Toleration{{
+				Key:      "foo",
+				Operator: v1.TolerationOpEqual,
+				Value:    "bar",
+				Effect:   v1.TaintEffectPreferNoSchedule,
+			}}),
+			nodes: []*v1.Node{
+				nodeWithTaints("nodeA", []v1.Taint{}),
+				nodeWithTaints("nodeB", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+				nodeWithTaints("nodeC", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					}, {
+						Key:    "disk-type",
+						Value:  "ssd",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+			},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: "nodeA", Score: schedulerapi.MaxPriority},
+				{Host: "nodeB", Score: 5},
+				{Host: "nodeC", Score: 0},
+			},
+		},
+		// taints-tolerations priority only takes care about the taints and tolerations that have effect PreferNoSchedule
+		{
+			test: "only taints and tolerations that have effect PreferNoSchedule are checked by taints-tolerations priority function",
+			pod: podWithTolerations([]v1.Toleration{
+				{
+					Key:      "cpu-type",
+					Operator: v1.TolerationOpEqual,
+					Value:    "arm64",
+					Effect:   v1.TaintEffectNoSchedule,
+				}, {
+					Key:      "disk-type",
+					Operator: v1.TolerationOpEqual,
+					Value:    "ssd",
+					Effect:   v1.TaintEffectNoSchedule,
+				},
+			}),
+			nodes: []*v1.Node{
+				nodeWithTaints("nodeA", []v1.Taint{}),
+				nodeWithTaints("nodeB", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectNoSchedule,
+					},
+				}),
+				nodeWithTaints("nodeC", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					}, {
+						Key:    "disk-type",
+						Value:  "ssd",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+			},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: "nodeA", Score: schedulerapi.MaxPriority},
+				{Host: "nodeB", Score: schedulerapi.MaxPriority},
+				{Host: "nodeC", Score: 0},
+			},
+		},
+		{
+			test: "Default behaviour No taints and tolerations, lands on node with no taints",
+			//pod without tolerations
+			pod: podWithTolerations([]v1.Toleration{}),
+			nodes: []*v1.Node{
+				//Node without taints
+				nodeWithTaints("nodeA", []v1.Taint{}),
+				nodeWithTaints("nodeB", []v1.Taint{
+					{
+						Key:    "cpu-type",
+						Value:  "arm64",
+						Effect: v1.TaintEffectPreferNoSchedule,
+					},
+				}),
+			},
+			expectedList: []schedulerapi.HostPriority{
+				{Host: "nodeA", Score: schedulerapi.MaxPriority},
+				{Host: "nodeB", Score: 0},
+			},
+		},
+	}
+	for _, test := range tests {
+		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+		ttp := priorityFunction(ComputeTaintTolerationPriorityMap, ComputeTaintTolerationPriorityReduce)
+		list, err := ttp(test.pod, nodeNameToInfo, test.nodes)
+		if err != nil {
+			t.Errorf("%s, unexpected error: %v", test.test, err)
+		}
+
+		if !reflect.DeepEqual(test.expectedList, list) {
+			t.Errorf("%s,\nexpected:\n\t%+v,\ngot:\n\t%+v", test.test, test.expectedList, list)
+		}
+	}
+
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/test_util.go

@@ -0,0 +1,61 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package priorities
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+func makeNode(node string, milliCPU, memory int64) *v1.Node {
+	return &v1.Node{
+		ObjectMeta: metav1.ObjectMeta{Name: node},
+		Status: v1.NodeStatus{
+			Capacity: v1.ResourceList{
+				v1.ResourceCPU:    *resource.NewMilliQuantity(milliCPU, resource.DecimalSI),
+				v1.ResourceMemory: *resource.NewQuantity(memory, resource.BinarySI),
+			},
+			Allocatable: v1.ResourceList{
+				v1.ResourceCPU:    *resource.NewMilliQuantity(milliCPU, resource.DecimalSI),
+				v1.ResourceMemory: *resource.NewQuantity(memory, resource.BinarySI),
+			},
+		},
+	}
+}
+
+func priorityFunction(mapFn algorithm.PriorityMapFunction, reduceFn algorithm.PriorityReduceFunction) algorithm.PriorityFunction {
+	return func(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+		result := make(schedulerapi.HostPriorityList, 0, len(nodes))
+		for i := range nodes {
+			hostResult, err := mapFn(pod, nil, nodeNameToInfo[nodes[i].Name])
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, hostResult)
+		}
+		if reduceFn != nil {
+			if err := reduceFn(pod, nil, nodeNameToInfo, result); err != nil {
+				return nil, err
+			}
+		}
+		return result, nil
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["topologies_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "non_zero.go",
+        "topologies.go",
+        "util.go",
+    ],
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util/non_zero.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import "k8s.io/api/core/v1"
+
+// For each of these resources, a pod that doesn't request the resource explicitly
+// will be treated as having requested the amount indicated below, for the purpose
+// of computing priority only. This ensures that when scheduling zero-request pods, such
+// pods will not all be scheduled to the machine with the smallest in-use request,
+// and that when scheduling regular pods, such pods will not see zero-request pods as
+// consuming no resources whatsoever. We chose these values to be similar to the
+// resources that we give to cluster addon pods (#10653). But they are pretty arbitrary.
+// As described in #11713, we use request instead of limit to deal with resource requirements.
+const DefaultMilliCpuRequest int64 = 100             // 0.1 core
+const DefaultMemoryRequest int64 = 200 * 1024 * 1024 // 200 MB
+
+// GetNonzeroRequests returns the default resource request if none is found or what is provided on the request
+// TODO: Consider setting default as a fixed fraction of machine capacity (take "capacity v1.ResourceList"
+// as an additional argument here) rather than using constants
+func GetNonzeroRequests(requests *v1.ResourceList) (int64, int64) {
+	var outMilliCPU, outMemory int64
+	// Override if un-set, but not if explicitly set to zero
+	if _, found := (*requests)[v1.ResourceCPU]; !found {
+		outMilliCPU = DefaultMilliCpuRequest
+	} else {
+		outMilliCPU = requests.Cpu().MilliValue()
+	}
+	// Override if un-set, but not if explicitly set to zero
+	if _, found := (*requests)[v1.ResourceMemory]; !found {
+		outMemory = DefaultMemoryRequest
+	} else {
+		outMemory = requests.Memory().Value()
+	}
+	return outMilliCPU, outMemory
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util/topologies.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+// GetNamespacesFromPodAffinityTerm returns a set of names
+// according to the namespaces indicated in podAffinityTerm.
+// If namespaces is empty it considers the given pod's namespace.
+func GetNamespacesFromPodAffinityTerm(pod *v1.Pod, podAffinityTerm *v1.PodAffinityTerm) sets.String {
+	names := sets.String{}
+	if len(podAffinityTerm.Namespaces) == 0 {
+		names.Insert(pod.Namespace)
+	} else {
+		names.Insert(podAffinityTerm.Namespaces...)
+	}
+	return names
+}
+
+// PodMatchesTermsNamespaceAndSelector returns true if the given <pod>
+// matches the namespace and selector defined by <affinityPod>`s <term>.
+func PodMatchesTermsNamespaceAndSelector(pod *v1.Pod, namespaces sets.String, selector labels.Selector) bool {
+	if !namespaces.Has(pod.Namespace) {
+		return false
+	}
+
+	if !selector.Matches(labels.Set(pod.Labels)) {
+		return false
+	}
+	return true
+}
+
+// NodesHaveSameTopologyKey checks if nodeA and nodeB have same label value with given topologyKey as label key.
+// Returns false if topologyKey is empty.
+func NodesHaveSameTopologyKey(nodeA, nodeB *v1.Node, topologyKey string) bool {
+	if len(topologyKey) == 0 {
+		return false
+	}
+
+	if nodeA.Labels == nil || nodeB.Labels == nil {
+		return false
+	}
+
+	nodeALabel, okA := nodeA.Labels[topologyKey]
+	nodeBLabel, okB := nodeB.Labels[topologyKey]
+
+	// If found label in both nodes, check the label
+	if okB && okA {
+		return nodeALabel == nodeBLabel
+	}
+
+	return false
+}
+
+type Topologies struct {
+	DefaultKeys []string
+}
+
+// NodesHaveSameTopologyKey checks if nodeA and nodeB have same label value with given topologyKey as label key.
+func (tps *Topologies) NodesHaveSameTopologyKey(nodeA, nodeB *v1.Node, topologyKey string) bool {
+	return NodesHaveSameTopologyKey(nodeA, nodeB, topologyKey)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util/topologies_test.go

@@ -0,0 +1,124 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestNodesHaveSameTopologyKey(t *testing.T) {
+	tests := []struct {
+		name         string
+		nodeA, nodeB *v1.Node
+		topologyKey  string
+		expected     bool
+	}{
+		{
+			name: "nodeA{'a':'a'} vs. empty label in nodeB",
+			nodeA: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "a",
+					},
+				},
+			},
+			nodeB:       &v1.Node{},
+			expected:    false,
+			topologyKey: "a",
+		},
+		{
+			name: "nodeA{'a':'a'} vs. nodeB{'a':'a'}",
+			nodeA: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "a",
+					},
+				},
+			},
+			nodeB: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "a",
+					},
+				},
+			},
+			expected:    true,
+			topologyKey: "a",
+		},
+		{
+			name: "nodeA{'a':''} vs. empty label in nodeB",
+			nodeA: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "",
+					},
+				},
+			},
+			nodeB:       &v1.Node{},
+			expected:    false,
+			topologyKey: "a",
+		},
+		{
+			name: "nodeA{'a':''} vs. nodeB{'a':''}",
+			nodeA: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "",
+					},
+				},
+			},
+			nodeB: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "",
+					},
+				},
+			},
+			expected:    true,
+			topologyKey: "a",
+		},
+		{
+			name: "nodeA{'a':'a'} vs. nodeB{'a':'a'} by key{'b'}",
+			nodeA: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "a",
+					},
+				},
+			},
+			nodeB: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"a": "a",
+					},
+				},
+			},
+			expected:    false,
+			topologyKey: "b",
+		},
+	}
+
+	for _, test := range tests {
+		got := NodesHaveSameTopologyKey(test.nodeA, test.nodeB, test.topologyKey)
+		if test.expected != got {
+			t.Errorf("%v: expected %t, got %t", test.name, test.expected, got)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util/util.go

@@ -0,0 +1,35 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func GetControllerRef(pod *v1.Pod) *metav1.OwnerReference {
+	if len(pod.OwnerReferences) == 0 {
+		return nil
+	}
+	for i := range pod.OwnerReferences {
+		ref := &pod.OwnerReferences[i]
+		if ref.Controller != nil && *ref.Controller {
+			return ref
+		}
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/scheduler_interface.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithm
+
+import (
+	"k8s.io/api/core/v1"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// SchedulerExtender is an interface for external processes to influence scheduling
+// decisions made by Kubernetes. This is typically needed for resources not directly
+// managed by Kubernetes.
+type SchedulerExtender interface {
+	// 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.
+	Filter(pod *v1.Pod, nodes []*v1.Node, nodeNameToInfo map[string]*schedulercache.NodeInfo) (filteredNodes []*v1.Node, failedNodesMap schedulerapi.FailedNodesMap, err error)
+
+	// Prioritize based on extender-implemented priority functions. The returned scores & weight
+	// are used to compute the weighted score for an extender. The weighted scores are added to
+	// the scores computed  by Kubernetes scheduler. The total scores are used to do the host selection.
+	Prioritize(pod *v1.Pod, nodes []*v1.Node) (hostPriorities *schedulerapi.HostPriorityList, weight int, err error)
+
+	// Bind delegates the action of binding a pod to a node to the extender.
+	Bind(binding *v1.Binding) error
+
+	// IsBinder returns whether this extender is configured for the Bind method.
+	IsBinder() bool
+}
+
+// ScheduleAlgorithm is an interface implemented by things that know how to schedule pods
+// onto machines.
+type ScheduleAlgorithm interface {
+	Schedule(*v1.Pod, NodeLister) (selectedMachine string, err error)
+	// Preempt receives scheduling errors for a pod and tries to create room for
+	// the pod by preempting lower priority pods if possible.
+	// It returns the node where preemption happened, a list of preempted pods, and error if any.
+	Preempt(*v1.Pod, NodeLister, error) (selectedNode *v1.Node, preemptedPods []*v1.Pod, err error)
+	// Predicates() returns a pointer to a map of predicate functions. This is
+	// exposed for testing.
+	Predicates() map[string]FitPredicate
+	// Prioritizers returns a slice of priority config. This is exposed for
+	// testing.
+	Prioritizers() []PriorityConfig
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/scheduler_interface_test.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithm
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+)
+
+// Some functions used by multiple scheduler tests.
+
+type schedulerTester struct {
+	t          *testing.T
+	scheduler  ScheduleAlgorithm
+	nodeLister NodeLister
+}
+
+// Call if you know exactly where pod should get scheduled.
+func (st *schedulerTester) expectSchedule(pod *v1.Pod, expected string) {
+	actual, err := st.scheduler.Schedule(pod, st.nodeLister)
+	if err != nil {
+		st.t.Errorf("Unexpected error %v\nTried to schedule: %#v", err, pod)
+		return
+	}
+	if actual != expected {
+		st.t.Errorf("Unexpected scheduling value: %v, expected %v", actual, expected)
+	}
+}
+
+// Call if you can't predict where pod will be scheduled.
+func (st *schedulerTester) expectSuccess(pod *v1.Pod) {
+	_, err := st.scheduler.Schedule(pod, st.nodeLister)
+	if err != nil {
+		st.t.Errorf("Unexpected error %v\nTried to schedule: %#v", err, pod)
+		return
+	}
+}
+
+// Call if pod should *not* schedule.
+func (st *schedulerTester) expectFailure(pod *v1.Pod) {
+	_, err := st.scheduler.Schedule(pod, st.nodeLister)
+	if err == nil {
+		st.t.Error("Unexpected non-error")
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/types.go

@@ -0,0 +1,164 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithm
+
+import (
+	apps "k8s.io/api/apps/v1beta1"
+	"k8s.io/api/core/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
+	"k8s.io/apimachinery/pkg/labels"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// FitPredicate is a function that indicates if a pod fits into an existing node.
+// The failure information is given by the error.
+type FitPredicate func(pod *v1.Pod, meta PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []PredicateFailureReason, error)
+
+// PriorityMapFunction is a function that computes per-node results for a given node.
+// TODO: Figure out the exact API of this method.
+// TODO: Change interface{} to a specific type.
+type PriorityMapFunction func(pod *v1.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error)
+
+// PriorityReduceFunction is a function that aggregated per-node results and computes
+// final scores for all nodes.
+// TODO: Figure out the exact API of this method.
+// TODO: Change interface{} to a specific type.
+type PriorityReduceFunction func(pod *v1.Pod, meta interface{}, nodeNameToInfo map[string]*schedulercache.NodeInfo, result schedulerapi.HostPriorityList) error
+
+// PredicateMetadataProducer is a function that computes predicate metadata for a given pod.
+type PredicateMetadataProducer func(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) PredicateMetadata
+
+// MetadataProducer is a function that computes metadata for a given pod. This
+// is now used for only for priority functions. For predicates please use PredicateMetadataProducer.
+// TODO: Rename this once we have a specific type for priority metadata producer.
+type MetadataProducer func(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) interface{}
+
+// DEPRECATED
+// Use Map-Reduce pattern for priority functions.
+type PriorityFunction func(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error)
+
+type PriorityConfig struct {
+	Map    PriorityMapFunction
+	Reduce PriorityReduceFunction
+	// TODO: Remove it after migrating all functions to
+	// Map-Reduce pattern.
+	Function PriorityFunction
+	Weight   int
+}
+
+// EmptyPredicateMetadataProducer returns a no-op MetadataProducer type.
+func EmptyPredicateMetadataProducer(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) PredicateMetadata {
+	return nil
+}
+
+// EmptyMetadataProducer returns a no-op MetadataProducer type.
+func EmptyMetadataProducer(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) interface{} {
+	return nil
+}
+
+type PredicateFailureReason interface {
+	GetReason() string
+}
+
+type GetEquivalencePodFunc func(pod *v1.Pod) interface{}
+
+// NodeLister interface represents anything that can list nodes for a scheduler.
+type NodeLister interface {
+	// We explicitly return []*v1.Node, instead of v1.NodeList, to avoid
+	// performing expensive copies that are unneeded.
+	List() ([]*v1.Node, error)
+}
+
+// PodLister interface represents anything that can list pods for a scheduler.
+type PodLister interface {
+	// We explicitly return []*v1.Pod, instead of v1.PodList, to avoid
+	// performing expensive copies that are unneeded.
+	List(labels.Selector) ([]*v1.Pod, error)
+	// This is similar to "List()", but the returned slice does not
+	// contain pods that don't pass `podFilter`.
+	FilteredList(podFilter schedulercache.PodFilter, selector labels.Selector) ([]*v1.Pod, error)
+}
+
+// ServiceLister interface represents anything that can produce a list of services; the list is consumed by a scheduler.
+type ServiceLister interface {
+	// Lists all the services
+	List(labels.Selector) ([]*v1.Service, error)
+	// Gets the services for the given pod
+	GetPodServices(*v1.Pod) ([]*v1.Service, error)
+}
+
+// ControllerLister interface represents anything that can produce a list of ReplicationController; the list is consumed by a scheduler.
+type ControllerLister interface {
+	// Lists all the replication controllers
+	List(labels.Selector) ([]*v1.ReplicationController, error)
+	// Gets the services for the given pod
+	GetPodControllers(*v1.Pod) ([]*v1.ReplicationController, error)
+}
+
+// ReplicaSetLister interface represents anything that can produce a list of ReplicaSet; the list is consumed by a scheduler.
+type ReplicaSetLister interface {
+	// Gets the replicasets for the given pod
+	GetPodReplicaSets(*v1.Pod) ([]*extensions.ReplicaSet, error)
+}
+
+var _ ControllerLister = &EmptyControllerLister{}
+
+// EmptyControllerLister implements ControllerLister on []v1.ReplicationController returning empty data
+type EmptyControllerLister struct{}
+
+// List returns nil
+func (f EmptyControllerLister) List(labels.Selector) ([]*v1.ReplicationController, error) {
+	return nil, nil
+}
+
+// GetPodControllers returns nil
+func (f EmptyControllerLister) GetPodControllers(pod *v1.Pod) (controllers []*v1.ReplicationController, err error) {
+	return nil, nil
+}
+
+var _ ReplicaSetLister = &EmptyReplicaSetLister{}
+
+// EmptyReplicaSetLister implements ReplicaSetLister on []extensions.ReplicaSet returning empty data
+type EmptyReplicaSetLister struct{}
+
+// GetPodReplicaSets returns nil
+func (f EmptyReplicaSetLister) GetPodReplicaSets(pod *v1.Pod) (rss []*extensions.ReplicaSet, err error) {
+	return nil, nil
+}
+
+// StatefulSetLister interface represents anything that can produce a list of StatefulSet; the list is consumed by a scheduler.
+type StatefulSetLister interface {
+	// Gets the StatefulSet for the given pod.
+	GetPodStatefulSets(*v1.Pod) ([]*apps.StatefulSet, error)
+}
+
+var _ StatefulSetLister = &EmptyStatefulSetLister{}
+
+// EmptyStatefulSetLister implements StatefulSetLister on []apps.StatefulSet returning empty data.
+type EmptyStatefulSetLister struct{}
+
+// GetPodStatefulSets of EmptyStatefulSetLister returns nil.
+func (f EmptyStatefulSetLister) GetPodStatefulSets(pod *v1.Pod) (sss []*apps.StatefulSet, err error) {
+	return nil, nil
+}
+
+type PredicateMetadata interface {
+	ShallowCopy() PredicateMetadata
+	AddPod(addedPod *v1.Pod, nodeInfo *schedulercache.NodeInfo) error
+	RemovePod(deletedPod *v1.Pod) error
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/types_test.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithm
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// EmptyMetadataProducer should returns a no-op MetadataProducer type.
+func TestEmptyMetadataProducer(t *testing.T) {
+	fakePod := new(v1.Pod)
+	fakeLabelSelector := labels.SelectorFromSet(labels.Set{"foo": "bar"})
+
+	nodeNameToInfo := map[string]*schedulercache.NodeInfo{
+		"2": schedulercache.NewNodeInfo(fakePod),
+		"1": schedulercache.NewNodeInfo(),
+	}
+	// Test EmptyMetadataProducer
+	metadata := EmptyMetadataProducer(fakePod, nodeNameToInfo)
+	if metadata != nil {
+		t.Errorf("failed to produce empty metadata: got %v, expected nil", metadata)
+	}
+	// Test EmptyControllerLister should return nill
+	controllerLister := EmptyControllerLister{}
+	nilController, nilError := controllerLister.List(fakeLabelSelector)
+	if nilController != nil || nilError != nil {
+		t.Errorf("failed to produce empty controller lister: got %v, expected nil", nilController)
+	}
+	// Test GetPodControllers on empty controller lister should return nill
+	nilController, nilError = controllerLister.GetPodControllers(fakePod)
+	if nilController != nil || nilError != nil {
+		t.Errorf("failed to produce empty controller lister: got %v, expected nil", nilController)
+	}
+	// Test GetPodReplicaSets on empty replica sets should return nill
+	replicaSetLister := EmptyReplicaSetLister{}
+	nilRss, nilErrRss := replicaSetLister.GetPodReplicaSets(fakePod)
+	if nilRss != nil || nilErrRss != nil {
+		t.Errorf("failed to produce empty replicaSetLister: got %v, expected nil", nilRss)
+	}
+
+	// Test GetPodStatefulSets on empty replica sets should return nill
+	statefulSetLister := EmptyStatefulSetLister{}
+	nilSSL, nilErrSSL := statefulSetLister.GetPodStatefulSets(fakePod)
+	if nilSSL != nil || nilErrSSL != nil {
+		t.Errorf("failed to produce empty statefulSetLister: got %v, expected nil", nilSSL)
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/well_known_labels.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithm
+
+const (
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeNotReady would be automatically added by node controller
+	// when node is not ready, and removed when node becomes ready.
+	TaintNodeNotReady = "node.alpha.kubernetes.io/notReady"
+
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeUnreachable would be automatically added by node controller
+	// when node becomes unreachable (corresponding to NodeReady status ConditionUnknown)
+	// and removed when node becomes reachable (NodeReady status ConditionTrue).
+	TaintNodeUnreachable = "node.alpha.kubernetes.io/unreachable"
+
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeOutOfDisk would be automatically added by node controller
+	// when node becomes out of disk, and removed when node has enough disk.
+	TaintNodeOutOfDisk = "node.kubernetes.io/out-of-disk"
+
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeMemoryPressure would be automatically added by node controller
+	// when node has memory pressure, and removed when node has enough memory.
+	TaintNodeMemoryPressure = "node.kubernetes.io/memory-pressure"
+
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeDiskPressure would be automatically added by node controller
+	// when node has disk pressure, and removed when node has enough disk.
+	TaintNodeDiskPressure = "node.kubernetes.io/disk-pressure"
+
+	// When feature-gate for TaintBasedEvictions=true flag is enabled,
+	// TaintNodeNetworkUnavailable would be automatically added by node controller
+	// when node's network is unavailable, and removed when network becomes ready.
+	TaintNodeNetworkUnavailable = "node.kubernetes.io/network-unavailable"
+
+	// When kubelet is started with the "external" cloud provider, then
+	// it sets this taint on a node to mark it as unusable, until a controller
+	// from the cloud-controller-manager intitializes this node, and then removes
+	// the taint
+	TaintExternalCloudProvider = "node.cloudprovider.kubernetes.io/uninitialized"
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/BUILD

@@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["plugins.go"],
+    deps = ["//plugin/pkg/scheduler/algorithmprovider/defaults:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["plugins_test.go"],
+    library = ":go_default_library",
+    deps = ["//plugin/pkg/scheduler/factory:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//plugin/pkg/scheduler/algorithmprovider/defaults:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/defaults/BUILD

@@ -0,0 +1,61 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["defaults.go"],
+    deps = [
+        "//pkg/cloudprovider/providers/aws:go_default_library",
+        "//pkg/features:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities:go_default_library",
+        "//plugin/pkg/scheduler/core:go_default_library",
+        "//plugin/pkg/scheduler/factory:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "compatibility_test.go",
+        "defaults_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/install:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/api/latest:go_default_library",
+        "//plugin/pkg/scheduler/factory:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/util/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/defaults/compatibility_test.go

@@ -0,0 +1,522 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package defaults
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/client-go/informers"
+	clientset "k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	utiltesting "k8s.io/client-go/util/testing"
+	"k8s.io/kubernetes/pkg/api"
+	_ "k8s.io/kubernetes/pkg/api/install"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	latestschedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api/latest"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/factory"
+)
+
+const enableEquivalenceCache = true
+
+func TestCompatibility_v1_Scheduler(t *testing.T) {
+	// Add serialized versions of scheduler config that exercise available options to ensure compatibility between releases
+	schedulerFiles := map[string]struct {
+		JSON           string
+		ExpectedPolicy schedulerapi.Policy
+	}{
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.0": {
+			JSON: `{
+  "kind": "Policy",
+  "apiVersion": "v1",
+  "predicates": [
+    {"name": "MatchNodeSelector"},
+    {"name": "PodFitsResources"},
+    {"name": "PodFitsPorts"},
+    {"name": "NoDiskConflict"},
+    {"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+    {"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}}
+  ],"priorities": [
+    {"name": "LeastRequestedPriority",   "weight": 1},
+    {"name": "ServiceSpreadingPriority", "weight": 2},
+    {"name": "TestServiceAntiAffinity",  "weight": 3, "argument": {"serviceAntiAffinity": {"label": "zone"}}},
+    {"name": "TestLabelPreference",      "weight": 4, "argument": {"labelPreference": {"label": "bar", "presence":true}}}
+  ]
+}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsPorts"},
+					{Name: "NoDiskConflict"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "LeastRequestedPriority", Weight: 1},
+					{Name: "ServiceSpreadingPriority", Weight: 2},
+					{Name: "TestServiceAntiAffinity", Weight: 3, Argument: &schedulerapi.PriorityArgument{ServiceAntiAffinity: &schedulerapi.ServiceAntiAffinity{Label: "zone"}}},
+					{Name: "TestLabelPreference", Weight: 4, Argument: &schedulerapi.PriorityArgument{LabelPreference: &schedulerapi.LabelPreference{Label: "bar", Presence: true}}},
+				},
+			},
+		},
+
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.1": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "PodFitsResources"},
+			{"name": "NoDiskConflict"},
+			{"name": "HostName"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "TestServiceAntiAffinity",  "weight": 3, "argument": {"serviceAntiAffinity": {"label": "zone"}}},
+			{"name": "TestLabelPreference",      "weight": 4, "argument": {"labelPreference": {"label": "bar", "presence":true}}}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "PodFitsResources"},
+					{Name: "NoDiskConflict"},
+					{Name: "HostName"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "TestServiceAntiAffinity", Weight: 3, Argument: &schedulerapi.PriorityArgument{ServiceAntiAffinity: &schedulerapi.ServiceAntiAffinity{Label: "zone"}}},
+					{Name: "TestLabelPreference", Weight: 4, Argument: &schedulerapi.PriorityArgument{LabelPreference: &schedulerapi.LabelPreference{Label: "bar", Presence: true}}},
+				},
+			},
+		},
+
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.2": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsResources"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "HostName"},
+			{"name": "NoDiskConflict"},
+			{"name": "NoVolumeZoneConflict"},
+			{"name": "MaxEBSVolumeCount"},
+			{"name": "MaxGCEPDVolumeCount"},
+			{"name": "MaxAzureDiskVolumeCount"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "NodeAffinityPriority",   "weight": 2},
+			{"name": "ImageLocalityPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "TestServiceAntiAffinity",  "weight": 3, "argument": {"serviceAntiAffinity": {"label": "zone"}}},
+			{"name": "TestLabelPreference",      "weight": 4, "argument": {"labelPreference": {"label": "bar", "presence":true}}}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "HostName"},
+					{Name: "NoDiskConflict"},
+					{Name: "NoVolumeZoneConflict"},
+					{Name: "MaxEBSVolumeCount"},
+					{Name: "MaxGCEPDVolumeCount"},
+					{Name: "MaxAzureDiskVolumeCount"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "NodeAffinityPriority", Weight: 2},
+					{Name: "ImageLocalityPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "TestServiceAntiAffinity", Weight: 3, Argument: &schedulerapi.PriorityArgument{ServiceAntiAffinity: &schedulerapi.ServiceAntiAffinity{Label: "zone"}}},
+					{Name: "TestLabelPreference", Weight: 4, Argument: &schedulerapi.PriorityArgument{LabelPreference: &schedulerapi.LabelPreference{Label: "bar", Presence: true}}},
+				},
+			},
+		},
+
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.3": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsResources"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "HostName"},
+			{"name": "NoDiskConflict"},
+			{"name": "NoVolumeZoneConflict"},
+			{"name": "PodToleratesNodeTaints"},
+			{"name": "CheckNodeMemoryPressure"},
+			{"name": "MaxEBSVolumeCount"},
+			{"name": "MaxGCEPDVolumeCount"},
+			{"name": "MaxAzureDiskVolumeCount"},
+			{"name": "MatchInterPodAffinity"},
+			{"name": "GeneralPredicates"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "ImageLocalityPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "NodeAffinityPriority",   "weight": 2},
+			{"name": "TaintTolerationPriority",   "weight": 2},
+			{"name": "InterPodAffinityPriority",   "weight": 2}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "HostName"},
+					{Name: "NoDiskConflict"},
+					{Name: "NoVolumeZoneConflict"},
+					{Name: "PodToleratesNodeTaints"},
+					{Name: "CheckNodeMemoryPressure"},
+					{Name: "MaxEBSVolumeCount"},
+					{Name: "MaxGCEPDVolumeCount"},
+					{Name: "MaxAzureDiskVolumeCount"},
+					{Name: "MatchInterPodAffinity"},
+					{Name: "GeneralPredicates"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "ImageLocalityPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "NodeAffinityPriority", Weight: 2},
+					{Name: "TaintTolerationPriority", Weight: 2},
+					{Name: "InterPodAffinityPriority", Weight: 2},
+				},
+			},
+		},
+
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.4": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsResources"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "HostName"},
+			{"name": "NoDiskConflict"},
+			{"name": "NoVolumeZoneConflict"},
+			{"name": "PodToleratesNodeTaints"},
+			{"name": "CheckNodeMemoryPressure"},
+			{"name": "CheckNodeDiskPressure"},
+			{"name": "MaxEBSVolumeCount"},
+			{"name": "MaxGCEPDVolumeCount"},
+			{"name": "MaxAzureDiskVolumeCount"},
+			{"name": "MatchInterPodAffinity"},
+			{"name": "GeneralPredicates"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "ImageLocalityPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "NodePreferAvoidPodsPriority",   "weight": 2},
+			{"name": "NodeAffinityPriority",   "weight": 2},
+			{"name": "TaintTolerationPriority",   "weight": 2},
+			{"name": "InterPodAffinityPriority",   "weight": 2},
+			{"name": "MostRequestedPriority",   "weight": 2}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "HostName"},
+					{Name: "NoDiskConflict"},
+					{Name: "NoVolumeZoneConflict"},
+					{Name: "PodToleratesNodeTaints"},
+					{Name: "CheckNodeMemoryPressure"},
+					{Name: "CheckNodeDiskPressure"},
+					{Name: "MaxEBSVolumeCount"},
+					{Name: "MaxGCEPDVolumeCount"},
+					{Name: "MaxAzureDiskVolumeCount"},
+					{Name: "MatchInterPodAffinity"},
+					{Name: "GeneralPredicates"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "ImageLocalityPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "NodePreferAvoidPodsPriority", Weight: 2},
+					{Name: "NodeAffinityPriority", Weight: 2},
+					{Name: "TaintTolerationPriority", Weight: 2},
+					{Name: "InterPodAffinityPriority", Weight: 2},
+					{Name: "MostRequestedPriority", Weight: 2},
+				},
+			},
+		},
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.7": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsResources"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "HostName"},
+			{"name": "NoDiskConflict"},
+			{"name": "NoVolumeZoneConflict"},
+			{"name": "PodToleratesNodeTaints"},
+			{"name": "CheckNodeMemoryPressure"},
+			{"name": "CheckNodeDiskPressure"},
+			{"name": "MaxEBSVolumeCount"},
+			{"name": "MaxGCEPDVolumeCount"},
+			{"name": "MaxAzureDiskVolumeCount"},
+			{"name": "MatchInterPodAffinity"},
+			{"name": "GeneralPredicates"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}},
+			{"name": "NoVolumeNodeConflict"}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "ImageLocalityPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "NodePreferAvoidPodsPriority",   "weight": 2},
+			{"name": "NodeAffinityPriority",   "weight": 2},
+			{"name": "TaintTolerationPriority",   "weight": 2},
+			{"name": "InterPodAffinityPriority",   "weight": 2},
+			{"name": "MostRequestedPriority",   "weight": 2}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "HostName"},
+					{Name: "NoDiskConflict"},
+					{Name: "NoVolumeZoneConflict"},
+					{Name: "PodToleratesNodeTaints"},
+					{Name: "CheckNodeMemoryPressure"},
+					{Name: "CheckNodeDiskPressure"},
+					{Name: "MaxEBSVolumeCount"},
+					{Name: "MaxGCEPDVolumeCount"},
+					{Name: "MaxAzureDiskVolumeCount"},
+					{Name: "MatchInterPodAffinity"},
+					{Name: "GeneralPredicates"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+					{Name: "NoVolumeNodeConflict"},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "ImageLocalityPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "NodePreferAvoidPodsPriority", Weight: 2},
+					{Name: "NodeAffinityPriority", Weight: 2},
+					{Name: "TaintTolerationPriority", Weight: 2},
+					{Name: "InterPodAffinityPriority", Weight: 2},
+					{Name: "MostRequestedPriority", Weight: 2},
+				},
+			},
+		},
+		// Do not change this JSON after the corresponding release has been tagged.
+		// A failure indicates backwards compatibility with the specified release was broken.
+		"1.8": {
+			JSON: `{
+		  "kind": "Policy",
+		  "apiVersion": "v1",
+		  "predicates": [
+			{"name": "MatchNodeSelector"},
+			{"name": "PodFitsResources"},
+			{"name": "PodFitsHostPorts"},
+			{"name": "HostName"},
+			{"name": "NoDiskConflict"},
+			{"name": "NoVolumeZoneConflict"},
+			{"name": "PodToleratesNodeTaints"},
+			{"name": "CheckNodeMemoryPressure"},
+			{"name": "CheckNodeDiskPressure"},
+			{"name": "CheckNodeCondition"},
+			{"name": "MaxEBSVolumeCount"},
+			{"name": "MaxGCEPDVolumeCount"},
+			{"name": "MaxAzureDiskVolumeCount"},
+			{"name": "MatchInterPodAffinity"},
+			{"name": "GeneralPredicates"},
+			{"name": "TestServiceAffinity", "argument": {"serviceAffinity" : {"labels" : ["region"]}}},
+			{"name": "TestLabelsPresence",  "argument": {"labelsPresence"  : {"labels" : ["foo"], "presence":true}}},
+			{"name": "NoVolumeNodeConflict"}
+		  ],"priorities": [
+			{"name": "EqualPriority",   "weight": 2},
+			{"name": "ImageLocalityPriority",   "weight": 2},
+			{"name": "LeastRequestedPriority",   "weight": 2},
+			{"name": "BalancedResourceAllocation",   "weight": 2},
+			{"name": "SelectorSpreadPriority",   "weight": 2},
+			{"name": "NodePreferAvoidPodsPriority",   "weight": 2},
+			{"name": "NodeAffinityPriority",   "weight": 2},
+			{"name": "TaintTolerationPriority",   "weight": 2},
+			{"name": "InterPodAffinityPriority",   "weight": 2},
+			{"name": "MostRequestedPriority",   "weight": 2}
+		  ]
+		}`,
+			ExpectedPolicy: schedulerapi.Policy{
+				Predicates: []schedulerapi.PredicatePolicy{
+					{Name: "MatchNodeSelector"},
+					{Name: "PodFitsResources"},
+					{Name: "PodFitsHostPorts"},
+					{Name: "HostName"},
+					{Name: "NoDiskConflict"},
+					{Name: "NoVolumeZoneConflict"},
+					{Name: "PodToleratesNodeTaints"},
+					{Name: "CheckNodeMemoryPressure"},
+					{Name: "CheckNodeDiskPressure"},
+					{Name: "CheckNodeCondition"},
+					{Name: "MaxEBSVolumeCount"},
+					{Name: "MaxGCEPDVolumeCount"},
+					{Name: "MaxAzureDiskVolumeCount"},
+					{Name: "MatchInterPodAffinity"},
+					{Name: "GeneralPredicates"},
+					{Name: "TestServiceAffinity", Argument: &schedulerapi.PredicateArgument{ServiceAffinity: &schedulerapi.ServiceAffinity{Labels: []string{"region"}}}},
+					{Name: "TestLabelsPresence", Argument: &schedulerapi.PredicateArgument{LabelsPresence: &schedulerapi.LabelsPresence{Labels: []string{"foo"}, Presence: true}}},
+					{Name: "NoVolumeNodeConflict"},
+				},
+				Priorities: []schedulerapi.PriorityPolicy{
+					{Name: "EqualPriority", Weight: 2},
+					{Name: "ImageLocalityPriority", Weight: 2},
+					{Name: "LeastRequestedPriority", Weight: 2},
+					{Name: "BalancedResourceAllocation", Weight: 2},
+					{Name: "SelectorSpreadPriority", Weight: 2},
+					{Name: "NodePreferAvoidPodsPriority", Weight: 2},
+					{Name: "NodeAffinityPriority", Weight: 2},
+					{Name: "TaintTolerationPriority", Weight: 2},
+					{Name: "InterPodAffinityPriority", Weight: 2},
+					{Name: "MostRequestedPriority", Weight: 2},
+				},
+			},
+		},
+	}
+
+	registeredPredicates := sets.NewString(factory.ListRegisteredFitPredicates()...)
+	registeredPriorities := sets.NewString(factory.ListRegisteredPriorityFunctions()...)
+	seenPredicates := sets.NewString()
+	seenPriorities := sets.NewString()
+
+	for v, tc := range schedulerFiles {
+		fmt.Printf("%s: Testing scheduler config\n", v)
+
+		policy := schedulerapi.Policy{}
+		if err := runtime.DecodeInto(latestschedulerapi.Codec, []byte(tc.JSON), &policy); err != nil {
+			t.Errorf("%s: Error decoding: %v", v, err)
+			continue
+		}
+		for _, predicate := range policy.Predicates {
+			seenPredicates.Insert(predicate.Name)
+		}
+		for _, priority := range policy.Priorities {
+			seenPriorities.Insert(priority.Name)
+		}
+		if !reflect.DeepEqual(policy, tc.ExpectedPolicy) {
+			t.Errorf("%s: Expected:\n\t%#v\nGot:\n\t%#v", v, tc.ExpectedPolicy, policy)
+		}
+
+		handler := utiltesting.FakeHandler{
+			StatusCode:   500,
+			ResponseBody: "",
+			T:            t,
+		}
+		server := httptest.NewServer(&handler)
+		defer server.Close()
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+		informerFactory := informers.NewSharedInformerFactory(client, 0)
+
+		if _, err := factory.NewConfigFactory(
+			"some-scheduler-name",
+			client,
+			informerFactory.Core().V1().Nodes(),
+			informerFactory.Core().V1().Pods(),
+			informerFactory.Core().V1().PersistentVolumes(),
+			informerFactory.Core().V1().PersistentVolumeClaims(),
+			informerFactory.Core().V1().ReplicationControllers(),
+			informerFactory.Extensions().V1beta1().ReplicaSets(),
+			informerFactory.Apps().V1beta1().StatefulSets(),
+			informerFactory.Core().V1().Services(),
+			v1.DefaultHardPodAffinitySymmetricWeight,
+			enableEquivalenceCache,
+		).CreateFromConfig(policy); err != nil {
+			t.Errorf("%s: Error constructing: %v", v, err)
+			continue
+		}
+	}
+
+	if !seenPredicates.HasAll(registeredPredicates.List()...) {
+		t.Errorf("Registered predicates are missing from compatibility test (add to test stanza for version currently in development): %#v", registeredPredicates.Difference(seenPredicates).List())
+	}
+	if !seenPriorities.HasAll(registeredPriorities.List()...) {
+		t.Errorf("Registered priorities are missing from compatibility test (add to test stanza for version currently in development): %#v", registeredPriorities.Difference(seenPriorities).List())
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/defaults/defaults.go

@@ -0,0 +1,272 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package defaults
+
+import (
+	"os"
+	"strconv"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/aws"
+	"k8s.io/kubernetes/pkg/features"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/core"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/factory"
+
+	"github.com/golang/glog"
+)
+
+const (
+	// 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
+	// ClusterAutoscalerProvider defines the default autoscaler provider
+	ClusterAutoscalerProvider = "ClusterAutoscalerProvider"
+	// StatefulSetKind defines the name of 'StatefulSet' kind
+	StatefulSetKind = "StatefulSet"
+	// KubeMaxPDVols defines the maximum number of PD Volumes per kubelet
+	KubeMaxPDVols = "KUBE_MAX_PD_VOLS"
+)
+
+func init() {
+	// Register functions that extract metadata used by predicates and priorities computations.
+	factory.RegisterPredicateMetadataProducerFactory(
+		func(args factory.PluginFactoryArgs) algorithm.PredicateMetadataProducer {
+			return predicates.NewPredicateMetadataFactory(args.PodLister)
+		})
+	factory.RegisterPriorityMetadataProducerFactory(
+		func(args factory.PluginFactoryArgs) algorithm.MetadataProducer {
+			return priorities.PriorityMetadata
+		})
+
+	// Registers algorithm providers. By default we use 'DefaultProvider', but user can specify one to be used
+	// by specifying flag.
+	factory.RegisterAlgorithmProvider(factory.DefaultProvider, defaultPredicates(), defaultPriorities())
+	// Cluster autoscaler friendly scheduling algorithm.
+	factory.RegisterAlgorithmProvider(ClusterAutoscalerProvider, defaultPredicates(),
+		copyAndReplace(defaultPriorities(), "LeastRequestedPriority", "MostRequestedPriority"))
+
+	// IMPORTANT NOTES for predicate developers:
+	// We are using cached predicate result for pods belonging to the same equivalence class.
+	// So when implementing a new predicate, you are expected to check whether the result
+	// of your predicate function can be affected by related API object change (ADD/DELETE/UPDATE).
+	// If yes, you are expected to invalidate the cached predicate result for related API object change.
+	// For example:
+	// https://github.com/kubernetes/kubernetes/blob/36a218e/plugin/pkg/scheduler/factory/factory.go#L422
+
+	// Registers predicates and priorities that are not enabled by default, but user can pick when creating his
+	// own set of priorities/predicates.
+
+	// PodFitsPorts has been replaced by PodFitsHostPorts for better user understanding.
+	// For backwards compatibility with 1.0, PodFitsPorts is registered as well.
+	factory.RegisterFitPredicate("PodFitsPorts", predicates.PodFitsHostPorts)
+	// Fit is defined based on the absence of port conflicts.
+	// This predicate is actually a default predicate, because it is invoked from
+	// predicates.GeneralPredicates()
+	factory.RegisterFitPredicate("PodFitsHostPorts", predicates.PodFitsHostPorts)
+	// Fit is determined by resource availability.
+	// This predicate is actually a default predicate, because it is invoked from
+	// predicates.GeneralPredicates()
+	factory.RegisterFitPredicate("PodFitsResources", predicates.PodFitsResources)
+	// Fit is determined by the presence of the Host parameter and a string match
+	// This predicate is actually a default predicate, because it is invoked from
+	// predicates.GeneralPredicates()
+	factory.RegisterFitPredicate("HostName", predicates.PodFitsHost)
+	// Fit is determined by node selector query.
+	factory.RegisterFitPredicate("MatchNodeSelector", predicates.PodMatchNodeSelector)
+
+	// Use equivalence class to speed up predicates & priorities
+	factory.RegisterGetEquivalencePodFunction(predicates.GetEquivalencePod)
+
+	// ServiceSpreadingPriority is a priority config factory that spreads pods by minimizing
+	// the number of pods (belonging to the same service) on the same node.
+	// Register the factory so that it's available, but do not include it as part of the default priorities
+	// Largely replaced by "SelectorSpreadPriority", but registered for backward compatibility with 1.0
+	factory.RegisterPriorityConfigFactory(
+		"ServiceSpreadingPriority",
+		factory.PriorityConfigFactory{
+			Function: func(args factory.PluginFactoryArgs) algorithm.PriorityFunction {
+				return priorities.NewSelectorSpreadPriority(args.ServiceLister, algorithm.EmptyControllerLister{}, algorithm.EmptyReplicaSetLister{}, algorithm.EmptyStatefulSetLister{})
+			},
+			Weight: 1,
+		},
+	)
+
+	// EqualPriority is a prioritizer function that gives an equal weight of one to all nodes
+	// Register the priority function so that its available
+	// but do not include it as part of the default priorities
+	factory.RegisterPriorityFunction2("EqualPriority", core.EqualPriorityMap, nil, 1)
+	// ImageLocalityPriority prioritizes nodes based on locality of images requested by a pod. Nodes with larger size
+	// of already-installed packages required by the pod will be preferred over nodes with no already-installed
+	// packages required by the pod or a small total size of already-installed packages required by the pod.
+	factory.RegisterPriorityFunction2("ImageLocalityPriority", priorities.ImageLocalityPriorityMap, nil, 1)
+	// Optional, cluster-autoscaler friendly priority function - give used nodes higher priority.
+	factory.RegisterPriorityFunction2("MostRequestedPriority", priorities.MostRequestedPriorityMap, nil, 1)
+}
+
+func defaultPredicates() sets.String {
+	predSet := sets.NewString(
+		// Fit is determined by volume zone requirements.
+		factory.RegisterFitPredicateFactory(
+			"NoVolumeZoneConflict",
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				return predicates.NewVolumeZonePredicate(args.PVInfo, args.PVCInfo)
+			},
+		),
+		// Fit is determined by whether or not there would be too many AWS EBS volumes attached to the node
+		factory.RegisterFitPredicateFactory(
+			"MaxEBSVolumeCount",
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				// TODO: allow for generically parameterized scheduler predicates, because this is a bit ugly
+				maxVols := getMaxVols(aws.DefaultMaxEBSVolumes)
+				return predicates.NewMaxPDVolumeCountPredicate(predicates.EBSVolumeFilter, maxVols, args.PVInfo, args.PVCInfo)
+			},
+		),
+		// Fit is determined by whether or not there would be too many GCE PD volumes attached to the node
+		factory.RegisterFitPredicateFactory(
+			"MaxGCEPDVolumeCount",
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				// TODO: allow for generically parameterized scheduler predicates, because this is a bit ugly
+				maxVols := getMaxVols(DefaultMaxGCEPDVolumes)
+				return predicates.NewMaxPDVolumeCountPredicate(predicates.GCEPDVolumeFilter, maxVols, args.PVInfo, args.PVCInfo)
+			},
+		),
+		// Fit is determined by whether or not there would be too many Azure Disk volumes attached to the node
+		factory.RegisterFitPredicateFactory(
+			"MaxAzureDiskVolumeCount",
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				// TODO: allow for generically parameterized scheduler predicates, because this is a bit ugly
+				maxVols := getMaxVols(DefaultMaxAzureDiskVolumes)
+				return predicates.NewMaxPDVolumeCountPredicate(predicates.AzureDiskVolumeFilter, maxVols, args.PVInfo, args.PVCInfo)
+			},
+		),
+		// Fit is determined by inter-pod affinity.
+		factory.RegisterFitPredicateFactory(
+			predicates.MatchInterPodAffinity,
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				return predicates.NewPodAffinityPredicate(args.NodeInfo, args.PodLister)
+			},
+		),
+
+		// Fit is determined by non-conflicting disk volumes.
+		factory.RegisterFitPredicate("NoDiskConflict", predicates.NoDiskConflict),
+
+		// GeneralPredicates are the predicates that are enforced by all Kubernetes components
+		// (e.g. kubelet and all schedulers)
+		factory.RegisterFitPredicate("GeneralPredicates", predicates.GeneralPredicates),
+
+		// Fit is determined by node memory pressure condition.
+		factory.RegisterFitPredicate("CheckNodeMemoryPressure", predicates.CheckNodeMemoryPressurePredicate),
+
+		// Fit is determined by node disk pressure condition.
+		factory.RegisterFitPredicate("CheckNodeDiskPressure", predicates.CheckNodeDiskPressurePredicate),
+
+		// Fit is determined by volume zone requirements.
+		factory.RegisterFitPredicateFactory(
+			"NoVolumeNodeConflict",
+			func(args factory.PluginFactoryArgs) algorithm.FitPredicate {
+				return predicates.NewVolumeNodePredicate(args.PVInfo, args.PVCInfo, nil)
+			},
+		),
+	)
+
+	if utilfeature.DefaultFeatureGate.Enabled(features.TaintNodesByCondition) {
+		// Fit is determined based on whether a pod can tolerate all of the node's taints
+		predSet.Insert(factory.RegisterMandatoryFitPredicate("PodToleratesNodeTaints", predicates.PodToleratesNodeTaints))
+		glog.Warningf("TaintNodesByCondition is enabled, PodToleratesNodeTaints predicate is mandatory")
+	} else {
+		// Fit is determied by node condtions: not ready, network unavailable and out of disk.
+		predSet.Insert(factory.RegisterMandatoryFitPredicate("CheckNodeCondition", predicates.CheckNodeConditionPredicate))
+		// Fit is determined based on whether a pod can tolerate all of the node's taints
+		predSet.Insert(factory.RegisterFitPredicate("PodToleratesNodeTaints", predicates.PodToleratesNodeTaints))
+	}
+
+	return predSet
+}
+
+func defaultPriorities() sets.String {
+	return sets.NewString(
+		// spreads pods by minimizing the number of pods (belonging to the same service or replication controller) on the same node.
+		factory.RegisterPriorityConfigFactory(
+			"SelectorSpreadPriority",
+			factory.PriorityConfigFactory{
+				Function: func(args factory.PluginFactoryArgs) algorithm.PriorityFunction {
+					return priorities.NewSelectorSpreadPriority(args.ServiceLister, args.ControllerLister, args.ReplicaSetLister, args.StatefulSetLister)
+				},
+				Weight: 1,
+			},
+		),
+		// pods should be placed in the same topological domain (e.g. same node, same rack, same zone, same power domain, etc.)
+		// as some other pods, or, conversely, should not be placed in the same topological domain as some other pods.
+		factory.RegisterPriorityConfigFactory(
+			"InterPodAffinityPriority",
+			factory.PriorityConfigFactory{
+				Function: func(args factory.PluginFactoryArgs) algorithm.PriorityFunction {
+					return priorities.NewInterPodAffinityPriority(args.NodeInfo, args.NodeLister, args.PodLister, args.HardPodAffinitySymmetricWeight)
+				},
+				Weight: 1,
+			},
+		),
+
+		// Prioritize nodes by least requested utilization.
+		factory.RegisterPriorityFunction2("LeastRequestedPriority", priorities.LeastRequestedPriorityMap, nil, 1),
+
+		// Prioritizes nodes to help achieve balanced resource usage
+		factory.RegisterPriorityFunction2("BalancedResourceAllocation", priorities.BalancedResourceAllocationMap, nil, 1),
+
+		// Set this weight large enough to override all other priority functions.
+		// TODO: Figure out a better way to do this, maybe at same time as fixing #24720.
+		factory.RegisterPriorityFunction2("NodePreferAvoidPodsPriority", priorities.CalculateNodePreferAvoidPodsPriorityMap, nil, 10000),
+
+		// Prioritizes nodes that have labels matching NodeAffinity
+		factory.RegisterPriorityFunction2("NodeAffinityPriority", priorities.CalculateNodeAffinityPriorityMap, priorities.CalculateNodeAffinityPriorityReduce, 1),
+
+		// Prioritizes nodes that marked with taint which pod can tolerate.
+		factory.RegisterPriorityFunction2("TaintTolerationPriority", priorities.ComputeTaintTolerationPriorityMap, priorities.ComputeTaintTolerationPriorityReduce, 1),
+	)
+}
+
+// getMaxVols checks the max PD volumes environment variable, otherwise returning a default value
+func getMaxVols(defaultVal int) int {
+	if rawMaxVols := os.Getenv(KubeMaxPDVols); rawMaxVols != "" {
+		if parsedMaxVols, err := strconv.Atoi(rawMaxVols); err != nil {
+			glog.Errorf("Unable to parse maximum PD volumes value, using default of %v: %v", defaultVal, err)
+		} else if parsedMaxVols <= 0 {
+			glog.Errorf("Maximum PD volumes must be a positive value, using default of %v", defaultVal)
+		} else {
+			return parsedMaxVols
+		}
+	}
+
+	return defaultVal
+}
+
+func copyAndReplace(set sets.String, replaceWhat, replaceWith string) sets.String {
+	result := sets.NewString(set.List()...)
+	if result.Has(replaceWhat) {
+		result.Delete(replaceWhat)
+		result.Insert(replaceWith)
+	}
+	return result
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/defaults/defaults_test.go

@@ -0,0 +1,156 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package defaults
+
+import (
+	"k8s.io/apimachinery/pkg/util/sets"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"os"
+	"testing"
+)
+
+func TestGetMaxVols(t *testing.T) {
+	previousValue := os.Getenv(KubeMaxPDVols)
+	defaultValue := 39
+
+	tests := []struct {
+		rawMaxVols string
+		expected   int
+		test       string
+	}{
+		{
+			rawMaxVols: "invalid",
+			expected:   defaultValue,
+			test:       "Unable to parse maximum PD volumes value, using default value",
+		},
+		{
+			rawMaxVols: "-2",
+			expected:   defaultValue,
+			test:       "Maximum PD volumes must be a positive value, using default value",
+		},
+		{
+			rawMaxVols: "40",
+			expected:   40,
+			test:       "Parse maximum PD volumes value from env",
+		},
+	}
+
+	for _, test := range tests {
+		os.Setenv(KubeMaxPDVols, test.rawMaxVols)
+		result := getMaxVols(defaultValue)
+		if result != test.expected {
+			t.Errorf("%s: expected %v got %v", test.test, test.expected, result)
+		}
+	}
+
+	os.Unsetenv(KubeMaxPDVols)
+	if previousValue != "" {
+		os.Setenv(KubeMaxPDVols, previousValue)
+	}
+}
+
+func TestCopyAndReplace(t *testing.T) {
+	testCases := []struct {
+		set         sets.String
+		replaceWhat string
+		replaceWith string
+		expected    sets.String
+	}{
+		{
+			set:         sets.String{"A": sets.Empty{}, "B": sets.Empty{}},
+			replaceWhat: "A",
+			replaceWith: "C",
+			expected:    sets.String{"B": sets.Empty{}, "C": sets.Empty{}},
+		},
+		{
+			set:         sets.String{"A": sets.Empty{}, "B": sets.Empty{}},
+			replaceWhat: "D",
+			replaceWith: "C",
+			expected:    sets.String{"A": sets.Empty{}, "B": sets.Empty{}},
+		},
+	}
+	for _, testCase := range testCases {
+		result := copyAndReplace(testCase.set, testCase.replaceWhat, testCase.replaceWith)
+		if !result.Equal(testCase.expected) {
+			t.Errorf("expected %v got %v", testCase.expected, result)
+		}
+	}
+}
+
+func TestDefaultPriorities(t *testing.T) {
+	result := sets.NewString(
+		"SelectorSpreadPriority",
+		"InterPodAffinityPriority",
+		"LeastRequestedPriority",
+		"BalancedResourceAllocation",
+		"NodePreferAvoidPodsPriority",
+		"NodeAffinityPriority",
+		"TaintTolerationPriority")
+	if expected := defaultPriorities(); !result.Equal(expected) {
+		t.Errorf("expected %v got %v", expected, result)
+	}
+}
+
+func TestDefaultPredicates(t *testing.T) {
+	testCases := []struct {
+		actionFunc  func(value string) error
+		actionParam string
+		expected    sets.String
+	}{
+		{
+			actionFunc:  utilfeature.DefaultFeatureGate.Set,
+			actionParam: "TaintNodesByCondition=true",
+			expected: sets.NewString(
+				"NoVolumeZoneConflict",
+				"MaxEBSVolumeCount",
+				"MaxGCEPDVolumeCount",
+				"MaxAzureDiskVolumeCount",
+				"MatchInterPodAffinity",
+				"NoDiskConflict",
+				"GeneralPredicates",
+				"CheckNodeMemoryPressure",
+				"CheckNodeDiskPressure",
+				"NoVolumeNodeConflict",
+				"PodToleratesNodeTaints",
+			),
+		},
+		{
+			actionFunc:  utilfeature.DefaultFeatureGate.Set,
+			actionParam: "TaintNodesByCondition=false",
+			expected: sets.NewString(
+				"NoVolumeZoneConflict",
+				"MaxEBSVolumeCount",
+				"MaxGCEPDVolumeCount",
+				"MaxAzureDiskVolumeCount",
+				"MatchInterPodAffinity",
+				"NoDiskConflict",
+				"GeneralPredicates",
+				"CheckNodeMemoryPressure",
+				"CheckNodeDiskPressure",
+				"NoVolumeNodeConflict",
+				"CheckNodeCondition",
+				"PodToleratesNodeTaints",
+			),
+		},
+	}
+	for _, testCase := range testCases {
+		testCase.actionFunc(testCase.actionParam)
+		if result := defaultPredicates(); !result.Equal(testCase.expected) {
+			t.Errorf("expected %v got %v", testCase.expected, result)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/plugins.go

@@ -0,0 +1,22 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithmprovider
+
+import (
+	// Import defaults of algorithmprovider for initialization.
+	_ "k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/defaults"
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/algorithmprovider/plugins_test.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package algorithmprovider
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/plugin/pkg/scheduler/factory"
+)
+
+var (
+	algorithmProviderNames = []string{
+		factory.DefaultProvider,
+	}
+)
+
+func TestDefaultConfigExists(t *testing.T) {
+	p, err := factory.GetAlgorithmProvider(factory.DefaultProvider)
+	if err != nil {
+		t.Errorf("error retrieving default provider: %v", err)
+	}
+	if p == nil {
+		t.Error("algorithm provider config should not be nil")
+	}
+	if len(p.FitPredicateKeys) == 0 {
+		t.Error("default algorithm provider shouldn't have 0 fit predicates")
+	}
+}
+
+func TestAlgorithmProviders(t *testing.T) {
+	for _, pn := range algorithmProviderNames {
+		p, err := factory.GetAlgorithmProvider(pn)
+		if err != nil {
+			t.Errorf("error retrieving '%s' provider: %v", pn, err)
+			break
+		}
+		if len(p.PriorityFunctionKeys) == 0 {
+			t.Errorf("%s algorithm provider shouldn't have 0 priority functions", pn)
+		}
+		for _, pf := range p.PriorityFunctionKeys.List() {
+			if !factory.IsPriorityFunctionRegistered(pf) {
+				t.Errorf("priority function %s is not registered but is used in the %s algorithm provider", pf, pn)
+			}
+		}
+		for _, fp := range p.FitPredicateKeys.List() {
+			if !factory.IsFitPredicateRegistered(fp) {
+				t.Errorf("fit predicate %s is not registered but is used in the %s algorithm provider", fp, pn)
+			}
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "register.go",
+        "types.go",
+        "zz_generated.deepcopy.go",
+    ],
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//plugin/pkg/scheduler/api/latest:all-srcs",
+        "//plugin/pkg/scheduler/api/v1:all-srcs",
+        "//plugin/pkg/scheduler/api/validation:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// +k8s:deepcopy-gen=package,register
+
+// Package api contains scheduler plugin API objects.
+package api // import "k8s.io/kubernetes/plugin/pkg/scheduler/api"

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/latest/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["latest.go"],
+    deps = [
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/api/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer/json:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer/versioning:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/latest/latest.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package latest
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/json"
+	"k8s.io/apimachinery/pkg/runtime/serializer/versioning"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	_ "k8s.io/kubernetes/plugin/pkg/scheduler/api/v1"
+)
+
+// Version is the string that represents the current external default version.
+const Version = "v1"
+
+// OldestVersion is the string that represents the oldest server version supported.
+const OldestVersion = "v1"
+
+// Versions is the list of versions that are recognized in code. The order provided
+// may be assumed to be least feature rich to most feature rich, and clients may
+// choose to prefer the latter items in the list over the former items when presented
+// with a set of versions to choose.
+var Versions = []string{"v1"}
+
+// Codec is the default codec for serializing input that should use
+// the latest supported version. It supports JSON by default.
+var Codec runtime.Codec
+
+func init() {
+	jsonSerializer := json.NewSerializer(json.DefaultMetaFactory, api.Scheme, api.Scheme, true)
+	Codec = versioning.NewDefaultingCodecForScheme(
+		api.Scheme,
+		jsonSerializer,
+		jsonSerializer,
+		schema.GroupVersion{Version: Version},
+		runtime.InternalGroupVersioner,
+	)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/register.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
+// TODO: remove this, scheduler should not have its own scheme.
+var Scheme = runtime.NewScheme()
+
+// SchemeGroupVersion is group version used to register these objects
+// TODO this should be in the "scheduler" group
+var SchemeGroupVersion = schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+func init() {
+	if err := addKnownTypes(Scheme); err != nil {
+		// Programmer error.
+		panic(err)
+	}
+}
+
+func addKnownTypes(scheme *runtime.Scheme) error {
+	if err := scheme.AddIgnoredConversionType(&metav1.TypeMeta{}, &metav1.TypeMeta{}); err != nil {
+		return err
+	}
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&Policy{},
+	)
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/types.go

@@ -0,0 +1,227 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import (
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	restclient "k8s.io/client-go/rest"
+)
+
+const (
+	MaxUint          = ^uint(0)
+	MaxInt           = int(MaxUint >> 1)
+	MaxTotalPriority = MaxInt
+	MaxPriority      = 10
+	MaxWeight        = MaxInt / MaxPriority
+)
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+type Policy struct {
+	metav1.TypeMeta
+	// Holds the information to configure the fit predicate functions
+	Predicates []PredicatePolicy
+	// Holds the information to configure the priority functions
+	Priorities []PriorityPolicy
+	// Holds the information to communicate with the extender(s)
+	ExtenderConfigs []ExtenderConfig
+	// RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule
+	// corresponding to every RequiredDuringScheduling affinity rule.
+	// HardPodAffinitySymmetricWeight represents the weight of implicit PreferredDuringScheduling affinity rule, in the range 1-100.
+	HardPodAffinitySymmetricWeight int
+}
+
+type PredicatePolicy struct {
+	// Identifier of the predicate policy
+	// For a custom predicate, the name can be user-defined
+	// For the Kubernetes provided predicates, the name is the identifier of the pre-defined predicate
+	Name string
+	// Holds the parameters to configure the given predicate
+	Argument *PredicateArgument
+}
+
+type PriorityPolicy struct {
+	// Identifier of the priority policy
+	// For a custom priority, the name can be user-defined
+	// For the Kubernetes provided priority functions, the name is the identifier of the pre-defined priority function
+	Name string
+	// The numeric multiplier for the node scores that the priority function generates
+	// The weight should be a positive integer
+	Weight int
+	// Holds the parameters to configure the given priority function
+	Argument *PriorityArgument
+}
+
+// Represents the arguments that the different types of predicates take
+// Only one of its members may be specified
+type PredicateArgument struct {
+	// The predicate that provides affinity for pods belonging to a service
+	// It uses a label to identify nodes that belong to the same "group"
+	ServiceAffinity *ServiceAffinity
+	// The predicate that checks whether a particular node has a certain label
+	// defined or not, regardless of value
+	LabelsPresence *LabelsPresence
+}
+
+// Represents the arguments that the different types of priorities take.
+// Only one of its members may be specified
+type PriorityArgument struct {
+	// The priority function that ensures a good spread (anti-affinity) for pods belonging to a service
+	// It uses a label to identify nodes that belong to the same "group"
+	ServiceAntiAffinity *ServiceAntiAffinity
+	// The priority function that checks whether a particular node has a certain label
+	// defined or not, regardless of value
+	LabelPreference *LabelPreference
+}
+
+// Holds the parameters that are used to configure the corresponding predicate
+type ServiceAffinity struct {
+	// The list of labels that identify node "groups"
+	// All of the labels should match for the node to be considered a fit for hosting the pod
+	Labels []string
+}
+
+// Holds the parameters that are used to configure the corresponding predicate
+type LabelsPresence struct {
+	// The list of labels that identify node "groups"
+	// All of the labels should be either present (or absent) for the node to be considered a fit for hosting the pod
+	Labels []string
+	// The boolean flag that indicates whether the labels should be present or absent from the node
+	Presence bool
+}
+
+// Holds the parameters that are used to configure the corresponding priority function
+type ServiceAntiAffinity struct {
+	// Used to identify node "groups"
+	Label string
+}
+
+// Holds the parameters that are used to configure the corresponding priority function
+type LabelPreference struct {
+	// Used to identify node "groups"
+	Label string
+	// This is a boolean flag
+	// If true, higher priority is given to nodes that have the label
+	// If false, higher priority is given to nodes that do not have the label
+	Presence bool
+}
+
+// Holds the parameters used to communicate with the extender. If a verb is unspecified/empty,
+// it is assumed that the extender chose not to provide that extension.
+type ExtenderConfig struct {
+	// URLPrefix at which the extender is available
+	URLPrefix string
+	// Verb for the filter call, empty if not supported. This verb is appended to the URLPrefix when issuing the filter call to extender.
+	FilterVerb string
+	// Verb for the prioritize call, empty if not supported. This verb is appended to the URLPrefix when issuing the prioritize call to extender.
+	PrioritizeVerb string
+	// The numeric multiplier for the node scores that the prioritize call generates.
+	// The weight should be a positive integer
+	Weight int
+	// Verb for the bind call, empty if not supported. This verb is appended to the URLPrefix when issuing the bind call to extender.
+	// If this method is implemented by the extender, it is the extender's responsibility to bind the pod to apiserver. Only one extender
+	// can implement this function.
+	BindVerb string
+	// EnableHttps specifies whether https should be used to communicate with the extender
+	EnableHttps bool
+	// TLSConfig specifies the transport layer security config
+	TLSConfig *restclient.TLSClientConfig
+	// HTTPTimeout specifies the timeout duration for a call to the extender. Filter timeout fails the scheduling of the pod. Prioritize
+	// timeout is ignored, k8s/other extenders priorities are used to select the node.
+	HTTPTimeout time.Duration
+	// NodeCacheCapable specifies that the extender is capable of caching node information,
+	// so the scheduler should only send minimal information about the eligible nodes
+	// assuming that the extender already cached full details of all nodes in the cluster
+	NodeCacheCapable bool
+}
+
+// ExtenderArgs represents the arguments needed by the extender to filter/prioritize
+// nodes for a pod.
+type ExtenderArgs struct {
+	// Pod being scheduled
+	Pod v1.Pod
+	// List of candidate nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == false
+	Nodes *v1.NodeList
+	// List of candidate node names where the pod can be scheduled; to be
+	// populated only if ExtenderConfig.NodeCacheCapable == true
+	NodeNames *[]string
+}
+
+// FailedNodesMap represents the filtered out nodes, with node names and failure messages
+type FailedNodesMap map[string]string
+
+// ExtenderFilterResult represents the results of a filter call to an extender
+type ExtenderFilterResult struct {
+	// Filtered set of nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == false
+	Nodes *v1.NodeList
+	// Filtered set of nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == true
+	NodeNames *[]string
+	// Filtered out nodes where the pod can't be scheduled and the failure messages
+	FailedNodes FailedNodesMap
+	// Error message indicating failure
+	Error string
+}
+
+// ExtenderBindingArgs represents the arguments to an extender for binding a pod to a node.
+type ExtenderBindingArgs struct {
+	// PodName is the name of the pod being bound
+	PodName string
+	// PodNamespace is the namespace of the pod being bound
+	PodNamespace string
+	// PodUID is the UID of the pod being bound
+	PodUID types.UID
+	// Node selected by the scheduler
+	Node string
+}
+
+// ExtenderBindingResult represents the result of binding of a pod to a node from an extender.
+type ExtenderBindingResult struct {
+	// Error message indicating failure
+	Error string
+}
+
+// HostPriority represents the priority of scheduling to a particular host, higher priority is better.
+type HostPriority struct {
+	// Name of the host
+	Host string
+	// Score associated with the host
+	Score int
+}
+
+type HostPriorityList []HostPriority
+
+func (h HostPriorityList) Len() int {
+	return len(h)
+}
+
+func (h HostPriorityList) Less(i, j int) bool {
+	if h[i].Score == h[j].Score {
+		return h[i].Host < h[j].Host
+	}
+	return h[i].Score < h[j].Score
+}
+
+func (h HostPriorityList) Swap(i, j int) {
+	h[i], h[j] = h[j], h[i]
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/v1/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "register.go",
+        "types.go",
+        "zz_generated.deepcopy.go",
+    ],
+    deps = [
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/v1/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// +k8s:deepcopy-gen=package,register
+
+// Package v1 contains scheduler plugin API objects.
+package v1 // import "k8s.io/kubernetes/plugin/pkg/scheduler/api/v1"

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/v1/register.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/api"
+)
+
+// SchemeGroupVersion is group version used to register these objects
+// TODO this should be in the "scheduler" group
+var SchemeGroupVersion = schema.GroupVersion{Group: "", Version: "v1"}
+
+func init() {
+	if err := addKnownTypes(api.Scheme); err != nil {
+		// Programmer error.
+		panic(err)
+	}
+}
+
+var (
+	// TODO: move SchemeBuilder with zz_generated.deepcopy.go to k8s.io/api.
+	// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
+	SchemeBuilder      runtime.SchemeBuilder
+	localSchemeBuilder = &SchemeBuilder
+	AddToScheme        = localSchemeBuilder.AddToScheme
+)
+
+func init() {
+	// We only register manually written functions here. The registration of the
+	// generated functions takes place in the generated files. The separation
+	// makes the code compile even when the generated files are missing.
+	localSchemeBuilder.Register(addKnownTypes)
+}
+
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&Policy{},
+	)
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/v1/types.go

@@ -0,0 +1,219 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	"time"
+
+	apiv1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	restclient "k8s.io/client-go/rest"
+)
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+type Policy struct {
+	metav1.TypeMeta `json:",inline"`
+	// Holds the information to configure the fit predicate functions
+	Predicates []PredicatePolicy `json:"predicates"`
+	// Holds the information to configure the priority functions
+	Priorities []PriorityPolicy `json:"priorities"`
+	// Holds the information to communicate with the extender(s)
+	ExtenderConfigs []ExtenderConfig `json:"extenders"`
+	// RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule
+	// corresponding to every RequiredDuringScheduling affinity rule.
+	// HardPodAffinitySymmetricWeight represents the weight of implicit PreferredDuringScheduling affinity rule, in the range 1-100.
+	HardPodAffinitySymmetricWeight int `json:"hardPodAffinitySymmetricWeight"`
+}
+
+type PredicatePolicy struct {
+	// Identifier of the predicate policy
+	// For a custom predicate, the name can be user-defined
+	// For the Kubernetes provided predicates, the name is the identifier of the pre-defined predicate
+	Name string `json:"name"`
+	// Holds the parameters to configure the given predicate
+	Argument *PredicateArgument `json:"argument"`
+}
+
+type PriorityPolicy struct {
+	// Identifier of the priority policy
+	// For a custom priority, the name can be user-defined
+	// For the Kubernetes provided priority functions, the name is the identifier of the pre-defined priority function
+	Name string `json:"name"`
+	// The numeric multiplier for the node scores that the priority function generates
+	// The weight should be non-zero and can be a positive or a negative integer
+	Weight int `json:"weight"`
+	// Holds the parameters to configure the given priority function
+	Argument *PriorityArgument `json:"argument"`
+}
+
+// Represents the arguments that the different types of predicates take
+// Only one of its members may be specified
+type PredicateArgument struct {
+	// The predicate that provides affinity for pods belonging to a service
+	// It uses a label to identify nodes that belong to the same "group"
+	ServiceAffinity *ServiceAffinity `json:"serviceAffinity"`
+	// The predicate that checks whether a particular node has a certain label
+	// defined or not, regardless of value
+	LabelsPresence *LabelsPresence `json:"labelsPresence"`
+}
+
+// Represents the arguments that the different types of priorities take.
+// Only one of its members may be specified
+type PriorityArgument struct {
+	// The priority function that ensures a good spread (anti-affinity) for pods belonging to a service
+	// It uses a label to identify nodes that belong to the same "group"
+	ServiceAntiAffinity *ServiceAntiAffinity `json:"serviceAntiAffinity"`
+	// The priority function that checks whether a particular node has a certain label
+	// defined or not, regardless of value
+	LabelPreference *LabelPreference `json:"labelPreference"`
+}
+
+// Holds the parameters that are used to configure the corresponding predicate
+type ServiceAffinity struct {
+	// The list of labels that identify node "groups"
+	// All of the labels should match for the node to be considered a fit for hosting the pod
+	Labels []string `json:"labels"`
+}
+
+// Holds the parameters that are used to configure the corresponding predicate
+type LabelsPresence struct {
+	// The list of labels that identify node "groups"
+	// All of the labels should be either present (or absent) for the node to be considered a fit for hosting the pod
+	Labels []string `json:"labels"`
+	// The boolean flag that indicates whether the labels should be present or absent from the node
+	Presence bool `json:"presence"`
+}
+
+// Holds the parameters that are used to configure the corresponding priority function
+type ServiceAntiAffinity struct {
+	// Used to identify node "groups"
+	Label string `json:"label"`
+}
+
+// Holds the parameters that are used to configure the corresponding priority function
+type LabelPreference struct {
+	// Used to identify node "groups"
+	Label string `json:"label"`
+	// This is a boolean flag
+	// If true, higher priority is given to nodes that have the label
+	// If false, higher priority is given to nodes that do not have the label
+	Presence bool `json:"presence"`
+}
+
+// Holds the parameters used to communicate with the extender. If a verb is unspecified/empty,
+// it is assumed that the extender chose not to provide that extension.
+type ExtenderConfig struct {
+	// URLPrefix at which the extender is available
+	URLPrefix string `json:"urlPrefix"`
+	// Verb for the filter call, empty if not supported. This verb is appended to the URLPrefix when issuing the filter call to extender.
+	FilterVerb string `json:"filterVerb,omitempty"`
+	// Verb for the prioritize call, empty if not supported. This verb is appended to the URLPrefix when issuing the prioritize call to extender.
+	PrioritizeVerb string `json:"prioritizeVerb,omitempty"`
+	// The numeric multiplier for the node scores that the prioritize call generates.
+	// The weight should be a positive integer
+	Weight int `json:"weight,omitempty"`
+	// Verb for the bind call, empty if not supported. This verb is appended to the URLPrefix when issuing the bind call to extender.
+	// If this method is implemented by the extender, it is the extender's responsibility to bind the pod to apiserver. Only one extender
+	// can implement this function.
+	BindVerb string
+	// EnableHttps specifies whether https should be used to communicate with the extender
+	EnableHttps bool `json:"enableHttps,omitempty"`
+	// TLSConfig specifies the transport layer security config
+	TLSConfig *restclient.TLSClientConfig `json:"tlsConfig,omitempty"`
+	// HTTPTimeout specifies the timeout duration for a call to the extender. Filter timeout fails the scheduling of the pod. Prioritize
+	// timeout is ignored, k8s/other extenders priorities are used to select the node.
+	HTTPTimeout time.Duration `json:"httpTimeout,omitempty"`
+	// NodeCacheCapable specifies that the extender is capable of caching node information,
+	// so the scheduler should only send minimal information about the eligible nodes
+	// assuming that the extender already cached full details of all nodes in the cluster
+	NodeCacheCapable bool `json:"nodeCacheCapable,omitempty"`
+}
+
+// ExtenderArgs represents the arguments needed by the extender to filter/prioritize
+// nodes for a pod.
+type ExtenderArgs struct {
+	// Pod being scheduled
+	Pod apiv1.Pod `json:"pod"`
+	// List of candidate nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == false
+	Nodes *apiv1.NodeList `json:"nodes,omitempty"`
+	// List of candidate node names where the pod can be scheduled; to be
+	// populated only if ExtenderConfig.NodeCacheCapable == true
+	NodeNames *[]string `json:"nodenames,omitempty"`
+}
+
+// FailedNodesMap represents the filtered out nodes, with node names and failure messages
+type FailedNodesMap map[string]string
+
+// ExtenderFilterResult represents the results of a filter call to an extender
+type ExtenderFilterResult struct {
+	// Filtered set of nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == false
+	Nodes *apiv1.NodeList `json:"nodes,omitempty"`
+	// Filtered set of nodes where the pod can be scheduled; to be populated
+	// only if ExtenderConfig.NodeCacheCapable == true
+	NodeNames *[]string `json:"nodenames,omitempty"`
+	// Filtered out nodes where the pod can't be scheduled and the failure messages
+	FailedNodes FailedNodesMap `json:"failedNodes,omitempty"`
+	// Error message indicating failure
+	Error string `json:"error,omitempty"`
+}
+
+// ExtenderBindingArgs represents the arguments to an extender for binding a pod to a node.
+type ExtenderBindingArgs struct {
+	// PodName is the name of the pod being bound
+	PodName string
+	// PodNamespace is the namespace of the pod being bound
+	PodNamespace string
+	// PodUID is the UID of the pod being bound
+	PodUID types.UID
+	// Node selected by the scheduler
+	Node string
+}
+
+// ExtenderBindingResult represents the result of binding of a pod to a node from an extender.
+type ExtenderBindingResult struct {
+	// Error message indicating failure
+	Error string
+}
+
+// HostPriority represents the priority of scheduling to a particular host, higher priority is better.
+type HostPriority struct {
+	// Name of the host
+	Host string `json:"host"`
+	// Score associated with the host
+	Score int `json:"score"`
+}
+
+type HostPriorityList []HostPriority
+
+func (h HostPriorityList) Len() int {
+	return len(h)
+}
+
+func (h HostPriorityList) Less(i, j int) bool {
+	if h[i].Score == h[j].Score {
+		return h[i].Host < h[j].Host
+	}
+	return h[i].Score < h[j].Score
+}
+
+func (h HostPriorityList) Swap(i, j int) {
+	h[i], h[j] = h[j], h[i]
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/v1/zz_generated.deepcopy.go

@@ -0,0 +1,498 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package v1
+
+import (
+	core_v1 "k8s.io/api/core/v1"
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	rest "k8s.io/client-go/rest"
+	reflect "reflect"
+)
+
+func init() {
+	SchemeBuilder.Register(RegisterDeepCopies)
+}
+
+// RegisterDeepCopies adds deep-copy functions to the given scheme. Public
+// to allow building arbitrary schemes.
+//
+// Deprecated: deepcopy registration will go away when static deepcopy is fully implemented.
+func RegisterDeepCopies(scheme *runtime.Scheme) error {
+	return scheme.AddGeneratedDeepCopyFuncs(
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderArgs).DeepCopyInto(out.(*ExtenderArgs))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderArgs{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderBindingArgs).DeepCopyInto(out.(*ExtenderBindingArgs))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderBindingArgs{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderBindingResult).DeepCopyInto(out.(*ExtenderBindingResult))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderBindingResult{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderConfig).DeepCopyInto(out.(*ExtenderConfig))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderConfig{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderFilterResult).DeepCopyInto(out.(*ExtenderFilterResult))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderFilterResult{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*HostPriority).DeepCopyInto(out.(*HostPriority))
+			return nil
+		}, InType: reflect.TypeOf(&HostPriority{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*LabelPreference).DeepCopyInto(out.(*LabelPreference))
+			return nil
+		}, InType: reflect.TypeOf(&LabelPreference{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*LabelsPresence).DeepCopyInto(out.(*LabelsPresence))
+			return nil
+		}, InType: reflect.TypeOf(&LabelsPresence{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Policy).DeepCopyInto(out.(*Policy))
+			return nil
+		}, InType: reflect.TypeOf(&Policy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PredicateArgument).DeepCopyInto(out.(*PredicateArgument))
+			return nil
+		}, InType: reflect.TypeOf(&PredicateArgument{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PredicatePolicy).DeepCopyInto(out.(*PredicatePolicy))
+			return nil
+		}, InType: reflect.TypeOf(&PredicatePolicy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PriorityArgument).DeepCopyInto(out.(*PriorityArgument))
+			return nil
+		}, InType: reflect.TypeOf(&PriorityArgument{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PriorityPolicy).DeepCopyInto(out.(*PriorityPolicy))
+			return nil
+		}, InType: reflect.TypeOf(&PriorityPolicy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ServiceAffinity).DeepCopyInto(out.(*ServiceAffinity))
+			return nil
+		}, InType: reflect.TypeOf(&ServiceAffinity{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ServiceAntiAffinity).DeepCopyInto(out.(*ServiceAntiAffinity))
+			return nil
+		}, InType: reflect.TypeOf(&ServiceAntiAffinity{})},
+	)
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderArgs) DeepCopyInto(out *ExtenderArgs) {
+	*out = *in
+	in.Pod.DeepCopyInto(&out.Pod)
+	if in.Nodes != nil {
+		in, out := &in.Nodes, &out.Nodes
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(core_v1.NodeList)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.NodeNames != nil {
+		in, out := &in.NodeNames, &out.NodeNames
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new([]string)
+			if **in != nil {
+				in, out := *in, *out
+				*out = make([]string, len(*in))
+				copy(*out, *in)
+			}
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderArgs.
+func (in *ExtenderArgs) DeepCopy() *ExtenderArgs {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderArgs)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderBindingArgs) DeepCopyInto(out *ExtenderBindingArgs) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderBindingArgs.
+func (in *ExtenderBindingArgs) DeepCopy() *ExtenderBindingArgs {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderBindingArgs)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderBindingResult) DeepCopyInto(out *ExtenderBindingResult) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderBindingResult.
+func (in *ExtenderBindingResult) DeepCopy() *ExtenderBindingResult {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderBindingResult)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderConfig) DeepCopyInto(out *ExtenderConfig) {
+	*out = *in
+	if in.TLSConfig != nil {
+		in, out := &in.TLSConfig, &out.TLSConfig
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(rest.TLSClientConfig)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderConfig.
+func (in *ExtenderConfig) DeepCopy() *ExtenderConfig {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderConfig)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderFilterResult) DeepCopyInto(out *ExtenderFilterResult) {
+	*out = *in
+	if in.Nodes != nil {
+		in, out := &in.Nodes, &out.Nodes
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(core_v1.NodeList)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.NodeNames != nil {
+		in, out := &in.NodeNames, &out.NodeNames
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new([]string)
+			if **in != nil {
+				in, out := *in, *out
+				*out = make([]string, len(*in))
+				copy(*out, *in)
+			}
+		}
+	}
+	if in.FailedNodes != nil {
+		in, out := &in.FailedNodes, &out.FailedNodes
+		*out = make(FailedNodesMap, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderFilterResult.
+func (in *ExtenderFilterResult) DeepCopy() *ExtenderFilterResult {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderFilterResult)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HostPriority) DeepCopyInto(out *HostPriority) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HostPriority.
+func (in *HostPriority) DeepCopy() *HostPriority {
+	if in == nil {
+		return nil
+	}
+	out := new(HostPriority)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LabelPreference) DeepCopyInto(out *LabelPreference) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LabelPreference.
+func (in *LabelPreference) DeepCopy() *LabelPreference {
+	if in == nil {
+		return nil
+	}
+	out := new(LabelPreference)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LabelsPresence) DeepCopyInto(out *LabelsPresence) {
+	*out = *in
+	if in.Labels != nil {
+		in, out := &in.Labels, &out.Labels
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LabelsPresence.
+func (in *LabelsPresence) DeepCopy() *LabelsPresence {
+	if in == nil {
+		return nil
+	}
+	out := new(LabelsPresence)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Policy) DeepCopyInto(out *Policy) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	if in.Predicates != nil {
+		in, out := &in.Predicates, &out.Predicates
+		*out = make([]PredicatePolicy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Priorities != nil {
+		in, out := &in.Priorities, &out.Priorities
+		*out = make([]PriorityPolicy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.ExtenderConfigs != nil {
+		in, out := &in.ExtenderConfigs, &out.ExtenderConfigs
+		*out = make([]ExtenderConfig, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Policy.
+func (in *Policy) DeepCopy() *Policy {
+	if in == nil {
+		return nil
+	}
+	out := new(Policy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Policy) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PredicateArgument) DeepCopyInto(out *PredicateArgument) {
+	*out = *in
+	if in.ServiceAffinity != nil {
+		in, out := &in.ServiceAffinity, &out.ServiceAffinity
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(ServiceAffinity)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.LabelsPresence != nil {
+		in, out := &in.LabelsPresence, &out.LabelsPresence
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(LabelsPresence)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PredicateArgument.
+func (in *PredicateArgument) DeepCopy() *PredicateArgument {
+	if in == nil {
+		return nil
+	}
+	out := new(PredicateArgument)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PredicatePolicy) DeepCopyInto(out *PredicatePolicy) {
+	*out = *in
+	if in.Argument != nil {
+		in, out := &in.Argument, &out.Argument
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(PredicateArgument)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PredicatePolicy.
+func (in *PredicatePolicy) DeepCopy() *PredicatePolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(PredicatePolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PriorityArgument) DeepCopyInto(out *PriorityArgument) {
+	*out = *in
+	if in.ServiceAntiAffinity != nil {
+		in, out := &in.ServiceAntiAffinity, &out.ServiceAntiAffinity
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(ServiceAntiAffinity)
+			**out = **in
+		}
+	}
+	if in.LabelPreference != nil {
+		in, out := &in.LabelPreference, &out.LabelPreference
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(LabelPreference)
+			**out = **in
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityArgument.
+func (in *PriorityArgument) DeepCopy() *PriorityArgument {
+	if in == nil {
+		return nil
+	}
+	out := new(PriorityArgument)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PriorityPolicy) DeepCopyInto(out *PriorityPolicy) {
+	*out = *in
+	if in.Argument != nil {
+		in, out := &in.Argument, &out.Argument
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(PriorityArgument)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityPolicy.
+func (in *PriorityPolicy) DeepCopy() *PriorityPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(PriorityPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServiceAffinity) DeepCopyInto(out *ServiceAffinity) {
+	*out = *in
+	if in.Labels != nil {
+		in, out := &in.Labels, &out.Labels
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAffinity.
+func (in *ServiceAffinity) DeepCopy() *ServiceAffinity {
+	if in == nil {
+		return nil
+	}
+	out := new(ServiceAffinity)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServiceAntiAffinity) DeepCopyInto(out *ServiceAntiAffinity) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAntiAffinity.
+func (in *ServiceAntiAffinity) DeepCopy() *ServiceAntiAffinity {
+	if in == nil {
+		return nil
+	}
+	out := new(ServiceAntiAffinity)
+	in.DeepCopyInto(out)
+	return out
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/validation/BUILD

@@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["validation.go"],
+    deps = [
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["validation_test.go"],
+    library = ":go_default_library",
+    deps = ["//plugin/pkg/scheduler/api:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/validation/validation.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package validation
+
+import (
+	"fmt"
+
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+)
+
+// ValidatePolicy checks for errors in the Config
+// It does not return early so that it can find as many errors as possible
+func ValidatePolicy(policy schedulerapi.Policy) error {
+	var validationErrors []error
+
+	for _, priority := range policy.Priorities {
+		if priority.Weight <= 0 || priority.Weight >= schedulerapi.MaxWeight {
+			validationErrors = append(validationErrors, fmt.Errorf("Priority %s should have a positive weight applied to it or it has overflown", priority.Name))
+		}
+	}
+
+	binders := 0
+	for _, extender := range policy.ExtenderConfigs {
+		if extender.Weight <= 0 {
+			validationErrors = append(validationErrors, fmt.Errorf("Priority for extender %s should have a positive weight applied to it", extender.URLPrefix))
+		}
+		if extender.BindVerb != "" {
+			binders++
+		}
+	}
+	if binders > 1 {
+		validationErrors = append(validationErrors, fmt.Errorf("Only one extender can implement bind, found %v", binders))
+	}
+	return utilerrors.NewAggregate(validationErrors)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/validation/validation_test.go

@@ -0,0 +1,76 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package validation
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"k8s.io/kubernetes/plugin/pkg/scheduler/api"
+)
+
+func TestValidatePolicy(t *testing.T) {
+	tests := []struct {
+		policy   api.Policy
+		expected error
+	}{
+		{
+			policy:   api.Policy{Priorities: []api.PriorityPolicy{{Name: "NoWeightPriority"}}},
+			expected: errors.New("Priority NoWeightPriority should have a positive weight applied to it or it has overflown"),
+		},
+		{
+			policy:   api.Policy{Priorities: []api.PriorityPolicy{{Name: "NoWeightPriority", Weight: 0}}},
+			expected: errors.New("Priority NoWeightPriority should have a positive weight applied to it or it has overflown"),
+		},
+		{
+			policy:   api.Policy{Priorities: []api.PriorityPolicy{{Name: "WeightPriority", Weight: 2}}},
+			expected: nil,
+		},
+		{
+			policy:   api.Policy{Priorities: []api.PriorityPolicy{{Name: "WeightPriority", Weight: -2}}},
+			expected: errors.New("Priority WeightPriority should have a positive weight applied to it or it has overflown"),
+		},
+		{
+			policy:   api.Policy{Priorities: []api.PriorityPolicy{{Name: "WeightPriority", Weight: api.MaxWeight}}},
+			expected: errors.New("Priority WeightPriority should have a positive weight applied to it or it has overflown"),
+		},
+		{
+			policy:   api.Policy{ExtenderConfigs: []api.ExtenderConfig{{URLPrefix: "http://127.0.0.1:8081/extender", FilterVerb: "filter", Weight: 2}}},
+			expected: nil,
+		},
+		{
+			policy:   api.Policy{ExtenderConfigs: []api.ExtenderConfig{{URLPrefix: "http://127.0.0.1:8081/extender", FilterVerb: "filter", Weight: -2}}},
+			expected: errors.New("Priority for extender http://127.0.0.1:8081/extender should have a positive weight applied to it"),
+		},
+		{
+			policy: api.Policy{
+				ExtenderConfigs: []api.ExtenderConfig{
+					{URLPrefix: "http://127.0.0.1:8081/extender", BindVerb: "bind", Weight: 2},
+					{URLPrefix: "http://127.0.0.1:8082/extender", BindVerb: "bind", Weight: 2},
+				}},
+			expected: errors.New("Only one extender can implement bind, found 2"),
+		},
+	}
+
+	for _, test := range tests {
+		actual := ValidatePolicy(test.policy)
+		if fmt.Sprint(test.expected) != fmt.Sprint(actual) {
+			t.Errorf("expected: %s, actual: %s", test.expected, actual)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/api/zz_generated.deepcopy.go

@@ -0,0 +1,498 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package api
+
+import (
+	v1 "k8s.io/api/core/v1"
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	rest "k8s.io/client-go/rest"
+	reflect "reflect"
+)
+
+func init() {
+	SchemeBuilder.Register(RegisterDeepCopies)
+}
+
+// RegisterDeepCopies adds deep-copy functions to the given scheme. Public
+// to allow building arbitrary schemes.
+//
+// Deprecated: deepcopy registration will go away when static deepcopy is fully implemented.
+func RegisterDeepCopies(scheme *runtime.Scheme) error {
+	return scheme.AddGeneratedDeepCopyFuncs(
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderArgs).DeepCopyInto(out.(*ExtenderArgs))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderArgs{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderBindingArgs).DeepCopyInto(out.(*ExtenderBindingArgs))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderBindingArgs{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderBindingResult).DeepCopyInto(out.(*ExtenderBindingResult))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderBindingResult{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderConfig).DeepCopyInto(out.(*ExtenderConfig))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderConfig{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ExtenderFilterResult).DeepCopyInto(out.(*ExtenderFilterResult))
+			return nil
+		}, InType: reflect.TypeOf(&ExtenderFilterResult{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*HostPriority).DeepCopyInto(out.(*HostPriority))
+			return nil
+		}, InType: reflect.TypeOf(&HostPriority{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*LabelPreference).DeepCopyInto(out.(*LabelPreference))
+			return nil
+		}, InType: reflect.TypeOf(&LabelPreference{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*LabelsPresence).DeepCopyInto(out.(*LabelsPresence))
+			return nil
+		}, InType: reflect.TypeOf(&LabelsPresence{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Policy).DeepCopyInto(out.(*Policy))
+			return nil
+		}, InType: reflect.TypeOf(&Policy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PredicateArgument).DeepCopyInto(out.(*PredicateArgument))
+			return nil
+		}, InType: reflect.TypeOf(&PredicateArgument{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PredicatePolicy).DeepCopyInto(out.(*PredicatePolicy))
+			return nil
+		}, InType: reflect.TypeOf(&PredicatePolicy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PriorityArgument).DeepCopyInto(out.(*PriorityArgument))
+			return nil
+		}, InType: reflect.TypeOf(&PriorityArgument{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PriorityPolicy).DeepCopyInto(out.(*PriorityPolicy))
+			return nil
+		}, InType: reflect.TypeOf(&PriorityPolicy{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ServiceAffinity).DeepCopyInto(out.(*ServiceAffinity))
+			return nil
+		}, InType: reflect.TypeOf(&ServiceAffinity{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*ServiceAntiAffinity).DeepCopyInto(out.(*ServiceAntiAffinity))
+			return nil
+		}, InType: reflect.TypeOf(&ServiceAntiAffinity{})},
+	)
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderArgs) DeepCopyInto(out *ExtenderArgs) {
+	*out = *in
+	in.Pod.DeepCopyInto(&out.Pod)
+	if in.Nodes != nil {
+		in, out := &in.Nodes, &out.Nodes
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(v1.NodeList)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.NodeNames != nil {
+		in, out := &in.NodeNames, &out.NodeNames
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new([]string)
+			if **in != nil {
+				in, out := *in, *out
+				*out = make([]string, len(*in))
+				copy(*out, *in)
+			}
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderArgs.
+func (in *ExtenderArgs) DeepCopy() *ExtenderArgs {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderArgs)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderBindingArgs) DeepCopyInto(out *ExtenderBindingArgs) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderBindingArgs.
+func (in *ExtenderBindingArgs) DeepCopy() *ExtenderBindingArgs {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderBindingArgs)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderBindingResult) DeepCopyInto(out *ExtenderBindingResult) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderBindingResult.
+func (in *ExtenderBindingResult) DeepCopy() *ExtenderBindingResult {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderBindingResult)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderConfig) DeepCopyInto(out *ExtenderConfig) {
+	*out = *in
+	if in.TLSConfig != nil {
+		in, out := &in.TLSConfig, &out.TLSConfig
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(rest.TLSClientConfig)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderConfig.
+func (in *ExtenderConfig) DeepCopy() *ExtenderConfig {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderConfig)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ExtenderFilterResult) DeepCopyInto(out *ExtenderFilterResult) {
+	*out = *in
+	if in.Nodes != nil {
+		in, out := &in.Nodes, &out.Nodes
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(v1.NodeList)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.NodeNames != nil {
+		in, out := &in.NodeNames, &out.NodeNames
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new([]string)
+			if **in != nil {
+				in, out := *in, *out
+				*out = make([]string, len(*in))
+				copy(*out, *in)
+			}
+		}
+	}
+	if in.FailedNodes != nil {
+		in, out := &in.FailedNodes, &out.FailedNodes
+		*out = make(FailedNodesMap, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtenderFilterResult.
+func (in *ExtenderFilterResult) DeepCopy() *ExtenderFilterResult {
+	if in == nil {
+		return nil
+	}
+	out := new(ExtenderFilterResult)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HostPriority) DeepCopyInto(out *HostPriority) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HostPriority.
+func (in *HostPriority) DeepCopy() *HostPriority {
+	if in == nil {
+		return nil
+	}
+	out := new(HostPriority)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LabelPreference) DeepCopyInto(out *LabelPreference) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LabelPreference.
+func (in *LabelPreference) DeepCopy() *LabelPreference {
+	if in == nil {
+		return nil
+	}
+	out := new(LabelPreference)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LabelsPresence) DeepCopyInto(out *LabelsPresence) {
+	*out = *in
+	if in.Labels != nil {
+		in, out := &in.Labels, &out.Labels
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LabelsPresence.
+func (in *LabelsPresence) DeepCopy() *LabelsPresence {
+	if in == nil {
+		return nil
+	}
+	out := new(LabelsPresence)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Policy) DeepCopyInto(out *Policy) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	if in.Predicates != nil {
+		in, out := &in.Predicates, &out.Predicates
+		*out = make([]PredicatePolicy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Priorities != nil {
+		in, out := &in.Priorities, &out.Priorities
+		*out = make([]PriorityPolicy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.ExtenderConfigs != nil {
+		in, out := &in.ExtenderConfigs, &out.ExtenderConfigs
+		*out = make([]ExtenderConfig, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Policy.
+func (in *Policy) DeepCopy() *Policy {
+	if in == nil {
+		return nil
+	}
+	out := new(Policy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Policy) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PredicateArgument) DeepCopyInto(out *PredicateArgument) {
+	*out = *in
+	if in.ServiceAffinity != nil {
+		in, out := &in.ServiceAffinity, &out.ServiceAffinity
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(ServiceAffinity)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	if in.LabelsPresence != nil {
+		in, out := &in.LabelsPresence, &out.LabelsPresence
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(LabelsPresence)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PredicateArgument.
+func (in *PredicateArgument) DeepCopy() *PredicateArgument {
+	if in == nil {
+		return nil
+	}
+	out := new(PredicateArgument)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PredicatePolicy) DeepCopyInto(out *PredicatePolicy) {
+	*out = *in
+	if in.Argument != nil {
+		in, out := &in.Argument, &out.Argument
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(PredicateArgument)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PredicatePolicy.
+func (in *PredicatePolicy) DeepCopy() *PredicatePolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(PredicatePolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PriorityArgument) DeepCopyInto(out *PriorityArgument) {
+	*out = *in
+	if in.ServiceAntiAffinity != nil {
+		in, out := &in.ServiceAntiAffinity, &out.ServiceAntiAffinity
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(ServiceAntiAffinity)
+			**out = **in
+		}
+	}
+	if in.LabelPreference != nil {
+		in, out := &in.LabelPreference, &out.LabelPreference
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(LabelPreference)
+			**out = **in
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityArgument.
+func (in *PriorityArgument) DeepCopy() *PriorityArgument {
+	if in == nil {
+		return nil
+	}
+	out := new(PriorityArgument)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PriorityPolicy) DeepCopyInto(out *PriorityPolicy) {
+	*out = *in
+	if in.Argument != nil {
+		in, out := &in.Argument, &out.Argument
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(PriorityArgument)
+			(*in).DeepCopyInto(*out)
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PriorityPolicy.
+func (in *PriorityPolicy) DeepCopy() *PriorityPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(PriorityPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServiceAffinity) DeepCopyInto(out *ServiceAffinity) {
+	*out = *in
+	if in.Labels != nil {
+		in, out := &in.Labels, &out.Labels
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAffinity.
+func (in *ServiceAffinity) DeepCopy() *ServiceAffinity {
+	if in == nil {
+		return nil
+	}
+	out := new(ServiceAffinity)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServiceAntiAffinity) DeepCopyInto(out *ServiceAntiAffinity) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAntiAffinity.
+func (in *ServiceAntiAffinity) DeepCopy() *ServiceAntiAffinity {
+	if in == nil {
+		return nil
+	}
+	out := new(ServiceAntiAffinity)
+	in.DeepCopyInto(out)
+	return out
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/BUILD

@@ -0,0 +1,72 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "equivalence_cache_test.go",
+        "extender_test.go",
+        "generic_scheduler_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/testing:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "equivalence_cache.go",
+        "extender.go",
+        "generic_scheduler.go",
+    ],
+    deps = [
+        "//pkg/util/hash:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/golang/groupcache/lru:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/net:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/trace:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/equivalence_cache.go

@@ -0,0 +1,205 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package core
+
+import (
+	"hash/fnv"
+	"sync"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	hashutil "k8s.io/kubernetes/pkg/util/hash"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+
+	"github.com/golang/glog"
+	"github.com/golang/groupcache/lru"
+)
+
+// We use predicate names as cache's key, its count is limited
+const maxCacheEntries = 100
+
+// EquivalenceCache holds:
+// 1. a map of AlgorithmCache with node name as key
+// 2. function to get equivalence pod
+type EquivalenceCache struct {
+	sync.RWMutex
+	getEquivalencePod algorithm.GetEquivalencePodFunc
+	algorithmCache    map[string]AlgorithmCache
+}
+
+// The AlgorithmCache stores PredicateMap with predicate name as key
+type AlgorithmCache struct {
+	// Only consider predicates for now
+	predicatesCache *lru.Cache
+}
+
+// PredicateMap stores HostPrediacte with equivalence hash as key
+type PredicateMap map[uint64]HostPredicate
+
+// HostPredicate is the cached predicate result
+type HostPredicate struct {
+	Fit         bool
+	FailReasons []algorithm.PredicateFailureReason
+}
+
+func newAlgorithmCache() AlgorithmCache {
+	return AlgorithmCache{
+		predicatesCache: lru.New(maxCacheEntries),
+	}
+}
+
+func NewEquivalenceCache(getEquivalencePodFunc algorithm.GetEquivalencePodFunc) *EquivalenceCache {
+	return &EquivalenceCache{
+		getEquivalencePod: getEquivalencePodFunc,
+		algorithmCache:    make(map[string]AlgorithmCache),
+	}
+}
+
+// UpdateCachedPredicateItem updates pod predicate for equivalence class
+func (ec *EquivalenceCache) UpdateCachedPredicateItem(
+	podName, nodeName, predicateKey string,
+	fit bool,
+	reasons []algorithm.PredicateFailureReason,
+	equivalenceHash uint64,
+) {
+	ec.Lock()
+	defer ec.Unlock()
+	if _, exist := ec.algorithmCache[nodeName]; !exist {
+		ec.algorithmCache[nodeName] = newAlgorithmCache()
+	}
+	predicateItem := HostPredicate{
+		Fit:         fit,
+		FailReasons: reasons,
+	}
+	// if cached predicate map already exists, just update the predicate by key
+	if v, ok := ec.algorithmCache[nodeName].predicatesCache.Get(predicateKey); ok {
+		predicateMap := v.(PredicateMap)
+		// maps in golang are references, no need to add them back
+		predicateMap[equivalenceHash] = predicateItem
+	} else {
+		ec.algorithmCache[nodeName].predicatesCache.Add(predicateKey,
+			PredicateMap{
+				equivalenceHash: predicateItem,
+			})
+	}
+	glog.V(5).Infof("Updated cached predicate: %v for pod: %v on node: %s, with item %v", predicateKey, podName, nodeName, predicateItem)
+}
+
+// PredicateWithECache returns:
+// 1. if fit
+// 2. reasons if not fit
+// 3. if this cache is invalid
+// based on cached predicate results
+func (ec *EquivalenceCache) PredicateWithECache(
+	podName, nodeName, predicateKey string,
+	equivalenceHash uint64,
+) (bool, []algorithm.PredicateFailureReason, bool) {
+	ec.RLock()
+	defer ec.RUnlock()
+	glog.V(5).Infof("Begin to calculate predicate: %v for pod: %s on node: %s based on equivalence cache",
+		predicateKey, podName, nodeName)
+	if algorithmCache, exist := ec.algorithmCache[nodeName]; exist {
+		if cachePredicate, exist := algorithmCache.predicatesCache.Get(predicateKey); exist {
+			predicateMap := cachePredicate.(PredicateMap)
+			// TODO(resouer) Is it possible a race that cache failed to update immediately?
+			if hostPredicate, ok := predicateMap[equivalenceHash]; ok {
+				if hostPredicate.Fit {
+					return true, []algorithm.PredicateFailureReason{}, false
+				} else {
+					return false, hostPredicate.FailReasons, false
+				}
+			} else {
+				// is invalid
+				return false, []algorithm.PredicateFailureReason{}, true
+			}
+		}
+	}
+	return false, []algorithm.PredicateFailureReason{}, true
+}
+
+// InvalidateCachedPredicateItem marks all items of given predicateKeys, of all pods, on the given node as invalid
+func (ec *EquivalenceCache) InvalidateCachedPredicateItem(nodeName string, predicateKeys sets.String) {
+	if len(predicateKeys) == 0 {
+		return
+	}
+	ec.Lock()
+	defer ec.Unlock()
+	if algorithmCache, exist := ec.algorithmCache[nodeName]; exist {
+		for predicateKey := range predicateKeys {
+			algorithmCache.predicatesCache.Remove(predicateKey)
+		}
+	}
+	glog.V(5).Infof("Done invalidating cached predicates: %v on node: %s", predicateKeys, nodeName)
+}
+
+// InvalidateCachedPredicateItemOfAllNodes marks all items of given predicateKeys, of all pods, on all node as invalid
+func (ec *EquivalenceCache) InvalidateCachedPredicateItemOfAllNodes(predicateKeys sets.String) {
+	if len(predicateKeys) == 0 {
+		return
+	}
+	ec.Lock()
+	defer ec.Unlock()
+	// algorithmCache uses nodeName as key, so we just iterate it and invalid given predicates
+	for _, algorithmCache := range ec.algorithmCache {
+		for predicateKey := range predicateKeys {
+			// just use keys is enough
+			algorithmCache.predicatesCache.Remove(predicateKey)
+		}
+	}
+	glog.V(5).Infof("Done invalidating cached predicates: %v on all node", predicateKeys)
+}
+
+// InvalidateAllCachedPredicateItemOfNode marks all cached items on given node as invalid
+func (ec *EquivalenceCache) InvalidateAllCachedPredicateItemOfNode(nodeName string) {
+	ec.Lock()
+	defer ec.Unlock()
+	delete(ec.algorithmCache, nodeName)
+	glog.V(5).Infof("Done invalidating all cached predicates on node: %s", nodeName)
+}
+
+// InvalidateCachedPredicateItemForPodAdd is a wrapper of InvalidateCachedPredicateItem for pod add case
+func (ec *EquivalenceCache) InvalidateCachedPredicateItemForPodAdd(pod *v1.Pod, nodeName string) {
+	// MatchInterPodAffinity: we assume scheduler can make sure newly binded pod
+	// will not break the existing inter pod affinity. So we does not need to invalidate
+	// MatchInterPodAffinity when pod added.
+	//
+	// But when a pod is deleted, existing inter pod affinity may become invalid.
+	// (e.g. this pod was preferred by some else, or vice versa)
+	//
+	// NOTE: assumptions above will not stand when we implemented features like
+	// RequiredDuringSchedulingRequiredDuringExecution.
+
+	// NoDiskConflict: the newly scheduled pod fits to existing pods on this node,
+	// it will also fits to equivalence class of existing pods
+
+	// GeneralPredicates: will always be affected by adding a new pod
+	invalidPredicates := sets.NewString("GeneralPredicates")
+	ec.InvalidateCachedPredicateItem(nodeName, invalidPredicates)
+}
+
+// getHashEquivalencePod returns the hash of equivalence pod.
+// 1. equivalenceHash
+// 2. if equivalence pod is found
+func (ec *EquivalenceCache) getHashEquivalencePod(pod *v1.Pod) (uint64, bool) {
+	equivalencePod := ec.getEquivalencePod(pod)
+	if equivalencePod != nil {
+		hash := fnv.New32a()
+		hashutil.DeepHashObject(hash, equivalencePod)
+		return uint64(hash.Sum32()), true
+	}
+	return 0, false
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/equivalence_cache_test.go

@@ -0,0 +1,448 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package core
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+)
+
+type predicateItemType struct {
+	fit     bool
+	reasons []algorithm.PredicateFailureReason
+}
+
+func TestUpdateCachedPredicateItem(t *testing.T) {
+	tests := []struct {
+		name               string
+		pod                string
+		predicateKey       string
+		nodeName           string
+		fit                bool
+		reasons            []algorithm.PredicateFailureReason
+		equivalenceHash    uint64
+		expectPredicateMap bool
+		expectCacheItem    HostPredicate
+	}{
+		{
+			name:               "test 1",
+			pod:                "testPod",
+			predicateKey:       "GeneralPredicates",
+			nodeName:           "node1",
+			fit:                true,
+			equivalenceHash:    123,
+			expectPredicateMap: false,
+			expectCacheItem: HostPredicate{
+				Fit: true,
+			},
+		},
+		{
+			name:               "test 2",
+			pod:                "testPod",
+			predicateKey:       "GeneralPredicates",
+			nodeName:           "node2",
+			fit:                false,
+			equivalenceHash:    123,
+			expectPredicateMap: true,
+			expectCacheItem: HostPredicate{
+				Fit: false,
+			},
+		},
+	}
+	for _, test := range tests {
+		// this case does not need to calculate equivalence hash, just pass an empty function
+		fakeGetEquivalencePodFunc := func(pod *v1.Pod) interface{} { return nil }
+		ecache := NewEquivalenceCache(fakeGetEquivalencePodFunc)
+		if test.expectPredicateMap {
+			ecache.algorithmCache[test.nodeName] = newAlgorithmCache()
+			predicateItem := HostPredicate{
+				Fit: true,
+			}
+			ecache.algorithmCache[test.nodeName].predicatesCache.Add(test.predicateKey,
+				PredicateMap{
+					test.equivalenceHash: predicateItem,
+				})
+		}
+		ecache.UpdateCachedPredicateItem(
+			test.pod,
+			test.nodeName,
+			test.predicateKey,
+			test.fit,
+			test.reasons,
+			test.equivalenceHash,
+		)
+
+		value, ok := ecache.algorithmCache[test.nodeName].predicatesCache.Get(test.predicateKey)
+		if !ok {
+			t.Errorf("Failed: %s, can't find expected cache item: %v",
+				test.name, test.expectCacheItem)
+		} else {
+			cachedMapItem := value.(PredicateMap)
+			if !reflect.DeepEqual(cachedMapItem[test.equivalenceHash], test.expectCacheItem) {
+				t.Errorf("Failed: %s, expected cached item: %v, but got: %v",
+					test.name, test.expectCacheItem, cachedMapItem[test.equivalenceHash])
+			}
+		}
+	}
+}
+
+func TestPredicateWithECache(t *testing.T) {
+	tests := []struct {
+		name                              string
+		podName                           string
+		nodeName                          string
+		predicateKey                      string
+		equivalenceHashForUpdatePredicate uint64
+		equivalenceHashForCalPredicate    uint64
+		cachedItem                        predicateItemType
+		expectedInvalidPredicateKey       bool
+		expectedInvalidEquivalenceHash    bool
+		expectedPredicateItem             predicateItemType
+	}{
+		{
+			name:     "test 1",
+			podName:  "testPod",
+			nodeName: "node1",
+			equivalenceHashForUpdatePredicate: 123,
+			equivalenceHashForCalPredicate:    123,
+			predicateKey:                      "GeneralPredicates",
+			cachedItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+			expectedInvalidPredicateKey: true,
+			expectedPredicateItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{},
+			},
+		},
+		{
+			name:     "test 2",
+			podName:  "testPod",
+			nodeName: "node2",
+			equivalenceHashForUpdatePredicate: 123,
+			equivalenceHashForCalPredicate:    123,
+			predicateKey:                      "GeneralPredicates",
+			cachedItem: predicateItemType{
+				fit: true,
+			},
+			expectedInvalidPredicateKey: false,
+			expectedPredicateItem: predicateItemType{
+				fit:     true,
+				reasons: []algorithm.PredicateFailureReason{},
+			},
+		},
+		{
+			name:     "test 3",
+			podName:  "testPod",
+			nodeName: "node3",
+			equivalenceHashForUpdatePredicate: 123,
+			equivalenceHashForCalPredicate:    123,
+			predicateKey:                      "GeneralPredicates",
+			cachedItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+			expectedInvalidPredicateKey: false,
+			expectedPredicateItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+		},
+		{
+			name:     "test 4",
+			podName:  "testPod",
+			nodeName: "node4",
+			equivalenceHashForUpdatePredicate: 123,
+			equivalenceHashForCalPredicate:    456,
+			predicateKey:                      "GeneralPredicates",
+			cachedItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+			expectedInvalidPredicateKey:    false,
+			expectedInvalidEquivalenceHash: true,
+			expectedPredicateItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		// this case does not need to calculate equivalence hash, just pass an empty function
+		fakeGetEquivalencePodFunc := func(pod *v1.Pod) interface{} { return nil }
+		ecache := NewEquivalenceCache(fakeGetEquivalencePodFunc)
+		// set cached item to equivalence cache
+		ecache.UpdateCachedPredicateItem(
+			test.podName,
+			test.nodeName,
+			test.predicateKey,
+			test.cachedItem.fit,
+			test.cachedItem.reasons,
+			test.equivalenceHashForUpdatePredicate,
+		)
+		// if we want to do invalid, invalid the cached item
+		if test.expectedInvalidPredicateKey {
+			predicateKeys := sets.NewString()
+			predicateKeys.Insert(test.predicateKey)
+			ecache.InvalidateCachedPredicateItem(test.nodeName, predicateKeys)
+		}
+		// calculate predicate with equivalence cache
+		fit, reasons, invalid := ecache.PredicateWithECache(test.podName,
+			test.nodeName,
+			test.predicateKey,
+			test.equivalenceHashForCalPredicate,
+		)
+		// returned invalid should match expectedInvalidPredicateKey or expectedInvalidEquivalenceHash
+		if test.equivalenceHashForUpdatePredicate != test.equivalenceHashForCalPredicate {
+			if invalid != test.expectedInvalidEquivalenceHash {
+				t.Errorf("Failed: %s, expected invalid: %v, but got: %v",
+					test.name, test.expectedInvalidEquivalenceHash, invalid)
+			}
+		} else {
+			if invalid != test.expectedInvalidPredicateKey {
+				t.Errorf("Failed: %s, expected invalid: %v, but got: %v",
+					test.name, test.expectedInvalidPredicateKey, invalid)
+			}
+		}
+		// returned predicate result should match expected predicate item
+		if fit != test.expectedPredicateItem.fit {
+			t.Errorf("Failed: %s, expected fit: %v, but got: %v", test.name, test.cachedItem.fit, fit)
+		}
+		if !reflect.DeepEqual(reasons, test.expectedPredicateItem.reasons) {
+			t.Errorf("Failed: %s, expected reasons: %v, but got: %v",
+				test.name, test.cachedItem.reasons, reasons)
+		}
+	}
+}
+
+func TestGetHashEquivalencePod(t *testing.T) {
+	//  use default equivalence class calculator
+	ecache := NewEquivalenceCache(predicates.GetEquivalencePod)
+
+	isController := true
+	pod1 := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "pod1",
+			OwnerReferences: []metav1.OwnerReference{
+				{
+					APIVersion: "v1",
+					Kind:       "ReplicationController",
+					Name:       "rc",
+					UID:        "123",
+					Controller: &isController,
+				},
+			},
+		},
+	}
+
+	pod2 := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "pod2",
+			OwnerReferences: []metav1.OwnerReference{
+				{
+					APIVersion: "v1",
+					Kind:       "ReplicationController",
+					Name:       "rc",
+					UID:        "123",
+					Controller: &isController,
+				},
+			},
+		},
+	}
+
+	pod3 := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "pod3",
+			OwnerReferences: []metav1.OwnerReference{
+				{
+					APIVersion: "v1",
+					Kind:       "ReplicationController",
+					Name:       "rc",
+					UID:        "567",
+					Controller: &isController,
+				},
+			},
+		},
+	}
+
+	hash1, _ := ecache.getHashEquivalencePod(pod1)
+	hash2, _ := ecache.getHashEquivalencePod(pod2)
+	hash3, _ := ecache.getHashEquivalencePod(pod3)
+
+	if hash1 != hash2 {
+		t.Errorf("Failed: pod %v and %v is expected to be equivalent", pod1.Name, pod2.Name)
+	}
+
+	if hash2 == hash3 {
+		t.Errorf("Failed: pod %v and %v is not expected to be equivalent", pod2.Name, pod3.Name)
+	}
+
+	// pod4 is a pod without controller ref
+	pod4 := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "pod4",
+		},
+	}
+	_, found := ecache.getHashEquivalencePod(pod4)
+	if found {
+		t.Errorf("Failed: equivalence hash of pod %v is not expected to be found, but got: %v",
+			pod4.Name, found)
+	}
+}
+
+func TestInvalidateCachedPredicateItemOfAllNodes(t *testing.T) {
+	testPredicate := "GeneralPredicates"
+	// tests is used to initialize all nodes
+	tests := []struct {
+		podName                           string
+		nodeName                          string
+		predicateKey                      string
+		equivalenceHashForUpdatePredicate uint64
+		cachedItem                        predicateItemType
+	}{
+		{
+			podName:  "testPod",
+			nodeName: "node1",
+			equivalenceHashForUpdatePredicate: 123,
+			cachedItem: predicateItemType{
+				fit: false,
+				reasons: []algorithm.PredicateFailureReason{
+					predicates.ErrPodNotFitsHostPorts,
+				},
+			},
+		},
+		{
+			podName:  "testPod",
+			nodeName: "node2",
+			equivalenceHashForUpdatePredicate: 456,
+			cachedItem: predicateItemType{
+				fit: false,
+				reasons: []algorithm.PredicateFailureReason{
+					predicates.ErrPodNotFitsHostPorts,
+				},
+			},
+		},
+		{
+			podName:  "testPod",
+			nodeName: "node3",
+			equivalenceHashForUpdatePredicate: 123,
+			cachedItem: predicateItemType{
+				fit: true,
+			},
+		},
+	}
+	// this case does not need to calculate equivalence hash, just pass an empty function
+	fakeGetEquivalencePodFunc := func(pod *v1.Pod) interface{} { return nil }
+	ecache := NewEquivalenceCache(fakeGetEquivalencePodFunc)
+
+	for _, test := range tests {
+		// set cached item to equivalence cache
+		ecache.UpdateCachedPredicateItem(
+			test.podName,
+			test.nodeName,
+			testPredicate,
+			test.cachedItem.fit,
+			test.cachedItem.reasons,
+			test.equivalenceHashForUpdatePredicate,
+		)
+	}
+
+	// invalidate cached predicate for all nodes
+	ecache.InvalidateCachedPredicateItemOfAllNodes(sets.NewString(testPredicate))
+
+	// there should be no cached predicate any more
+	for _, test := range tests {
+		if algorithmCache, exist := ecache.algorithmCache[test.nodeName]; exist {
+			if _, exist := algorithmCache.predicatesCache.Get(testPredicate); exist {
+				t.Errorf("Failed: cached item for predicate key: %v on node: %v should be invalidated",
+					testPredicate, test.nodeName)
+				break
+			}
+		}
+	}
+}
+
+func TestInvalidateAllCachedPredicateItemOfNode(t *testing.T) {
+	testPredicate := "GeneralPredicates"
+	// tests is used to initialize all nodes
+	tests := []struct {
+		podName                           string
+		nodeName                          string
+		predicateKey                      string
+		equivalenceHashForUpdatePredicate uint64
+		cachedItem                        predicateItemType
+	}{
+		{
+			podName:  "testPod",
+			nodeName: "node1",
+			equivalenceHashForUpdatePredicate: 123,
+			cachedItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+		},
+		{
+			podName:  "testPod",
+			nodeName: "node2",
+			equivalenceHashForUpdatePredicate: 456,
+			cachedItem: predicateItemType{
+				fit:     false,
+				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
+			},
+		},
+		{
+			podName:  "testPod",
+			nodeName: "node3",
+			equivalenceHashForUpdatePredicate: 123,
+			cachedItem: predicateItemType{
+				fit: true,
+			},
+		},
+	}
+	// this case does not need to calculate equivalence hash, just pass an empty function
+	fakeGetEquivalencePodFunc := func(pod *v1.Pod) interface{} { return nil }
+	ecache := NewEquivalenceCache(fakeGetEquivalencePodFunc)
+
+	for _, test := range tests {
+		// set cached item to equivalence cache
+		ecache.UpdateCachedPredicateItem(
+			test.podName,
+			test.nodeName,
+			testPredicate,
+			test.cachedItem.fit,
+			test.cachedItem.reasons,
+			test.equivalenceHashForUpdatePredicate,
+		)
+	}
+
+	for _, test := range tests {
+		// invalidate cached predicate for all nodes
+		ecache.InvalidateAllCachedPredicateItemOfNode(test.nodeName)
+		if _, exist := ecache.algorithmCache[test.nodeName]; exist {
+			t.Errorf("Failed: cached item for node: %v should be invalidated", test.nodeName)
+			break
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/extender.go

@@ -0,0 +1,252 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package core
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"k8s.io/api/core/v1"
+	utilnet "k8s.io/apimachinery/pkg/util/net"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+const (
+	DefaultExtenderTimeout = 5 * time.Second
+)
+
+// HTTPExtender implements the algorithm.SchedulerExtender interface.
+type HTTPExtender struct {
+	extenderURL      string
+	filterVerb       string
+	prioritizeVerb   string
+	bindVerb         string
+	weight           int
+	client           *http.Client
+	nodeCacheCapable bool
+}
+
+func makeTransport(config *schedulerapi.ExtenderConfig) (http.RoundTripper, error) {
+	var cfg restclient.Config
+	if config.TLSConfig != nil {
+		cfg.TLSClientConfig = *config.TLSConfig
+	}
+	if config.EnableHttps {
+		hasCA := len(cfg.CAFile) > 0 || len(cfg.CAData) > 0
+		if !hasCA {
+			cfg.Insecure = true
+		}
+	}
+	tlsConfig, err := restclient.TLSConfigFor(&cfg)
+	if err != nil {
+		return nil, err
+	}
+	if tlsConfig != nil {
+		return utilnet.SetTransportDefaults(&http.Transport{
+			TLSClientConfig: tlsConfig,
+		}), nil
+	}
+	return utilnet.SetTransportDefaults(&http.Transport{}), nil
+}
+
+func NewHTTPExtender(config *schedulerapi.ExtenderConfig) (algorithm.SchedulerExtender, error) {
+	if config.HTTPTimeout.Nanoseconds() == 0 {
+		config.HTTPTimeout = time.Duration(DefaultExtenderTimeout)
+	}
+
+	transport, err := makeTransport(config)
+	if err != nil {
+		return nil, err
+	}
+	client := &http.Client{
+		Transport: transport,
+		Timeout:   config.HTTPTimeout,
+	}
+	return &HTTPExtender{
+		extenderURL:      config.URLPrefix,
+		filterVerb:       config.FilterVerb,
+		prioritizeVerb:   config.PrioritizeVerb,
+		bindVerb:         config.BindVerb,
+		weight:           config.Weight,
+		client:           client,
+		nodeCacheCapable: config.NodeCacheCapable,
+	}, nil
+}
+
+// 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 (h *HTTPExtender) Filter(pod *v1.Pod, nodes []*v1.Node, nodeNameToInfo map[string]*schedulercache.NodeInfo) ([]*v1.Node, schedulerapi.FailedNodesMap, error) {
+	var (
+		result     schedulerapi.ExtenderFilterResult
+		nodeList   *v1.NodeList
+		nodeNames  *[]string
+		nodeResult []*v1.Node
+		args       *schedulerapi.ExtenderArgs
+	)
+
+	if h.filterVerb == "" {
+		return nodes, schedulerapi.FailedNodesMap{}, nil
+	}
+
+	if h.nodeCacheCapable {
+		nodeNameSlice := make([]string, 0, len(nodes))
+		for _, node := range nodes {
+			nodeNameSlice = append(nodeNameSlice, node.Name)
+		}
+		nodeNames = &nodeNameSlice
+	} else {
+		nodeList = &v1.NodeList{}
+		for _, node := range nodes {
+			nodeList.Items = append(nodeList.Items, *node)
+		}
+	}
+
+	args = &schedulerapi.ExtenderArgs{
+		Pod:       *pod,
+		Nodes:     nodeList,
+		NodeNames: nodeNames,
+	}
+
+	if err := h.send(h.filterVerb, args, &result); err != nil {
+		return nil, nil, err
+	}
+	if result.Error != "" {
+		return nil, nil, fmt.Errorf(result.Error)
+	}
+
+	if h.nodeCacheCapable && result.NodeNames != nil {
+		nodeResult = make([]*v1.Node, 0, len(*result.NodeNames))
+		for i := range *result.NodeNames {
+			nodeResult = append(nodeResult, nodeNameToInfo[(*result.NodeNames)[i]].Node())
+		}
+	} else if result.Nodes != nil {
+		nodeResult = make([]*v1.Node, 0, len(result.Nodes.Items))
+		for i := range result.Nodes.Items {
+			nodeResult = append(nodeResult, &result.Nodes.Items[i])
+		}
+	}
+
+	return nodeResult, result.FailedNodes, nil
+}
+
+// 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 (h *HTTPExtender) Prioritize(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, int, error) {
+	var (
+		result    schedulerapi.HostPriorityList
+		nodeList  *v1.NodeList
+		nodeNames *[]string
+		args      *schedulerapi.ExtenderArgs
+	)
+
+	if h.prioritizeVerb == "" {
+		result := schedulerapi.HostPriorityList{}
+		for _, node := range nodes {
+			result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: 0})
+		}
+		return &result, 0, nil
+	}
+
+	if h.nodeCacheCapable {
+		nodeNameSlice := make([]string, 0, len(nodes))
+		for _, node := range nodes {
+			nodeNameSlice = append(nodeNameSlice, node.Name)
+		}
+		nodeNames = &nodeNameSlice
+	} else {
+		nodeList = &v1.NodeList{}
+		for _, node := range nodes {
+			nodeList.Items = append(nodeList.Items, *node)
+		}
+	}
+
+	args = &schedulerapi.ExtenderArgs{
+		Pod:       *pod,
+		Nodes:     nodeList,
+		NodeNames: nodeNames,
+	}
+
+	if err := h.send(h.prioritizeVerb, args, &result); err != nil {
+		return nil, 0, err
+	}
+	return &result, h.weight, nil
+}
+
+// Bind delegates the action of binding a pod to a node to the extender.
+func (h *HTTPExtender) Bind(binding *v1.Binding) error {
+	var result schedulerapi.ExtenderBindingResult
+	if !h.IsBinder() {
+		// This shouldn't happen as this extender wouldn't have become a Binder.
+		return fmt.Errorf("Unexpected empty bindVerb in extender")
+	}
+	req := &schedulerapi.ExtenderBindingArgs{
+		PodName:      binding.Name,
+		PodNamespace: binding.Namespace,
+		PodUID:       binding.UID,
+		Node:         binding.Target.Name,
+	}
+	if err := h.send(h.bindVerb, &req, &result); err != nil {
+		return err
+	}
+	if result.Error != "" {
+		return fmt.Errorf(result.Error)
+	}
+	return nil
+}
+
+// IsBinder returns whether this extender is configured for the Bind method.
+func (h *HTTPExtender) IsBinder() bool {
+	return h.bindVerb != ""
+}
+
+// Helper function to send messages to the extender
+func (h *HTTPExtender) send(action string, args interface{}, result interface{}) error {
+	out, err := json.Marshal(args)
+	if err != nil {
+		return err
+	}
+
+	url := strings.TrimRight(h.extenderURL, "/") + "/" + action
+
+	req, err := http.NewRequest("POST", url, bytes.NewReader(out))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := h.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Failed %v with extender at URL %v, code %v", action, h.extenderURL, resp.StatusCode)
+	}
+
+	return json.NewDecoder(resp.Body).Decode(result)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/extender_test.go

@@ -0,0 +1,336 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package core
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedulertesting "k8s.io/kubernetes/plugin/pkg/scheduler/testing"
+)
+
+type fitPredicate func(pod *v1.Pod, node *v1.Node) (bool, error)
+type priorityFunc func(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, error)
+
+type priorityConfig struct {
+	function priorityFunc
+	weight   int
+}
+
+func errorPredicateExtender(pod *v1.Pod, node *v1.Node) (bool, error) {
+	return false, fmt.Errorf("Some error")
+}
+
+func falsePredicateExtender(pod *v1.Pod, node *v1.Node) (bool, error) {
+	return false, nil
+}
+
+func truePredicateExtender(pod *v1.Pod, node *v1.Node) (bool, error) {
+	return true, nil
+}
+
+func machine1PredicateExtender(pod *v1.Pod, node *v1.Node) (bool, error) {
+	if node.Name == "machine1" {
+		return true, nil
+	}
+	return false, nil
+}
+
+func machine2PredicateExtender(pod *v1.Pod, node *v1.Node) (bool, error) {
+	if node.Name == "machine2" {
+		return true, nil
+	}
+	return false, nil
+}
+
+func errorPrioritizerExtender(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, error) {
+	return &schedulerapi.HostPriorityList{}, fmt.Errorf("Some error")
+}
+
+func machine1PrioritizerExtender(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, error) {
+	result := schedulerapi.HostPriorityList{}
+	for _, node := range nodes {
+		score := 1
+		if node.Name == "machine1" {
+			score = 10
+		}
+		result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: score})
+	}
+	return &result, nil
+}
+
+func machine2PrioritizerExtender(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, error) {
+	result := schedulerapi.HostPriorityList{}
+	for _, node := range nodes {
+		score := 1
+		if node.Name == "machine2" {
+			score = 10
+		}
+		result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: score})
+	}
+	return &result, nil
+}
+
+func machine2Prioritizer(_ *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	result := []schedulerapi.HostPriority{}
+	for _, node := range nodes {
+		score := 1
+		if node.Name == "machine2" {
+			score = 10
+		}
+		result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: score})
+	}
+	return result, nil
+}
+
+type FakeExtender struct {
+	predicates       []fitPredicate
+	prioritizers     []priorityConfig
+	weight           int
+	nodeCacheCapable bool
+	filteredNodes    []*v1.Node
+}
+
+func (f *FakeExtender) Filter(pod *v1.Pod, nodes []*v1.Node, nodeNameToInfo map[string]*schedulercache.NodeInfo) ([]*v1.Node, schedulerapi.FailedNodesMap, error) {
+	filtered := []*v1.Node{}
+	failedNodesMap := schedulerapi.FailedNodesMap{}
+	for _, node := range nodes {
+		fits := true
+		for _, predicate := range f.predicates {
+			fit, err := predicate(pod, node)
+			if err != nil {
+				return []*v1.Node{}, schedulerapi.FailedNodesMap{}, err
+			}
+			if !fit {
+				fits = false
+				break
+			}
+		}
+		if fits {
+			filtered = append(filtered, node)
+		} else {
+			failedNodesMap[node.Name] = "FakeExtender failed"
+		}
+	}
+
+	f.filteredNodes = filtered
+	if f.nodeCacheCapable {
+		return filtered, failedNodesMap, nil
+	}
+	return filtered, failedNodesMap, nil
+}
+
+func (f *FakeExtender) Prioritize(pod *v1.Pod, nodes []*v1.Node) (*schedulerapi.HostPriorityList, int, error) {
+	result := schedulerapi.HostPriorityList{}
+	combinedScores := map[string]int{}
+	for _, prioritizer := range f.prioritizers {
+		weight := prioritizer.weight
+		if weight == 0 {
+			continue
+		}
+		priorityFunc := prioritizer.function
+		prioritizedList, err := priorityFunc(pod, nodes)
+		if err != nil {
+			return &schedulerapi.HostPriorityList{}, 0, err
+		}
+		for _, hostEntry := range *prioritizedList {
+			combinedScores[hostEntry.Host] += hostEntry.Score * weight
+		}
+	}
+	for host, score := range combinedScores {
+		result = append(result, schedulerapi.HostPriority{Host: host, Score: score})
+	}
+	return &result, f.weight, nil
+}
+
+func (f *FakeExtender) Bind(binding *v1.Binding) error {
+	if len(f.filteredNodes) != 0 {
+		for _, node := range f.filteredNodes {
+			if node.Name == binding.Target.Name {
+				f.filteredNodes = nil
+				return nil
+			}
+		}
+		err := fmt.Errorf("Node %v not in filtered nodes %v", binding.Target.Name, f.filteredNodes)
+		f.filteredNodes = nil
+		return err
+	}
+	return nil
+}
+
+func (f *FakeExtender) IsBinder() bool {
+	return true
+}
+
+var _ algorithm.SchedulerExtender = &FakeExtender{}
+
+func TestGenericSchedulerWithExtenders(t *testing.T) {
+	tests := []struct {
+		name                 string
+		predicates           map[string]algorithm.FitPredicate
+		prioritizers         []algorithm.PriorityConfig
+		extenders            []FakeExtender
+		extenderPredicates   []fitPredicate
+		extenderPrioritizers []priorityConfig
+		nodes                []string
+		expectedHost         string
+		expectsErr           bool
+	}{
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates: []fitPredicate{truePredicateExtender},
+				},
+				{
+					predicates: []fitPredicate{errorPredicateExtender},
+				},
+			},
+			nodes:      []string{"machine1", "machine2"},
+			expectsErr: true,
+			name:       "test 1",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates: []fitPredicate{truePredicateExtender},
+				},
+				{
+					predicates: []fitPredicate{falsePredicateExtender},
+				},
+			},
+			nodes:      []string{"machine1", "machine2"},
+			expectsErr: true,
+			name:       "test 2",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates: []fitPredicate{truePredicateExtender},
+				},
+				{
+					predicates: []fitPredicate{machine1PredicateExtender},
+				},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			expectedHost: "machine1",
+			name:         "test 3",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates: []fitPredicate{machine2PredicateExtender},
+				},
+				{
+					predicates: []fitPredicate{machine1PredicateExtender},
+				},
+			},
+			nodes:      []string{"machine1", "machine2"},
+			expectsErr: true,
+			name:       "test 4",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates:   []fitPredicate{truePredicateExtender},
+					prioritizers: []priorityConfig{{errorPrioritizerExtender, 10}},
+					weight:       1,
+				},
+			},
+			nodes:        []string{"machine1"},
+			expectedHost: "machine1",
+			name:         "test 5",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
+			extenders: []FakeExtender{
+				{
+					predicates:   []fitPredicate{truePredicateExtender},
+					prioritizers: []priorityConfig{{machine1PrioritizerExtender, 10}},
+					weight:       1,
+				},
+				{
+					predicates:   []fitPredicate{truePredicateExtender},
+					prioritizers: []priorityConfig{{machine2PrioritizerExtender, 10}},
+					weight:       5,
+				},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			expectedHost: "machine2",
+			name:         "test 6",
+		},
+		{
+			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
+			prioritizers: []algorithm.PriorityConfig{{Function: machine2Prioritizer, Weight: 20}},
+			extenders: []FakeExtender{
+				{
+					predicates:   []fitPredicate{truePredicateExtender},
+					prioritizers: []priorityConfig{{machine1PrioritizerExtender, 10}},
+					weight:       1,
+				},
+			},
+			nodes:        []string{"machine1", "machine2"},
+			expectedHost: "machine2", // machine2 has higher score
+			name:         "test 7",
+		},
+	}
+
+	for _, test := range tests {
+		extenders := []algorithm.SchedulerExtender{}
+		for ii := range test.extenders {
+			extenders = append(extenders, &test.extenders[ii])
+		}
+		cache := schedulercache.New(time.Duration(0), wait.NeverStop)
+		for _, name := range test.nodes {
+			cache.AddNode(&v1.Node{ObjectMeta: metav1.ObjectMeta{Name: name}})
+		}
+		scheduler := NewGenericScheduler(
+			cache, nil, test.predicates, algorithm.EmptyPredicateMetadataProducer, test.prioritizers, algorithm.EmptyMetadataProducer, extenders)
+		podIgnored := &v1.Pod{}
+		machine, err := scheduler.Schedule(podIgnored, schedulertesting.FakeNodeLister(makeNodeList(test.nodes)))
+		if test.expectsErr {
+			if err == nil {
+				t.Errorf("Unexpected non-error for %s, machine %s", test.name, machine)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				continue
+			}
+			if test.expectedHost != machine {
+				t.Errorf("Failed : %s, Expected: %s, Saw: %s", test.name, test.expectedHost, machine)
+			}
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/core/generic_scheduler.go

@@ -0,0 +1,788 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package core
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/util/errors"
+	utiltrace "k8s.io/apiserver/pkg/util/trace"
+	"k8s.io/client-go/util/workqueue"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+
+	"github.com/golang/glog"
+)
+
+type FailedPredicateMap map[string][]algorithm.PredicateFailureReason
+
+type FitError struct {
+	Pod              *v1.Pod
+	FailedPredicates FailedPredicateMap
+}
+
+var ErrNoNodesAvailable = fmt.Errorf("no nodes available to schedule pods")
+
+const (
+	NoNodeAvailableMsg = "No nodes are available that match all of the predicates"
+	// NominatedNodeAnnotationKey is used to annotate a pod that has preempted other pods.
+	// The scheduler uses the annotation to find that the pod shouldn't preempt more pods
+	// when it gets to the head of scheduling queue again.
+	// See podEligibleToPreemptOthers() for more information.
+	NominatedNodeAnnotationKey = "NominatedNodeName"
+)
+
+// Error returns detailed information of why the pod failed to fit on each node
+func (f *FitError) Error() string {
+	reasons := make(map[string]int)
+	for _, predicates := range f.FailedPredicates {
+		for _, pred := range predicates {
+			reasons[pred.GetReason()] += 1
+		}
+	}
+
+	sortReasonsHistogram := func() []string {
+		reasonStrings := []string{}
+		for k, v := range reasons {
+			reasonStrings = append(reasonStrings, fmt.Sprintf("%v (%v)", k, v))
+		}
+		sort.Strings(reasonStrings)
+		return reasonStrings
+	}
+	reasonMsg := fmt.Sprintf(NoNodeAvailableMsg+": %v.", strings.Join(sortReasonsHistogram(), ", "))
+	return reasonMsg
+}
+
+type genericScheduler struct {
+	cache                 schedulercache.Cache
+	equivalenceCache      *EquivalenceCache
+	predicates            map[string]algorithm.FitPredicate
+	priorityMetaProducer  algorithm.MetadataProducer
+	predicateMetaProducer algorithm.PredicateMetadataProducer
+	prioritizers          []algorithm.PriorityConfig
+	extenders             []algorithm.SchedulerExtender
+	pods                  algorithm.PodLister
+	lastNodeIndexLock     sync.Mutex
+	lastNodeIndex         uint64
+
+	cachedNodeInfoMap map[string]*schedulercache.NodeInfo
+}
+
+// Schedule tries to schedule the given pod to one of node in the node list.
+// If it succeeds, it will return the name of the node.
+// If it fails, it will return a Fiterror error with reasons.
+func (g *genericScheduler) Schedule(pod *v1.Pod, nodeLister algorithm.NodeLister) (string, error) {
+	trace := utiltrace.New(fmt.Sprintf("Scheduling %s/%s", pod.Namespace, pod.Name))
+	defer trace.LogIfLong(100 * time.Millisecond)
+
+	nodes, err := nodeLister.List()
+	if err != nil {
+		return "", err
+	}
+	if len(nodes) == 0 {
+		return "", ErrNoNodesAvailable
+	}
+
+	// Used for all fit and priority funcs.
+	err = g.cache.UpdateNodeNameToInfoMap(g.cachedNodeInfoMap)
+	if err != nil {
+		return "", err
+	}
+
+	trace.Step("Computing predicates")
+	filteredNodes, failedPredicateMap, err := findNodesThatFit(pod, g.cachedNodeInfoMap, nodes, g.predicates, g.extenders, g.predicateMetaProducer, g.equivalenceCache)
+	if err != nil {
+		return "", err
+	}
+
+	if len(filteredNodes) == 0 {
+		return "", &FitError{
+			Pod:              pod,
+			FailedPredicates: failedPredicateMap,
+		}
+	}
+
+	trace.Step("Prioritizing")
+	metaPrioritiesInterface := g.priorityMetaProducer(pod, g.cachedNodeInfoMap)
+	priorityList, err := PrioritizeNodes(pod, g.cachedNodeInfoMap, metaPrioritiesInterface, g.prioritizers, filteredNodes, g.extenders)
+	if err != nil {
+		return "", err
+	}
+
+	trace.Step("Selecting host")
+	return g.selectHost(priorityList)
+}
+
+// Prioritizers returns a slice containing all the scheduler's priority
+// functions and their config. It is exposed for testing only.
+func (g *genericScheduler) Prioritizers() []algorithm.PriorityConfig {
+	return g.prioritizers
+}
+
+// Predicates returns a map containing all the scheduler's predicate
+// functions. It is exposed for testing only.
+func (g *genericScheduler) Predicates() map[string]algorithm.FitPredicate {
+	return g.predicates
+}
+
+// selectHost takes a prioritized list of nodes and then picks one
+// in a round-robin manner from the nodes that had the highest score.
+func (g *genericScheduler) selectHost(priorityList schedulerapi.HostPriorityList) (string, error) {
+	if len(priorityList) == 0 {
+		return "", fmt.Errorf("empty priorityList")
+	}
+
+	sort.Sort(sort.Reverse(priorityList))
+	maxScore := priorityList[0].Score
+	firstAfterMaxScore := sort.Search(len(priorityList), func(i int) bool { return priorityList[i].Score < maxScore })
+
+	g.lastNodeIndexLock.Lock()
+	ix := int(g.lastNodeIndex % uint64(firstAfterMaxScore))
+	g.lastNodeIndex++
+	g.lastNodeIndexLock.Unlock()
+
+	return priorityList[ix].Host, nil
+}
+
+// preempt finds nodes with pods that can be preempted to make room for "pod" to
+// schedule. It chooses one of the nodes and preempts the pods on the node and
+// returns the node and the list of preempted pods if such a node is found.
+// TODO(bsalamat): Add priority-based scheduling. More info: today one or more
+// pending pods (different from the pod that triggered the preemption(s)) may
+// schedule into some portion of the resources freed up by the preemption(s)
+// before the pod that triggered the preemption(s) has a chance to schedule
+// there, thereby preventing the pod that triggered the preemption(s) from
+// scheduling. Solution is given at:
+// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/pod-preemption.md#preemption-mechanics
+func (g *genericScheduler) Preempt(pod *v1.Pod, nodeLister algorithm.NodeLister, scheduleErr error) (*v1.Node, []*v1.Pod, error) {
+	// Scheduler may return various types of errors. Consider preemption only if
+	// the error is of type FitError.
+	fitError, ok := scheduleErr.(*FitError)
+	if !ok || fitError == nil {
+		return nil, nil, nil
+	}
+	err := g.cache.UpdateNodeNameToInfoMap(g.cachedNodeInfoMap)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !podEligibleToPreemptOthers(pod, g.cachedNodeInfoMap) {
+		glog.V(5).Infof("Pod %v is not eligible for more preemption.", pod.Name)
+		return nil, nil, nil
+	}
+	allNodes, err := nodeLister.List()
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(allNodes) == 0 {
+		return nil, nil, ErrNoNodesAvailable
+	}
+	potentialNodes := nodesWherePreemptionMightHelp(pod, allNodes, fitError.FailedPredicates)
+	if len(potentialNodes) == 0 {
+		glog.V(3).Infof("Preemption will not help schedule pod %v on any node.", pod.Name)
+		return nil, nil, nil
+	}
+	nodeToPods, err := selectNodesForPreemption(pod, g.cachedNodeInfoMap, potentialNodes, g.predicates, g.predicateMetaProducer)
+	if err != nil {
+		return nil, nil, err
+	}
+	for len(nodeToPods) > 0 {
+		node := pickOneNodeForPreemption(nodeToPods)
+		if node == nil {
+			return nil, nil, err
+		}
+		passes, pErr := nodePassesExtendersForPreemption(pod, node.Name, nodeToPods[node], g.cachedNodeInfoMap, g.extenders)
+		if passes && pErr == nil {
+			return node, nodeToPods[node], err
+		}
+		if pErr != nil {
+			glog.Errorf("Error occurred while checking extenders for preemption on node %v: %v", node, pErr)
+		}
+		// Remove the node from the map and try to pick a different node.
+		delete(nodeToPods, node)
+	}
+	return nil, nil, err
+}
+
+// Filters the nodes to find the ones that fit based on the given predicate functions
+// Each node is passed through the predicate functions to determine if it is a fit
+func findNodesThatFit(
+	pod *v1.Pod,
+	nodeNameToInfo map[string]*schedulercache.NodeInfo,
+	nodes []*v1.Node,
+	predicateFuncs map[string]algorithm.FitPredicate,
+	extenders []algorithm.SchedulerExtender,
+	metadataProducer algorithm.PredicateMetadataProducer,
+	ecache *EquivalenceCache,
+) ([]*v1.Node, FailedPredicateMap, error) {
+	var filtered []*v1.Node
+	failedPredicateMap := FailedPredicateMap{}
+
+	if len(predicateFuncs) == 0 {
+		filtered = nodes
+	} else {
+		// Create filtered list with enough space to avoid growing it
+		// and allow assigning.
+		filtered = make([]*v1.Node, len(nodes))
+		errs := errors.MessageCountMap{}
+		var predicateResultLock sync.Mutex
+		var filteredLen int32
+
+		// We can use the same metadata producer for all nodes.
+		meta := metadataProducer(pod, nodeNameToInfo)
+		checkNode := func(i int) {
+			nodeName := nodes[i].Name
+			fits, failedPredicates, err := podFitsOnNode(pod, meta, nodeNameToInfo[nodeName], predicateFuncs, ecache)
+			if err != nil {
+				predicateResultLock.Lock()
+				errs[err.Error()]++
+				predicateResultLock.Unlock()
+				return
+			}
+			if fits {
+				filtered[atomic.AddInt32(&filteredLen, 1)-1] = nodes[i]
+			} else {
+				predicateResultLock.Lock()
+				failedPredicateMap[nodeName] = failedPredicates
+				predicateResultLock.Unlock()
+			}
+		}
+		workqueue.Parallelize(16, len(nodes), checkNode)
+		filtered = filtered[:filteredLen]
+		if len(errs) > 0 {
+			return []*v1.Node{}, FailedPredicateMap{}, errors.CreateAggregateFromMessageCountMap(errs)
+		}
+	}
+
+	if len(filtered) > 0 && len(extenders) != 0 {
+		for _, extender := range extenders {
+			filteredList, failedMap, err := extender.Filter(pod, filtered, nodeNameToInfo)
+			if err != nil {
+				return []*v1.Node{}, FailedPredicateMap{}, err
+			}
+
+			for failedNodeName, failedMsg := range failedMap {
+				if _, found := failedPredicateMap[failedNodeName]; !found {
+					failedPredicateMap[failedNodeName] = []algorithm.PredicateFailureReason{}
+				}
+				failedPredicateMap[failedNodeName] = append(failedPredicateMap[failedNodeName], predicates.NewFailureReason(failedMsg))
+			}
+			filtered = filteredList
+			if len(filtered) == 0 {
+				break
+			}
+		}
+	}
+	return filtered, failedPredicateMap, nil
+}
+
+// Checks whether node with a given name and NodeInfo satisfies all predicateFuncs.
+func podFitsOnNode(pod *v1.Pod, meta algorithm.PredicateMetadata, info *schedulercache.NodeInfo, predicateFuncs map[string]algorithm.FitPredicate,
+	ecache *EquivalenceCache) (bool, []algorithm.PredicateFailureReason, error) {
+	var (
+		equivalenceHash  uint64
+		failedPredicates []algorithm.PredicateFailureReason
+		eCacheAvailable  bool
+		invalid          bool
+		fit              bool
+		reasons          []algorithm.PredicateFailureReason
+		err              error
+	)
+	if ecache != nil {
+		// getHashEquivalencePod will return immediately if no equivalence pod found
+		equivalenceHash, eCacheAvailable = ecache.getHashEquivalencePod(pod)
+	}
+	for predicateKey, predicate := range predicateFuncs {
+		// If equivalenceCache is available
+		if eCacheAvailable {
+			// PredicateWithECache will returns it's cached predicate results
+			fit, reasons, invalid = ecache.PredicateWithECache(pod.GetName(), info.Node().GetName(), predicateKey, equivalenceHash)
+		}
+
+		if !eCacheAvailable || invalid {
+			// we need to execute predicate functions since equivalence cache does not work
+			fit, reasons, err = predicate(pod, meta, info)
+			if err != nil {
+				return false, []algorithm.PredicateFailureReason{}, err
+			}
+
+			if eCacheAvailable {
+				// update equivalence cache with newly computed fit & reasons
+				// TODO(resouer) should we do this in another thread? any race?
+				ecache.UpdateCachedPredicateItem(pod.GetName(), info.Node().GetName(), predicateKey, fit, reasons, equivalenceHash)
+			}
+		}
+
+		if !fit {
+			// eCache is available and valid, and predicates result is unfit, record the fail reasons
+			failedPredicates = append(failedPredicates, reasons...)
+		}
+	}
+	return len(failedPredicates) == 0, failedPredicates, nil
+}
+
+// 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
+func PrioritizeNodes(
+	pod *v1.Pod,
+	nodeNameToInfo map[string]*schedulercache.NodeInfo,
+	meta interface{},
+	priorityConfigs []algorithm.PriorityConfig,
+	nodes []*v1.Node,
+	extenders []algorithm.SchedulerExtender,
+) (schedulerapi.HostPriorityList, error) {
+	// If no priority configs are provided, then the EqualPriority function is applied
+	// This is required to generate the priority list in the required format
+	if len(priorityConfigs) == 0 && len(extenders) == 0 {
+		result := make(schedulerapi.HostPriorityList, 0, len(nodes))
+		for i := range nodes {
+			hostPriority, err := EqualPriorityMap(pod, meta, nodeNameToInfo[nodes[i].Name])
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, hostPriority)
+		}
+		return result, nil
+	}
+
+	var (
+		mu   = sync.Mutex{}
+		wg   = sync.WaitGroup{}
+		errs []error
+	)
+	appendError := func(err error) {
+		mu.Lock()
+		defer mu.Unlock()
+		errs = append(errs, err)
+	}
+
+	results := make([]schedulerapi.HostPriorityList, len(priorityConfigs), len(priorityConfigs))
+
+	for i, priorityConfig := range priorityConfigs {
+		if priorityConfig.Function != nil {
+			// DEPRECATED
+			wg.Add(1)
+			go func(index int, config algorithm.PriorityConfig) {
+				defer wg.Done()
+				var err error
+				results[index], err = config.Function(pod, nodeNameToInfo, nodes)
+				if err != nil {
+					appendError(err)
+				}
+			}(i, priorityConfig)
+		} else {
+			results[i] = make(schedulerapi.HostPriorityList, len(nodes))
+		}
+	}
+	processNode := func(index int) {
+		nodeInfo := nodeNameToInfo[nodes[index].Name]
+		var err error
+		for i := range priorityConfigs {
+			if priorityConfigs[i].Function != nil {
+				continue
+			}
+			results[i][index], err = priorityConfigs[i].Map(pod, meta, nodeInfo)
+			if err != nil {
+				appendError(err)
+				return
+			}
+		}
+	}
+	workqueue.Parallelize(16, len(nodes), processNode)
+	for i, priorityConfig := range priorityConfigs {
+		if priorityConfig.Reduce == nil {
+			continue
+		}
+		wg.Add(1)
+		go func(index int, config algorithm.PriorityConfig) {
+			defer wg.Done()
+			if err := config.Reduce(pod, meta, nodeNameToInfo, results[index]); err != nil {
+				appendError(err)
+			}
+		}(i, priorityConfig)
+	}
+	// Wait for all computations to be finished.
+	wg.Wait()
+	if len(errs) != 0 {
+		return schedulerapi.HostPriorityList{}, errors.NewAggregate(errs)
+	}
+
+	// Summarize all scores.
+	result := make(schedulerapi.HostPriorityList, 0, len(nodes))
+
+	for i := range nodes {
+		result = append(result, schedulerapi.HostPriority{Host: nodes[i].Name, Score: 0})
+		for j := range priorityConfigs {
+			result[i].Score += results[j][i].Score * priorityConfigs[j].Weight
+		}
+	}
+
+	if len(extenders) != 0 && nodes != nil {
+		combinedScores := make(map[string]int, len(nodeNameToInfo))
+		for _, extender := range extenders {
+			wg.Add(1)
+			go func(ext algorithm.SchedulerExtender) {
+				defer wg.Done()
+				prioritizedList, weight, err := ext.Prioritize(pod, nodes)
+				if err != nil {
+					// Prioritization errors from extender can be ignored, let k8s/other extenders determine the priorities
+					return
+				}
+				mu.Lock()
+				for i := range *prioritizedList {
+					host, score := (*prioritizedList)[i].Host, (*prioritizedList)[i].Score
+					combinedScores[host] += score * weight
+				}
+				mu.Unlock()
+			}(extender)
+		}
+		// wait for all go routines to finish
+		wg.Wait()
+		for i := range result {
+			result[i].Score += combinedScores[result[i].Host]
+		}
+	}
+
+	if glog.V(10) {
+		for i := range result {
+			glog.V(10).Infof("Host %s => Score %d", result[i].Host, result[i].Score)
+		}
+	}
+	return result, nil
+}
+
+// EqualPriority is a prioritizer function that gives an equal weight of one to all nodes
+func EqualPriorityMap(_ *v1.Pod, _ interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) {
+	node := nodeInfo.Node()
+	if node == nil {
+		return schedulerapi.HostPriority{}, fmt.Errorf("node not found")
+	}
+	return schedulerapi.HostPriority{
+		Host:  node.Name,
+		Score: 1,
+	}, nil
+}
+
+// pickOneNodeForPreemption chooses one node among the given nodes. It assumes
+// pods in each map entry are ordered by decreasing priority.
+// It picks a node based on the following criteria:
+// 1. A node with minimum highest priority victim is picked.
+// 2. Ties are broken by sum of priorities of all victims.
+// 3. If there are still ties, node with the minimum number of victims is picked.
+// 4. If there are still ties, the first such node is picked (sort of randomly).
+//TODO(bsalamat): Try to reuse the "nodeScore" slices in order to save GC time.
+func pickOneNodeForPreemption(nodesToPods map[*v1.Node][]*v1.Pod) *v1.Node {
+	type nodeScore struct {
+		node            *v1.Node
+		highestPriority int32
+		sumPriorities   int64
+		numPods         int
+	}
+	if len(nodesToPods) == 0 {
+		return nil
+	}
+	minHighestPriority := int32(math.MaxInt32)
+	minPriorityScores := []*nodeScore{}
+	for node, pods := range nodesToPods {
+		if len(pods) == 0 {
+			// We found a node that doesn't need any preemption. Return it!
+			// This should happen rarely when one or more pods are terminated between
+			// the time that scheduler tries to schedule the pod and the time that
+			// preemption logic tries to find nodes for preemption.
+			return node
+		}
+		// highestPodPriority is the highest priority among the victims on this node.
+		highestPodPriority := util.GetPodPriority(pods[0])
+		if highestPodPriority < minHighestPriority {
+			minHighestPriority = highestPodPriority
+			minPriorityScores = nil
+		}
+		if highestPodPriority == minHighestPriority {
+			minPriorityScores = append(minPriorityScores, &nodeScore{node: node, highestPriority: highestPodPriority, numPods: len(pods)})
+		}
+	}
+	if len(minPriorityScores) == 1 {
+		return minPriorityScores[0].node
+	}
+	// There are a few nodes with minimum highest priority victim. Find the
+	// smallest sum of priorities.
+	minSumPriorities := int64(math.MaxInt64)
+	minSumPriorityScores := []*nodeScore{}
+	for _, nodeScore := range minPriorityScores {
+		var sumPriorities int64
+		for _, pod := range nodesToPods[nodeScore.node] {
+			// We add MaxInt32+1 to all priorities to make all of them >= 0. This is
+			// needed so that a node with a few pods with negative priority is not
+			// picked over a node with a smaller number of pods with the same negative
+			// priority (and similar scenarios).
+			sumPriorities += int64(util.GetPodPriority(pod)) + int64(math.MaxInt32+1)
+		}
+		if sumPriorities < minSumPriorities {
+			minSumPriorities = sumPriorities
+			minSumPriorityScores = nil
+		}
+		nodeScore.sumPriorities = sumPriorities
+		if sumPriorities == minSumPriorities {
+			minSumPriorityScores = append(minSumPriorityScores, nodeScore)
+		}
+	}
+	if len(minSumPriorityScores) == 1 {
+		return minSumPriorityScores[0].node
+	}
+	// There are a few nodes with minimum highest priority victim and sum of priorities.
+	// Find one with the minimum number of pods.
+	minNumPods := math.MaxInt32
+	minNumPodScores := []*nodeScore{}
+	for _, nodeScore := range minSumPriorityScores {
+		if nodeScore.numPods < minNumPods {
+			minNumPods = nodeScore.numPods
+			minNumPodScores = nil
+		}
+		if nodeScore.numPods == minNumPods {
+			minNumPodScores = append(minNumPodScores, nodeScore)
+		}
+	}
+	// At this point, even if there are more than one node with the same score,
+	// return the first one.
+	if len(minNumPodScores) > 0 {
+		return minNumPodScores[0].node
+	}
+	glog.Errorf("Error in logic of node scoring for preemption. We should never reach here!")
+	return nil
+}
+
+// selectNodesForPreemption finds all the nodes with possible victims for
+// preemption in parallel.
+func selectNodesForPreemption(pod *v1.Pod,
+	nodeNameToInfo map[string]*schedulercache.NodeInfo,
+	potentialNodes []*v1.Node,
+	predicates map[string]algorithm.FitPredicate,
+	metadataProducer algorithm.PredicateMetadataProducer,
+) (map[*v1.Node][]*v1.Pod, error) {
+
+	nodeNameToPods := map[*v1.Node][]*v1.Pod{}
+	var resultLock sync.Mutex
+
+	// We can use the same metadata producer for all nodes.
+	meta := metadataProducer(pod, nodeNameToInfo)
+	checkNode := func(i int) {
+		nodeName := potentialNodes[i].Name
+		var metaCopy algorithm.PredicateMetadata
+		if meta != nil {
+			metaCopy = meta.ShallowCopy()
+		}
+		pods, fits := selectVictimsOnNode(pod, metaCopy, nodeNameToInfo[nodeName], predicates)
+		if fits {
+			resultLock.Lock()
+			nodeNameToPods[potentialNodes[i]] = pods
+			resultLock.Unlock()
+		}
+	}
+	workqueue.Parallelize(16, len(potentialNodes), checkNode)
+	return nodeNameToPods, nil
+}
+
+func nodePassesExtendersForPreemption(
+	pod *v1.Pod,
+	nodeName string,
+	victims []*v1.Pod,
+	nodeNameToInfo map[string]*schedulercache.NodeInfo,
+	extenders []algorithm.SchedulerExtender) (bool, error) {
+	// If there are any extenders, run them and filter the list of candidate nodes.
+	if len(extenders) == 0 {
+		return true, nil
+	}
+	// Remove the victims from the corresponding nodeInfo and send nodes to the
+	// extenders for filtering.
+	originalNodeInfo := nodeNameToInfo[nodeName]
+	nodeInfoCopy := nodeNameToInfo[nodeName].Clone()
+	for _, victim := range victims {
+		nodeInfoCopy.RemovePod(victim)
+	}
+	nodeNameToInfo[nodeName] = nodeInfoCopy
+	defer func() { nodeNameToInfo[nodeName] = originalNodeInfo }()
+	filteredNodes := []*v1.Node{nodeInfoCopy.Node()}
+	for _, extender := range extenders {
+		var err error
+		var failedNodesMap map[string]string
+		filteredNodes, failedNodesMap, err = extender.Filter(pod, filteredNodes, nodeNameToInfo)
+		if err != nil {
+			return false, err
+		}
+		if _, found := failedNodesMap[nodeName]; found || len(filteredNodes) == 0 {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+// selectVictimsOnNode finds minimum set of pods on the given node that should
+// be preempted in order to make enough room for "pod" to be scheduled. The
+// minimum set selected is subject to the constraint that a higher-priority pod
+// is never preempted when a lower-priority pod could be (higher/lower relative
+// to one another, not relative to the preemptor "pod").
+// The algorithm first checks if the pod can be scheduled on the node when all the
+// lower priority pods are gone. If so, it sorts all the lower priority pods by
+// their priority and starts from the highest priority one, tries to keep as
+// many of them as possible while checking that the "pod" can still fit on the node.
+// NOTE: This function assumes that it is never called if "pod" cannot be scheduled
+// due to pod affinity, node affinity, or node anti-affinity reasons. None of
+// these predicates can be satisfied by removing more pods from the node.
+// TODO(bsalamat): Add support for PodDisruptionBudget.
+func selectVictimsOnNode(
+	pod *v1.Pod,
+	meta algorithm.PredicateMetadata,
+	nodeInfo *schedulercache.NodeInfo,
+	fitPredicates map[string]algorithm.FitPredicate) ([]*v1.Pod, bool) {
+	potentialVictims := util.SortableList{CompFunc: util.HigherPriorityPod}
+	nodeInfoCopy := nodeInfo.Clone()
+
+	removePod := func(rp *v1.Pod) {
+		nodeInfoCopy.RemovePod(rp)
+		if meta != nil {
+			meta.RemovePod(rp)
+		}
+	}
+	addPod := func(ap *v1.Pod) {
+		nodeInfoCopy.AddPod(ap)
+		if meta != nil {
+			meta.AddPod(ap, nodeInfoCopy)
+		}
+	}
+	// As the first step, remove all the lower priority pods from the node and
+	// check if the given pod can be scheduled.
+	podPriority := util.GetPodPriority(pod)
+	for _, p := range nodeInfoCopy.Pods() {
+		if util.GetPodPriority(p) < podPriority {
+			potentialVictims.Items = append(potentialVictims.Items, p)
+			removePod(p)
+		}
+	}
+	potentialVictims.Sort()
+	// If the new pod does not fit after removing all the lower priority pods,
+	// we are almost done and this node is not suitable for preemption. The only condition
+	// that we should check is if the "pod" is failing to schedule due to pod affinity
+	// failure.
+	// TODO(bsalamat): Consider checking affinity to lower priority pods if feasible with reasonable performance.
+	if fits, _, err := podFitsOnNode(pod, meta, nodeInfoCopy, fitPredicates, nil); !fits {
+		if err != nil {
+			glog.Warningf("Encountered error while selecting victims on node %v: %v", nodeInfo.Node().Name, err)
+		}
+		return nil, false
+	}
+	victims := []*v1.Pod{}
+	// Try to reprieve as many pods as possible starting from the highest priority one.
+	for _, p := range potentialVictims.Items {
+		lpp := p.(*v1.Pod)
+		addPod(lpp)
+		if fits, _, _ := podFitsOnNode(pod, meta, nodeInfoCopy, fitPredicates, nil); !fits {
+			removePod(lpp)
+			victims = append(victims, lpp)
+			glog.V(5).Infof("Pod %v is a potential preemption victim on node %v.", lpp.Name, nodeInfo.Node().Name)
+		}
+	}
+	return victims, true
+}
+
+// nodesWherePreemptionMightHelp returns a list of nodes with failed predicates
+// that may be satisfied by removing pods from the node.
+func nodesWherePreemptionMightHelp(pod *v1.Pod, nodes []*v1.Node, failedPredicatesMap FailedPredicateMap) []*v1.Node {
+	potentialNodes := []*v1.Node{}
+	for _, node := range nodes {
+		unresolvableReasonExist := false
+		failedPredicates, found := failedPredicatesMap[node.Name]
+		// If we assume that scheduler looks at all nodes and populates the failedPredicateMap
+		// (which is the case today), the !found case should never happen, but we'd prefer
+		// to rely less on such assumptions in the code when checking does not impose
+		// significant overhead.
+		for _, failedPredicate := range failedPredicates {
+			switch failedPredicate {
+			case
+				predicates.ErrNodeSelectorNotMatch,
+				predicates.ErrPodNotMatchHostName,
+				predicates.ErrTaintsTolerationsNotMatch,
+				predicates.ErrNodeLabelPresenceViolated,
+				predicates.ErrNodeNotReady,
+				predicates.ErrNodeNetworkUnavailable,
+				predicates.ErrNodeUnschedulable,
+				predicates.ErrNodeUnknownCondition:
+				unresolvableReasonExist = true
+				break
+				// TODO(bsalamat): Please add affinity failure cases once we have specific affinity failure errors.
+			}
+		}
+		if !found || !unresolvableReasonExist {
+			glog.V(3).Infof("Node %v is a potential node for preemption.", node.Name)
+			potentialNodes = append(potentialNodes, node)
+		}
+	}
+	return potentialNodes
+}
+
+// podEligibleToPreemptOthers determines whether this pod should be considered
+// for preempting other pods or not. If this pod has already preempted other
+// pods and those are in their graceful termination period, it shouldn't be
+// considered for preemption.
+// We look at the node that is nominated for this pod and as long as there are
+// terminating pods on the node, we don't consider this for preempting more pods.
+// TODO(bsalamat): Revisit this algorithm once scheduling by priority is added.
+func podEligibleToPreemptOthers(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo) bool {
+	if nodeName, found := pod.Annotations[NominatedNodeAnnotationKey]; found {
+		if nodeInfo, found := nodeNameToInfo[nodeName]; found {
+			for _, p := range nodeInfo.Pods() {
+				if p.DeletionTimestamp != nil && util.GetPodPriority(p) < util.GetPodPriority(pod) {
+					// There is a terminating pod on the nominated node.
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+func NewGenericScheduler(
+	cache schedulercache.Cache,
+	eCache *EquivalenceCache,
+	predicates map[string]algorithm.FitPredicate,
+	predicateMetaProducer algorithm.PredicateMetadataProducer,
+	prioritizers []algorithm.PriorityConfig,
+	priorityMetaProducer algorithm.MetadataProducer,
+	extenders []algorithm.SchedulerExtender) algorithm.ScheduleAlgorithm {
+	return &genericScheduler{
+		cache:                 cache,
+		equivalenceCache:      eCache,
+		predicates:            predicates,
+		predicateMetaProducer: predicateMetaProducer,
+		prioritizers:          prioritizers,
+		priorityMetaProducer:  priorityMetaProducer,
+		extenders:             extenders,
+		cachedNodeInfoMap:     make(map[string]*schedulercache.NodeInfo),
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/factory/BUILD

@@ -0,0 +1,86 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "factory.go",
+        "plugins.go",
+    ],
+    deps = [
+        "//pkg/api/helper:go_default_library",
+        "//pkg/api/v1/pod:go_default_library",
+        "//pkg/kubelet/apis:go_default_library",
+        "//plugin/pkg/scheduler:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/predicates:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/api/validation:go_default_library",
+        "//plugin/pkg/scheduler/core:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/client-go/informers/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "factory_test.go",
+        "plugins_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/testing:go_default_library",
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/api:go_default_library",
+        "//plugin/pkg/scheduler/api/latest:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/util/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/factory/factory_test.go

@@ -0,0 +1,527 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package factory
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/informers"
+	clientset "k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/cache"
+	utiltesting "k8s.io/client-go/util/testing"
+	"k8s.io/kubernetes/pkg/api"
+	apitesting "k8s.io/kubernetes/pkg/api/testing"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	latestschedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api/latest"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+)
+
+const enableEquivalenceCache = true
+
+func TestCreate(t *testing.T) {
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+	factory.Create()
+}
+
+// Test configures a scheduler from a policies defined in a file
+// It combines some configurable predicate/priorities with some pre-defined ones
+func TestCreateFromConfig(t *testing.T) {
+	var configData []byte
+	var policy schedulerapi.Policy
+
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+
+	// Pre-register some predicate and priority functions
+	RegisterFitPredicate("PredicateOne", PredicateOne)
+	RegisterFitPredicate("PredicateTwo", PredicateTwo)
+	RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
+	RegisterPriorityFunction("PriorityTwo", PriorityTwo, 1)
+
+	configData = []byte(`{
+		"kind" : "Policy",
+		"apiVersion" : "v1",
+		"predicates" : [
+			{"name" : "TestZoneAffinity", "argument" : {"serviceAffinity" : {"labels" : ["zone"]}}},
+			{"name" : "TestRequireZone", "argument" : {"labelsPresence" : {"labels" : ["zone"], "presence" : true}}},
+			{"name" : "PredicateOne"},
+			{"name" : "PredicateTwo"}
+		],
+		"priorities" : [
+			{"name" : "RackSpread", "weight" : 3, "argument" : {"serviceAntiAffinity" : {"label" : "rack"}}},
+			{"name" : "PriorityOne", "weight" : 2},
+			{"name" : "PriorityTwo", "weight" : 1}		]
+	}`)
+	if err := runtime.DecodeInto(latestschedulerapi.Codec, configData, &policy); err != nil {
+		t.Errorf("Invalid configuration: %v", err)
+	}
+
+	factory.CreateFromConfig(policy)
+	hpa := factory.GetHardPodAffinitySymmetricWeight()
+	if hpa != v1.DefaultHardPodAffinitySymmetricWeight {
+		t.Errorf("Wrong hardPodAffinitySymmetricWeight, ecpected: %d, got: %d", v1.DefaultHardPodAffinitySymmetricWeight, hpa)
+	}
+}
+
+func TestCreateFromConfigWithHardPodAffinitySymmetricWeight(t *testing.T) {
+	var configData []byte
+	var policy schedulerapi.Policy
+
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+
+	// Pre-register some predicate and priority functions
+	RegisterFitPredicate("PredicateOne", PredicateOne)
+	RegisterFitPredicate("PredicateTwo", PredicateTwo)
+	RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
+	RegisterPriorityFunction("PriorityTwo", PriorityTwo, 1)
+
+	configData = []byte(`{
+		"kind" : "Policy",
+		"apiVersion" : "v1",
+		"predicates" : [
+			{"name" : "TestZoneAffinity", "argument" : {"serviceAffinity" : {"labels" : ["zone"]}}},
+			{"name" : "TestRequireZone", "argument" : {"labelsPresence" : {"labels" : ["zone"], "presence" : true}}},
+			{"name" : "PredicateOne"},
+			{"name" : "PredicateTwo"}
+		],
+		"priorities" : [
+			{"name" : "RackSpread", "weight" : 3, "argument" : {"serviceAntiAffinity" : {"label" : "rack"}}},
+			{"name" : "PriorityOne", "weight" : 2},
+			{"name" : "PriorityTwo", "weight" : 1}
+		],
+		"hardPodAffinitySymmetricWeight" : 10
+	}`)
+	if err := runtime.DecodeInto(latestschedulerapi.Codec, configData, &policy); err != nil {
+		t.Errorf("Invalid configuration: %v", err)
+	}
+	factory.CreateFromConfig(policy)
+	hpa := factory.GetHardPodAffinitySymmetricWeight()
+	if hpa != 10 {
+		t.Errorf("Wrong hardPodAffinitySymmetricWeight, ecpected: %d, got: %d", 10, hpa)
+	}
+}
+
+func TestCreateFromEmptyConfig(t *testing.T) {
+	var configData []byte
+	var policy schedulerapi.Policy
+
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+
+	configData = []byte(`{}`)
+	if err := runtime.DecodeInto(latestschedulerapi.Codec, configData, &policy); err != nil {
+		t.Errorf("Invalid configuration: %v", err)
+	}
+
+	factory.CreateFromConfig(policy)
+}
+
+func PredicateOne(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error) {
+	return true, nil, nil
+}
+
+func PredicateTwo(pod *v1.Pod, meta algorithm.PredicateMetadata, nodeInfo *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error) {
+	return true, nil, nil
+}
+
+func PriorityOne(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	return []schedulerapi.HostPriority{}, nil
+}
+
+func PriorityTwo(pod *v1.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
+	return []schedulerapi.HostPriority{}, nil
+}
+
+func TestDefaultErrorFunc(t *testing.T) {
+	testPod := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "bar"},
+		Spec:       apitesting.V1DeepEqualSafePodSpec(),
+	}
+	handler := utiltesting.FakeHandler{
+		StatusCode:   200,
+		ResponseBody: runtime.EncodeOrDie(util.Test.Codec(), testPod),
+		T:            t,
+	}
+	mux := http.NewServeMux()
+
+	// FakeHandler musn't be sent requests other than the one you want to test.
+	mux.Handle(util.Test.ResourcePath(string(v1.ResourcePods), "bar", "foo"), &handler)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+	queue := cache.NewFIFO(cache.MetaNamespaceKeyFunc)
+	podBackoff := util.CreatePodBackoff(1*time.Millisecond, 1*time.Second)
+	errFunc := factory.MakeDefaultErrorFunc(podBackoff, queue)
+
+	errFunc(testPod, nil)
+	for {
+		// This is a terrible way to do this but I plan on replacing this
+		// whole error handling system in the future. The test will time
+		// out if something doesn't work.
+		time.Sleep(10 * time.Millisecond)
+		got, exists, _ := queue.Get(testPod)
+		if !exists {
+			continue
+		}
+		handler.ValidateRequest(t, util.Test.ResourcePath(string(v1.ResourcePods), "bar", "foo"), "GET", nil)
+		if e, a := testPod, got; !reflect.DeepEqual(e, a) {
+			t.Errorf("Expected %v, got %v", e, a)
+		}
+		break
+	}
+}
+
+func TestNodeEnumerator(t *testing.T) {
+	testList := &v1.NodeList{
+		Items: []v1.Node{
+			{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "bar"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "baz"}},
+		},
+	}
+	me := nodeEnumerator{testList}
+
+	if e, a := 3, me.Len(); e != a {
+		t.Fatalf("expected %v, got %v", e, a)
+	}
+	for i := range testList.Items {
+		gotObj := me.Get(i)
+		if e, a := testList.Items[i].Name, gotObj.(*v1.Node).Name; e != a {
+			t.Errorf("Expected %v, got %v", e, a)
+		}
+		if e, a := &testList.Items[i], gotObj; !reflect.DeepEqual(e, a) {
+			t.Errorf("Expected %#v, got %v#", e, a)
+		}
+	}
+}
+
+func TestBind(t *testing.T) {
+	table := []struct {
+		binding *v1.Binding
+	}{
+		{binding: &v1.Binding{
+			ObjectMeta: metav1.ObjectMeta{
+				Namespace: metav1.NamespaceDefault,
+				Name:      "foo",
+			},
+			Target: v1.ObjectReference{
+				Name: "foohost.kubernetes.mydomain.com",
+			},
+		}},
+	}
+
+	for _, item := range table {
+		handler := utiltesting.FakeHandler{
+			StatusCode:   200,
+			ResponseBody: "",
+			T:            t,
+		}
+		server := httptest.NewServer(&handler)
+		defer server.Close()
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+		b := binder{client}
+
+		if err := b.Bind(item.binding); err != nil {
+			t.Errorf("Unexpected error: %v", err)
+			continue
+		}
+		expectedBody := runtime.EncodeOrDie(util.Test.Codec(), item.binding)
+		handler.ValidateRequest(t,
+			util.Test.SubResourcePath(string(v1.ResourcePods), metav1.NamespaceDefault, "foo", "binding"),
+			"POST", &expectedBody)
+	}
+}
+
+// TestResponsibleForPod tests if a pod with an annotation that should cause it to
+// be picked up by the default scheduler, is in fact picked by the default scheduler
+// Two schedulers are made in the test: one is default scheduler and other scheduler
+// is of name "foo-scheduler". A pod must be picked up by at most one of the two
+// schedulers.
+func TestResponsibleForPod(t *testing.T) {
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	// factory of "default-scheduler"
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factoryDefaultScheduler := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+	// factory of "foo-scheduler"
+	factoryFooScheduler := NewConfigFactory(
+		"foo-scheduler",
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		v1.DefaultHardPodAffinitySymmetricWeight,
+		enableEquivalenceCache,
+	)
+	// scheduler annotations to be tested
+	schedulerFitsDefault := "default-scheduler"
+	schedulerFitsFoo := "foo-scheduler"
+	schedulerFitsNone := "bar-scheduler"
+
+	tests := []struct {
+		pod             *v1.Pod
+		pickedByDefault bool
+		pickedByFoo     bool
+	}{
+		{
+			// pod with "spec.Schedulername=default-scheduler" should be picked
+			// by the scheduler of name "default-scheduler", NOT by the one of name "foo-scheduler"
+			pod:             &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "bar"}, Spec: v1.PodSpec{SchedulerName: schedulerFitsDefault}},
+			pickedByDefault: true,
+			pickedByFoo:     false,
+		},
+		{
+			// pod with "spec.SchedulerName=foo-scheduler" should be NOT
+			// be picked by the scheduler of name "default-scheduler", but by the one of name "foo-scheduler"
+			pod:             &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "bar"}, Spec: v1.PodSpec{SchedulerName: schedulerFitsFoo}},
+			pickedByDefault: false,
+			pickedByFoo:     true,
+		},
+		{
+			// pod with "spec.SchedulerName=foo-scheduler" should be NOT
+			// be picked by niether the scheduler of name "default-scheduler" nor the one of name "foo-scheduler"
+			pod:             &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "bar"}, Spec: v1.PodSpec{SchedulerName: schedulerFitsNone}},
+			pickedByDefault: false,
+			pickedByFoo:     false,
+		},
+	}
+
+	for _, test := range tests {
+		podOfDefault := factoryDefaultScheduler.ResponsibleForPod(test.pod)
+		podOfFoo := factoryFooScheduler.ResponsibleForPod(test.pod)
+		results := []bool{podOfDefault, podOfFoo}
+		expected := []bool{test.pickedByDefault, test.pickedByFoo}
+		if !reflect.DeepEqual(results, expected) {
+			t.Errorf("expected: {%v, %v}, got {%v, %v}", test.pickedByDefault, test.pickedByFoo, podOfDefault, podOfFoo)
+		}
+	}
+}
+
+func TestInvalidHardPodAffinitySymmetricWeight(t *testing.T) {
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	// TODO: Uncomment when fix #19254
+	// defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	// factory of "default-scheduler"
+	informerFactory := informers.NewSharedInformerFactory(client, 0)
+	factory := NewConfigFactory(
+		v1.DefaultSchedulerName,
+		client,
+		informerFactory.Core().V1().Nodes(),
+		informerFactory.Core().V1().Pods(),
+		informerFactory.Core().V1().PersistentVolumes(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
+		informerFactory.Core().V1().ReplicationControllers(),
+		informerFactory.Extensions().V1beta1().ReplicaSets(),
+		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().Services(),
+		-1,
+		enableEquivalenceCache,
+	)
+	_, err := factory.Create()
+	if err == nil {
+		t.Errorf("expected err: invalid hardPodAffinitySymmetricWeight, got nothing")
+	}
+}
+
+func TestInvalidFactoryArgs(t *testing.T) {
+	handler := utiltesting.FakeHandler{
+		StatusCode:   500,
+		ResponseBody: "",
+		T:            t,
+	}
+	server := httptest.NewServer(&handler)
+	defer server.Close()
+	client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+
+	testCases := []struct {
+		hardPodAffinitySymmetricWeight int
+		expectErr                      string
+	}{
+		{
+			hardPodAffinitySymmetricWeight: -1,
+			expectErr:                      "invalid hardPodAffinitySymmetricWeight: -1, must be in the range 0-100",
+		},
+		{
+			hardPodAffinitySymmetricWeight: 101,
+			expectErr:                      "invalid hardPodAffinitySymmetricWeight: 101, must be in the range 0-100",
+		},
+	}
+
+	for _, test := range testCases {
+		informerFactory := informers.NewSharedInformerFactory(client, 0)
+		factory := NewConfigFactory(
+			v1.DefaultSchedulerName,
+			client,
+			informerFactory.Core().V1().Nodes(),
+			informerFactory.Core().V1().Pods(),
+			informerFactory.Core().V1().PersistentVolumes(),
+			informerFactory.Core().V1().PersistentVolumeClaims(),
+			informerFactory.Core().V1().ReplicationControllers(),
+			informerFactory.Extensions().V1beta1().ReplicaSets(),
+			informerFactory.Apps().V1beta1().StatefulSets(),
+			informerFactory.Core().V1().Services(),
+			test.hardPodAffinitySymmetricWeight,
+			enableEquivalenceCache,
+		)
+		_, err := factory.Create()
+		if err == nil {
+			t.Errorf("expected err: %s, got nothing", test.expectErr)
+		}
+	}
+
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/factory/plugins.go

@@ -0,0 +1,471 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package factory
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+
+	"github.com/golang/glog"
+)
+
+// PluginFactoryArgs are passed to all plugin factory functions.
+type PluginFactoryArgs struct {
+	PodLister                      algorithm.PodLister
+	ServiceLister                  algorithm.ServiceLister
+	ControllerLister               algorithm.ControllerLister
+	ReplicaSetLister               algorithm.ReplicaSetLister
+	StatefulSetLister              algorithm.StatefulSetLister
+	NodeLister                     algorithm.NodeLister
+	NodeInfo                       predicates.NodeInfo
+	PVInfo                         predicates.PersistentVolumeInfo
+	PVCInfo                        predicates.PersistentVolumeClaimInfo
+	HardPodAffinitySymmetricWeight int
+}
+
+// MetadataProducerFactory produces MetadataProducer from the given args.
+// TODO: Rename this to PriorityMetadataProducerFactory.
+type MetadataProducerFactory func(PluginFactoryArgs) algorithm.MetadataProducer
+
+// PredicateMetadataProducerFactory produces PredicateMetadataProducer from the given args.
+type PredicateMetadataProducerFactory func(PluginFactoryArgs) algorithm.PredicateMetadataProducer
+
+// A FitPredicateFactory produces a FitPredicate from the given args.
+type FitPredicateFactory func(PluginFactoryArgs) algorithm.FitPredicate
+
+// DEPRECATED
+// Use Map-Reduce pattern for priority functions.
+// A PriorityFunctionFactory produces a PriorityConfig from the given args.
+type PriorityFunctionFactory func(PluginFactoryArgs) algorithm.PriorityFunction
+
+// A PriorityFunctionFactory produces map & reduce priority functions
+// from a given args.
+// FIXME: Rename to PriorityFunctionFactory.
+type PriorityFunctionFactory2 func(PluginFactoryArgs) (algorithm.PriorityMapFunction, algorithm.PriorityReduceFunction)
+
+// A PriorityConfigFactory produces a PriorityConfig from the given function and weight
+type PriorityConfigFactory struct {
+	Function          PriorityFunctionFactory
+	MapReduceFunction PriorityFunctionFactory2
+	Weight            int
+}
+
+var (
+	schedulerFactoryMutex sync.Mutex
+
+	// maps that hold registered algorithm types
+	fitPredicateMap        = make(map[string]FitPredicateFactory)
+	mandatoryFitPredicates = sets.NewString()
+	priorityFunctionMap    = make(map[string]PriorityConfigFactory)
+	algorithmProviderMap   = make(map[string]AlgorithmProviderConfig)
+
+	// Registered metadata producers
+	priorityMetadataProducer  MetadataProducerFactory
+	predicateMetadataProducer PredicateMetadataProducerFactory
+
+	// get equivalence pod function
+	getEquivalencePodFunc algorithm.GetEquivalencePodFunc
+)
+
+const (
+	DefaultProvider = "DefaultProvider"
+)
+
+type AlgorithmProviderConfig struct {
+	FitPredicateKeys     sets.String
+	PriorityFunctionKeys sets.String
+}
+
+// RegisterFitPredicate registers a fit predicate with the algorithm
+// registry. Returns the name with which the predicate was registered.
+func RegisterFitPredicate(name string, predicate algorithm.FitPredicate) string {
+	return RegisterFitPredicateFactory(name, func(PluginFactoryArgs) algorithm.FitPredicate { return predicate })
+}
+
+// RegisterMandatoryFitPredicate registers a fit predicate with the algorithm registry, the predicate is used by
+// kubelet, DaemonSet; it is always included in configuration. Returns the name with which the predicate was
+// registered.
+func RegisterMandatoryFitPredicate(name string, predicate algorithm.FitPredicate) string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	validateAlgorithmNameOrDie(name)
+	fitPredicateMap[name] = func(PluginFactoryArgs) algorithm.FitPredicate { return predicate }
+	mandatoryFitPredicates.Insert(name)
+	return name
+}
+
+// RegisterFitPredicateFactory registers a fit predicate factory with the
+// algorithm registry. Returns the name with which the predicate was registered.
+func RegisterFitPredicateFactory(name string, predicateFactory FitPredicateFactory) string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	validateAlgorithmNameOrDie(name)
+	fitPredicateMap[name] = predicateFactory
+	return name
+}
+
+// RegisterCustomFitPredicate registers a custom fit predicate with the algorithm registry.
+// Returns the name, with which the predicate was registered.
+func RegisterCustomFitPredicate(policy schedulerapi.PredicatePolicy) string {
+	var predicateFactory FitPredicateFactory
+	var ok bool
+
+	validatePredicateOrDie(policy)
+
+	// generate the predicate function, if a custom type is requested
+	if policy.Argument != nil {
+		if policy.Argument.ServiceAffinity != nil {
+			predicateFactory = func(args PluginFactoryArgs) algorithm.FitPredicate {
+				predicate, precomputationFunction := predicates.NewServiceAffinityPredicate(
+					args.PodLister,
+					args.ServiceLister,
+					args.NodeInfo,
+					policy.Argument.ServiceAffinity.Labels,
+				)
+
+				// Once we generate the predicate we should also Register the Precomputation
+				predicates.RegisterPredicateMetadataProducer(policy.Name, precomputationFunction)
+				return predicate
+			}
+		} else if policy.Argument.LabelsPresence != nil {
+			predicateFactory = func(args PluginFactoryArgs) algorithm.FitPredicate {
+				return predicates.NewNodeLabelPredicate(
+					policy.Argument.LabelsPresence.Labels,
+					policy.Argument.LabelsPresence.Presence,
+				)
+			}
+		}
+	} else if predicateFactory, ok = fitPredicateMap[policy.Name]; ok {
+		// checking to see if a pre-defined predicate is requested
+		glog.V(2).Infof("Predicate type %s already registered, reusing.", policy.Name)
+		return policy.Name
+	}
+
+	if predicateFactory == nil {
+		glog.Fatalf("Invalid configuration: Predicate type not found for %s", policy.Name)
+	}
+
+	return RegisterFitPredicateFactory(policy.Name, predicateFactory)
+}
+
+// IsFitPredicateRegistered is useful for testing providers.
+func IsFitPredicateRegistered(name string) bool {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	_, ok := fitPredicateMap[name]
+	return ok
+}
+
+func RegisterPriorityMetadataProducerFactory(factory MetadataProducerFactory) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	priorityMetadataProducer = factory
+}
+
+func RegisterPredicateMetadataProducerFactory(factory PredicateMetadataProducerFactory) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	predicateMetadataProducer = factory
+}
+
+// DEPRECATED
+// Use Map-Reduce pattern for priority functions.
+// Registers a priority function with the algorithm registry. Returns the name,
+// with which the function was registered.
+func RegisterPriorityFunction(name string, function algorithm.PriorityFunction, weight int) string {
+	return RegisterPriorityConfigFactory(name, PriorityConfigFactory{
+		Function: func(PluginFactoryArgs) algorithm.PriorityFunction {
+			return function
+		},
+		Weight: weight,
+	})
+}
+
+// RegisterPriorityFunction2 registers a priority function with the algorithm registry. Returns the name,
+// with which the function was registered.
+// FIXME: Rename to PriorityFunctionFactory.
+func RegisterPriorityFunction2(
+	name string,
+	mapFunction algorithm.PriorityMapFunction,
+	reduceFunction algorithm.PriorityReduceFunction,
+	weight int) string {
+	return RegisterPriorityConfigFactory(name, PriorityConfigFactory{
+		MapReduceFunction: func(PluginFactoryArgs) (algorithm.PriorityMapFunction, algorithm.PriorityReduceFunction) {
+			return mapFunction, reduceFunction
+		},
+		Weight: weight,
+	})
+}
+
+func RegisterPriorityConfigFactory(name string, pcf PriorityConfigFactory) string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	validateAlgorithmNameOrDie(name)
+	priorityFunctionMap[name] = pcf
+	return name
+}
+
+// RegisterCustomPriorityFunction registers a custom priority function with the algorithm registry.
+// Returns the name, with which the priority function was registered.
+func RegisterCustomPriorityFunction(policy schedulerapi.PriorityPolicy) string {
+	var pcf *PriorityConfigFactory
+
+	validatePriorityOrDie(policy)
+
+	// generate the priority function, if a custom priority is requested
+	if policy.Argument != nil {
+		if policy.Argument.ServiceAntiAffinity != nil {
+			pcf = &PriorityConfigFactory{
+				Function: func(args PluginFactoryArgs) algorithm.PriorityFunction {
+					return priorities.NewServiceAntiAffinityPriority(
+						args.PodLister,
+						args.ServiceLister,
+						policy.Argument.ServiceAntiAffinity.Label,
+					)
+				},
+				Weight: policy.Weight,
+			}
+		} else if policy.Argument.LabelPreference != nil {
+			pcf = &PriorityConfigFactory{
+				MapReduceFunction: func(args PluginFactoryArgs) (algorithm.PriorityMapFunction, algorithm.PriorityReduceFunction) {
+					return priorities.NewNodeLabelPriority(
+						policy.Argument.LabelPreference.Label,
+						policy.Argument.LabelPreference.Presence,
+					)
+				},
+				Weight: policy.Weight,
+			}
+		}
+	} else if existingPcf, ok := priorityFunctionMap[policy.Name]; ok {
+		glog.V(2).Infof("Priority type %s already registered, reusing.", policy.Name)
+		// set/update the weight based on the policy
+		pcf = &PriorityConfigFactory{
+			Function:          existingPcf.Function,
+			MapReduceFunction: existingPcf.MapReduceFunction,
+			Weight:            policy.Weight,
+		}
+	}
+
+	if pcf == nil {
+		glog.Fatalf("Invalid configuration: Priority type not found for %s", policy.Name)
+	}
+
+	return RegisterPriorityConfigFactory(policy.Name, *pcf)
+}
+
+func RegisterGetEquivalencePodFunction(equivalenceFunc algorithm.GetEquivalencePodFunc) {
+	getEquivalencePodFunc = equivalenceFunc
+}
+
+// IsPriorityFunctionRegistered is useful for testing providers.
+func IsPriorityFunctionRegistered(name string) bool {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	_, ok := priorityFunctionMap[name]
+	return ok
+}
+
+// RegisterAlgorithmProvider registers a new algorithm provider with the algorithm registry. This should
+// be called from the init function in a provider plugin.
+func RegisterAlgorithmProvider(name string, predicateKeys, priorityKeys sets.String) string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+	validateAlgorithmNameOrDie(name)
+	algorithmProviderMap[name] = AlgorithmProviderConfig{
+		FitPredicateKeys:     predicateKeys,
+		PriorityFunctionKeys: priorityKeys,
+	}
+	return name
+}
+
+// GetAlgorithmProvider should not be used to modify providers. It is publicly visible for testing.
+func GetAlgorithmProvider(name string) (*AlgorithmProviderConfig, error) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	provider, ok := algorithmProviderMap[name]
+	if !ok {
+		return nil, fmt.Errorf("plugin %q has not been registered", name)
+	}
+
+	return &provider, nil
+}
+
+func getFitPredicateFunctions(names sets.String, args PluginFactoryArgs) (map[string]algorithm.FitPredicate, error) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	predicates := map[string]algorithm.FitPredicate{}
+	for _, name := range names.List() {
+		factory, ok := fitPredicateMap[name]
+		if !ok {
+			return nil, fmt.Errorf("Invalid predicate name %q specified - no corresponding function found", name)
+		}
+		predicates[name] = factory(args)
+	}
+
+	// Always include mandatory fit predicates.
+	for name := range mandatoryFitPredicates {
+		if factory, found := fitPredicateMap[name]; found {
+			predicates[name] = factory(args)
+		}
+	}
+
+	return predicates, nil
+}
+
+func getPriorityMetadataProducer(args PluginFactoryArgs) (algorithm.MetadataProducer, error) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	if priorityMetadataProducer == nil {
+		return algorithm.EmptyMetadataProducer, nil
+	}
+	return priorityMetadataProducer(args), nil
+}
+
+func getPredicateMetadataProducer(args PluginFactoryArgs) (algorithm.PredicateMetadataProducer, error) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	if predicateMetadataProducer == nil {
+		return algorithm.EmptyPredicateMetadataProducer, nil
+	}
+	return predicateMetadataProducer(args), nil
+}
+
+func getPriorityFunctionConfigs(names sets.String, args PluginFactoryArgs) ([]algorithm.PriorityConfig, error) {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	configs := []algorithm.PriorityConfig{}
+	for _, name := range names.List() {
+		factory, ok := priorityFunctionMap[name]
+		if !ok {
+			return nil, fmt.Errorf("Invalid priority name %s specified - no corresponding function found", name)
+		}
+		if factory.Function != nil {
+			configs = append(configs, algorithm.PriorityConfig{
+				Function: factory.Function(args),
+				Weight:   factory.Weight,
+			})
+		} else {
+			mapFunction, reduceFunction := factory.MapReduceFunction(args)
+			configs = append(configs, algorithm.PriorityConfig{
+				Map:    mapFunction,
+				Reduce: reduceFunction,
+				Weight: factory.Weight,
+			})
+		}
+	}
+	if err := validateSelectedConfigs(configs); err != nil {
+		return nil, err
+	}
+	return configs, nil
+}
+
+// validateSelectedConfigs validates the config weights to avoid the overflow.
+func validateSelectedConfigs(configs []algorithm.PriorityConfig) error {
+	var totalPriority int
+	for _, config := range configs {
+		// Checks totalPriority against MaxTotalPriority to avoid overflow
+		if config.Weight*schedulerapi.MaxPriority > schedulerapi.MaxTotalPriority-totalPriority {
+			return fmt.Errorf("Total priority of priority functions has overflown")
+		}
+		totalPriority += config.Weight * schedulerapi.MaxPriority
+	}
+	return nil
+}
+
+var validName = regexp.MustCompile("^[a-zA-Z0-9]([-a-zA-Z0-9]*[a-zA-Z0-9])$")
+
+func validateAlgorithmNameOrDie(name string) {
+	if !validName.MatchString(name) {
+		glog.Fatalf("Algorithm name %v does not match the name validation regexp \"%v\".", name, validName)
+	}
+}
+
+func validatePredicateOrDie(predicate schedulerapi.PredicatePolicy) {
+	if predicate.Argument != nil {
+		numArgs := 0
+		if predicate.Argument.ServiceAffinity != nil {
+			numArgs++
+		}
+		if predicate.Argument.LabelsPresence != nil {
+			numArgs++
+		}
+		if numArgs != 1 {
+			glog.Fatalf("Exactly 1 predicate argument is required, numArgs: %v, Predicate: %s", numArgs, predicate.Name)
+		}
+	}
+}
+
+func validatePriorityOrDie(priority schedulerapi.PriorityPolicy) {
+	if priority.Argument != nil {
+		numArgs := 0
+		if priority.Argument.ServiceAntiAffinity != nil {
+			numArgs++
+		}
+		if priority.Argument.LabelPreference != nil {
+			numArgs++
+		}
+		if numArgs != 1 {
+			glog.Fatalf("Exactly 1 priority argument is required, numArgs: %v, Priority: %s", numArgs, priority.Name)
+		}
+	}
+}
+
+func ListRegisteredFitPredicates() []string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	names := []string{}
+	for name := range fitPredicateMap {
+		names = append(names, name)
+	}
+	return names
+}
+
+func ListRegisteredPriorityFunctions() []string {
+	schedulerFactoryMutex.Lock()
+	defer schedulerFactoryMutex.Unlock()
+
+	names := []string{}
+	for name := range priorityFunctionMap {
+		names = append(names, name)
+	}
+	return names
+}
+
+// ListAlgorithmProviders is called when listing all available algorithm providers in `kube-scheduler --help`
+func ListAlgorithmProviders() string {
+	var availableAlgorithmProviders []string
+	for name := range algorithmProviderMap {
+		availableAlgorithmProviders = append(availableAlgorithmProviders, name)
+	}
+	sort.Strings(availableAlgorithmProviders)
+	return strings.Join(availableAlgorithmProviders, " | ")
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/factory/plugins_test.go

@@ -0,0 +1,82 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package factory
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/api"
+)
+
+func TestAlgorithmNameValidation(t *testing.T) {
+	algorithmNamesShouldValidate := []string{
+		"1SomeAlgo1rithm",
+		"someAlgor-ithm1",
+	}
+	algorithmNamesShouldNotValidate := []string{
+		"-SomeAlgorithm",
+		"SomeAlgorithm-",
+		"Some,Alg:orithm",
+	}
+	for _, name := range algorithmNamesShouldValidate {
+		if !validName.MatchString(name) {
+			t.Errorf("%v should be a valid algorithm name but is not valid.", name)
+		}
+	}
+	for _, name := range algorithmNamesShouldNotValidate {
+		if validName.MatchString(name) {
+			t.Errorf("%v should be an invalid algorithm name but is valid.", name)
+		}
+	}
+}
+
+func TestValidatePriorityConfigOverFlow(t *testing.T) {
+	tests := []struct {
+		description string
+		configs     []algorithm.PriorityConfig
+		expected    bool
+	}{
+		{
+			description: "one of the weights is MaxInt",
+			configs:     []algorithm.PriorityConfig{{Weight: api.MaxInt}, {Weight: 5}},
+			expected:    true,
+		},
+		{
+			description: "after multiplication with MaxPriority the weight is larger than MaxWeight",
+			configs:     []algorithm.PriorityConfig{{Weight: api.MaxInt/api.MaxPriority + api.MaxPriority}, {Weight: 5}},
+			expected:    true,
+		},
+		{
+			description: "normal weights",
+			configs:     []algorithm.PriorityConfig{{Weight: 10000}, {Weight: 5}},
+			expected:    false,
+		},
+	}
+	for _, test := range tests {
+		err := validateSelectedConfigs(test.configs)
+		if test.expected {
+			if err == nil {
+				t.Errorf("Expected Overflow for %s", test.description)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Did not expect an overflow for %s", test.description)
+			}
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/metrics/BUILD

@@ -0,0 +1,25 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["metrics.go"],
+    deps = ["//vendor/github.com/prometheus/client_golang/prometheus:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/metrics/metrics.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"sync"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+const schedulerSubsystem = "scheduler"
+
+var BindingSaturationReportInterval = 1 * time.Second
+
+var (
+	E2eSchedulingLatency = prometheus.NewHistogram(
+		prometheus.HistogramOpts{
+			Subsystem: schedulerSubsystem,
+			Name:      "e2e_scheduling_latency_microseconds",
+			Help:      "E2e scheduling latency (scheduling algorithm + binding)",
+			Buckets:   prometheus.ExponentialBuckets(1000, 2, 15),
+		},
+	)
+	SchedulingAlgorithmLatency = prometheus.NewHistogram(
+		prometheus.HistogramOpts{
+			Subsystem: schedulerSubsystem,
+			Name:      "scheduling_algorithm_latency_microseconds",
+			Help:      "Scheduling algorithm latency",
+			Buckets:   prometheus.ExponentialBuckets(1000, 2, 15),
+		},
+	)
+	BindingLatency = prometheus.NewHistogram(
+		prometheus.HistogramOpts{
+			Subsystem: schedulerSubsystem,
+			Name:      "binding_latency_microseconds",
+			Help:      "Binding latency",
+			Buckets:   prometheus.ExponentialBuckets(1000, 2, 15),
+		},
+	)
+)
+
+var registerMetrics sync.Once
+
+// Register all metrics.
+func Register() {
+	// Register the metrics.
+	registerMetrics.Do(func() {
+		prometheus.MustRegister(E2eSchedulingLatency)
+		prometheus.MustRegister(SchedulingAlgorithmLatency)
+		prometheus.MustRegister(BindingLatency)
+	})
+}
+
+// Gets the time since the specified start in microseconds.
+func SinceInMicroseconds(start time.Time) float64 {
+	return float64(time.Since(start).Nanoseconds() / time.Microsecond.Nanoseconds())
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/scheduler.go

@@ -0,0 +1,341 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package scheduler
+
+import (
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/wait"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	clientset "k8s.io/client-go/kubernetes"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/features"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/core"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/metrics"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+
+	"github.com/golang/glog"
+)
+
+// Binder knows how to write a binding.
+type Binder interface {
+	Bind(binding *v1.Binding) error
+}
+
+// PodConditionUpdater updates the condition of a pod based on the passed
+// PodCondition
+type PodConditionUpdater interface {
+	Update(pod *v1.Pod, podCondition *v1.PodCondition) error
+}
+
+// PodPreemptor has methods needed to delete a pod and to update
+// annotations of the preemptor pod.
+type PodPreemptor interface {
+	GetUpdatedPod(pod *v1.Pod) (*v1.Pod, error)
+	DeletePod(pod *v1.Pod) error
+	UpdatePodAnnotations(pod *v1.Pod, annots map[string]string) error
+}
+
+// Scheduler watches for new unscheduled pods. It attempts to find
+// nodes that they fit on and writes bindings back to the api server.
+type Scheduler struct {
+	config *Config
+}
+
+// StopEverything closes the scheduler config's StopEverything channel, to shut
+// down the Scheduler.
+func (sched *Scheduler) StopEverything() {
+	close(sched.config.StopEverything)
+}
+
+// Configurator defines I/O, caching, and other functionality needed to
+// construct a new scheduler. An implementation of this can be seen in
+// factory.go.
+type Configurator interface {
+	GetPriorityFunctionConfigs(priorityKeys sets.String) ([]algorithm.PriorityConfig, error)
+	GetPriorityMetadataProducer() (algorithm.MetadataProducer, error)
+	GetPredicateMetadataProducer() (algorithm.PredicateMetadataProducer, error)
+	GetPredicates(predicateKeys sets.String) (map[string]algorithm.FitPredicate, error)
+	GetHardPodAffinitySymmetricWeight() int
+	GetSchedulerName() string
+	MakeDefaultErrorFunc(backoff *util.PodBackoff, podQueue *cache.FIFO) func(pod *v1.Pod, err error)
+
+	// Probably doesn't need to be public.  But exposed for now in case.
+	ResponsibleForPod(pod *v1.Pod) bool
+
+	// Needs to be exposed for things like integration tests where we want to make fake nodes.
+	GetNodeLister() corelisters.NodeLister
+	GetClient() clientset.Interface
+	GetScheduledPodLister() corelisters.PodLister
+
+	Create() (*Config, error)
+	CreateFromProvider(providerName string) (*Config, error)
+	CreateFromConfig(policy schedulerapi.Policy) (*Config, error)
+	CreateFromKeys(predicateKeys, priorityKeys sets.String, extenders []algorithm.SchedulerExtender) (*Config, error)
+}
+
+// Config is an implementation of the Scheduler's configured input data.
+// TODO over time we should make this struct a hidden implementation detail of the scheduler.
+type Config struct {
+	// It is expected that changes made via SchedulerCache will be observed
+	// by NodeLister and Algorithm.
+	SchedulerCache schedulercache.Cache
+	// Ecache is used for optimistically invalid affected cache items after
+	// successfully binding a pod
+	Ecache     *core.EquivalenceCache
+	NodeLister algorithm.NodeLister
+	Algorithm  algorithm.ScheduleAlgorithm
+	Binder     Binder
+	// PodConditionUpdater is used only in case of scheduling errors. If we succeed
+	// with scheduling, PodScheduled condition will be updated in apiserver in /bind
+	// handler so that binding and setting PodCondition it is atomic.
+	PodConditionUpdater PodConditionUpdater
+	// PodPreemptor is used to evict pods and update pod annotations.
+	PodPreemptor PodPreemptor
+
+	// NextPod should be a function that blocks until the next pod
+	// is available. We don't use a channel for this, because scheduling
+	// a pod may take some amount of time and we don't want pods to get
+	// stale while they sit in a channel.
+	NextPod func() *v1.Pod
+
+	// WaitForCacheSync waits for scheduler cache to populate.
+	// It returns true if it was successful, false if the controller should shutdown.
+	WaitForCacheSync func() bool
+
+	// Error is called if there is an error. It is passed the pod in
+	// question, and the error
+	Error func(*v1.Pod, error)
+
+	// Recorder is the EventRecorder to use
+	Recorder record.EventRecorder
+
+	// Close this to shut down the scheduler.
+	StopEverything chan struct{}
+}
+
+// NewFromConfigurator returns a new scheduler that is created entirely by the Configurator.  Assumes Create() is implemented.
+// Supports intermediate Config mutation for now if you provide modifier functions which will run after Config is created.
+func NewFromConfigurator(c Configurator, modifiers ...func(c *Config)) (*Scheduler, error) {
+	cfg, err := c.Create()
+	if err != nil {
+		return nil, err
+	}
+	// Mutate it if any functions were provided, changes might be required for certain types of tests (i.e. change the recorder).
+	for _, modifier := range modifiers {
+		modifier(cfg)
+	}
+	// From this point on the config is immutable to the outside.
+	s := &Scheduler{
+		config: cfg,
+	}
+	metrics.Register()
+	return s, nil
+}
+
+// Run begins watching and scheduling. It waits for cache to be synced, then starts a goroutine and returns immediately.
+func (sched *Scheduler) Run() {
+	if !sched.config.WaitForCacheSync() {
+		return
+	}
+
+	go wait.Until(sched.scheduleOne, 0, sched.config.StopEverything)
+}
+
+// Config return scheduler's config pointer. It is exposed for testing purposes.
+func (sched *Scheduler) Config() *Config {
+	return sched.config
+}
+
+// schedule implements the scheduling algorithm and returns the suggested host.
+func (sched *Scheduler) schedule(pod *v1.Pod) (string, error) {
+	host, err := sched.config.Algorithm.Schedule(pod, sched.config.NodeLister)
+	if err != nil {
+		glog.V(1).Infof("Failed to schedule pod: %v/%v", pod.Namespace, pod.Name)
+		pod = pod.DeepCopy()
+		sched.config.Error(pod, err)
+		sched.config.Recorder.Eventf(pod, v1.EventTypeWarning, "FailedScheduling", "%v", err)
+		sched.config.PodConditionUpdater.Update(pod, &v1.PodCondition{
+			Type:    v1.PodScheduled,
+			Status:  v1.ConditionFalse,
+			Reason:  v1.PodReasonUnschedulable,
+			Message: err.Error(),
+		})
+		return "", err
+	}
+	return host, err
+}
+
+func (sched *Scheduler) preempt(preemptor *v1.Pod, scheduleErr error) (string, error) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.PodPriority) {
+		glog.V(3).Infof("Pod priority feature is not enabled. No preemption is performed.")
+		return "", nil
+	}
+	preemptor, err := sched.config.PodPreemptor.GetUpdatedPod(preemptor)
+	if err != nil {
+		glog.Errorf("Error getting the updated preemptor pod object: %v", err)
+		return "", err
+	}
+	node, victims, err := sched.config.Algorithm.Preempt(preemptor, sched.config.NodeLister, scheduleErr)
+	if err != nil {
+		glog.Errorf("Error preempting victims to make room for %v/%v.", preemptor.Namespace, preemptor.Name)
+		return "", err
+	}
+	if node == nil {
+		return "", err
+	}
+	glog.Infof("Preempting %d pod(s) on node %v to make room for %v/%v.", len(victims), node.Name, preemptor.Namespace, preemptor.Name)
+	annotations := map[string]string{core.NominatedNodeAnnotationKey: node.Name}
+	err = sched.config.PodPreemptor.UpdatePodAnnotations(preemptor, annotations)
+	if err != nil {
+		glog.Errorf("Error in preemption process. Cannot update pod %v annotations: %v", preemptor.Name, err)
+		return "", err
+	}
+	for _, victim := range victims {
+		if err := sched.config.PodPreemptor.DeletePod(victim); err != nil {
+			glog.Errorf("Error preempting pod %v/%v: %v", victim.Namespace, victim.Name, err)
+			return "", err
+		}
+		sched.config.Recorder.Eventf(victim, v1.EventTypeNormal, "Preempted", "by %v/%v on node %v", preemptor.Namespace, preemptor.Name, node.Name)
+	}
+	return node.Name, err
+}
+
+// assume signals to the cache that a pod is already in the cache, so that binding can be asynchronous.
+// assume modifies `assumed`.
+func (sched *Scheduler) assume(assumed *v1.Pod, host string) error {
+	// Optimistically assume that the binding will succeed and send it to apiserver
+	// in the background.
+	// If the binding fails, scheduler will release resources allocated to assumed pod
+	// immediately.
+	assumed.Spec.NodeName = host
+	if err := sched.config.SchedulerCache.AssumePod(assumed); err != nil {
+		glog.Errorf("scheduler cache AssumePod failed: %v", err)
+
+		// This is most probably result of a BUG in retrying logic.
+		// We report an error here so that pod scheduling can be retried.
+		// This relies on the fact that Error will check if the pod has been bound
+		// to a node and if so will not add it back to the unscheduled pods queue
+		// (otherwise this would cause an infinite loop).
+		sched.config.Error(assumed, err)
+		sched.config.Recorder.Eventf(assumed, v1.EventTypeWarning, "FailedScheduling", "AssumePod failed: %v", err)
+		sched.config.PodConditionUpdater.Update(assumed, &v1.PodCondition{
+			Type:    v1.PodScheduled,
+			Status:  v1.ConditionFalse,
+			Reason:  "SchedulerError",
+			Message: err.Error(),
+		})
+		return err
+	}
+
+	// Optimistically assume that the binding will succeed, so we need to invalidate affected
+	// predicates in equivalence cache.
+	// If the binding fails, these invalidated item will not break anything.
+	if sched.config.Ecache != nil {
+		sched.config.Ecache.InvalidateCachedPredicateItemForPodAdd(assumed, host)
+	}
+	return nil
+}
+
+// bind binds a pod to a given node defined in a binding object.  We expect this to run asynchronously, so we
+// handle binding metrics internally.
+func (sched *Scheduler) bind(assumed *v1.Pod, b *v1.Binding) error {
+	bindingStart := time.Now()
+	// If binding succeeded then PodScheduled condition will be updated in apiserver so that
+	// it's atomic with setting host.
+	err := sched.config.Binder.Bind(b)
+	if err := sched.config.SchedulerCache.FinishBinding(assumed); err != nil {
+		glog.Errorf("scheduler cache FinishBinding failed: %v", err)
+	}
+	if err != nil {
+		glog.V(1).Infof("Failed to bind pod: %v/%v", assumed.Namespace, assumed.Name)
+		if err := sched.config.SchedulerCache.ForgetPod(assumed); err != nil {
+			glog.Errorf("scheduler cache ForgetPod failed: %v", err)
+		}
+		sched.config.Error(assumed, err)
+		sched.config.Recorder.Eventf(assumed, v1.EventTypeWarning, "FailedScheduling", "Binding rejected: %v", err)
+		sched.config.PodConditionUpdater.Update(assumed, &v1.PodCondition{
+			Type:   v1.PodScheduled,
+			Status: v1.ConditionFalse,
+			Reason: "BindingRejected",
+		})
+		return err
+	}
+
+	metrics.BindingLatency.Observe(metrics.SinceInMicroseconds(bindingStart))
+	sched.config.Recorder.Eventf(assumed, v1.EventTypeNormal, "Scheduled", "Successfully assigned %v to %v", assumed.Name, b.Target.Name)
+	return nil
+}
+
+// scheduleOne does the entire scheduling workflow for a single pod.  It is serialized on the scheduling algorithm's host fitting.
+func (sched *Scheduler) scheduleOne() {
+	pod := sched.config.NextPod()
+	if pod.DeletionTimestamp != nil {
+		sched.config.Recorder.Eventf(pod, v1.EventTypeWarning, "FailedScheduling", "skip schedule deleting pod: %v/%v", pod.Namespace, pod.Name)
+		glog.V(3).Infof("Skip schedule deleting pod: %v/%v", pod.Namespace, pod.Name)
+		return
+	}
+
+	glog.V(3).Infof("Attempting to schedule pod: %v/%v", pod.Namespace, pod.Name)
+
+	// Synchronously attempt to find a fit for the pod.
+	start := time.Now()
+	suggestedHost, err := sched.schedule(pod)
+	metrics.SchedulingAlgorithmLatency.Observe(metrics.SinceInMicroseconds(start))
+	if err != nil {
+		// schedule() may have failed because the pod would not fit on any host, so we try to
+		// preempt, with the expectation that the next time the pod is tried for scheduling it
+		// will fit due to the preemption. It is also possible that a different pod will schedule
+		// into the resources that were preempted, but this is harmless.
+		if fitError, ok := err.(*core.FitError); ok {
+			sched.preempt(pod, fitError)
+		}
+		return
+	}
+
+	// Tell the cache to assume that a pod now is running on a given node, even though it hasn't been bound yet.
+	// This allows us to keep scheduling without waiting on binding to occur.
+	assumedPod := *pod
+	// assume modifies `assumedPod` by setting NodeName=suggestedHost
+	err = sched.assume(&assumedPod, suggestedHost)
+	if err != nil {
+		return
+	}
+
+	// bind the pod to its host asynchronously (we can do this b/c of the assumption step above).
+	go func() {
+		err := sched.bind(&assumedPod, &v1.Binding{
+			ObjectMeta: metav1.ObjectMeta{Namespace: assumedPod.Namespace, Name: assumedPod.Name, UID: assumedPod.UID},
+			Target: v1.ObjectReference{
+				Kind: "Node",
+				Name: suggestedHost,
+			},
+		})
+		metrics.E2eSchedulingLatency.Observe(metrics.SinceInMicroseconds(start))
+		if err != nil {
+			glog.Errorf("Internal error binding pod: (%v)", err)
+		}
+	}()
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/scheduler_test.go

@@ -0,0 +1,576 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package scheduler
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientcache "k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/predicates"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/core"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+	schedulertesting "k8s.io/kubernetes/plugin/pkg/scheduler/testing"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+)
+
+type fakeBinder struct {
+	b func(binding *v1.Binding) error
+}
+
+func (fb fakeBinder) Bind(binding *v1.Binding) error { return fb.b(binding) }
+
+type fakePodConditionUpdater struct{}
+
+func (fc fakePodConditionUpdater) Update(pod *v1.Pod, podCondition *v1.PodCondition) error {
+	return nil
+}
+
+func podWithID(id, desiredHost string) *v1.Pod {
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: id, SelfLink: util.Test.SelfLink(string(v1.ResourcePods), id)},
+		Spec: v1.PodSpec{
+			NodeName: desiredHost,
+		},
+	}
+}
+
+func deletingPod(id string) *v1.Pod {
+	deletionTimestamp := metav1.Now()
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: id, SelfLink: util.Test.SelfLink(string(v1.ResourcePods), id), DeletionTimestamp: &deletionTimestamp},
+		Spec: v1.PodSpec{
+			NodeName: "",
+		},
+	}
+}
+
+func podWithPort(id, desiredHost string, port int) *v1.Pod {
+	pod := podWithID(id, desiredHost)
+	pod.Spec.Containers = []v1.Container{
+		{Name: "ctr", Ports: []v1.ContainerPort{{HostPort: int32(port)}}},
+	}
+	return pod
+}
+
+func podWithResources(id, desiredHost string, limits v1.ResourceList, requests v1.ResourceList) *v1.Pod {
+	pod := podWithID(id, desiredHost)
+	pod.Spec.Containers = []v1.Container{
+		{Name: "ctr", Resources: v1.ResourceRequirements{Limits: limits, Requests: requests}},
+	}
+	return pod
+}
+
+type mockScheduler struct {
+	machine string
+	err     error
+}
+
+func (es mockScheduler) Schedule(pod *v1.Pod, ml algorithm.NodeLister) (string, error) {
+	return es.machine, es.err
+}
+
+func (es mockScheduler) Predicates() map[string]algorithm.FitPredicate {
+	return nil
+}
+func (es mockScheduler) Prioritizers() []algorithm.PriorityConfig {
+	return nil
+}
+
+func (es mockScheduler) Preempt(pod *v1.Pod, nodeLister algorithm.NodeLister, scheduleErr error) (*v1.Node, []*v1.Pod, error) {
+	return nil, nil, nil
+}
+
+func TestScheduler(t *testing.T) {
+	eventBroadcaster := record.NewBroadcaster()
+	eventBroadcaster.StartLogging(t.Logf).Stop()
+	errS := errors.New("scheduler")
+	errB := errors.New("binder")
+	testNode := v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "machine1"}}
+
+	table := []struct {
+		injectBindError  error
+		sendPod          *v1.Pod
+		algo             algorithm.ScheduleAlgorithm
+		expectErrorPod   *v1.Pod
+		expectForgetPod  *v1.Pod
+		expectAssumedPod *v1.Pod
+		expectError      error
+		expectBind       *v1.Binding
+		eventReason      string
+	}{
+		{
+			sendPod:          podWithID("foo", ""),
+			algo:             mockScheduler{testNode.Name, nil},
+			expectBind:       &v1.Binding{ObjectMeta: metav1.ObjectMeta{Name: "foo"}, Target: v1.ObjectReference{Kind: "Node", Name: testNode.Name}},
+			expectAssumedPod: podWithID("foo", testNode.Name),
+			eventReason:      "Scheduled",
+		}, {
+			sendPod:        podWithID("foo", ""),
+			algo:           mockScheduler{testNode.Name, errS},
+			expectError:    errS,
+			expectErrorPod: podWithID("foo", ""),
+			eventReason:    "FailedScheduling",
+		}, {
+			sendPod:          podWithID("foo", ""),
+			algo:             mockScheduler{testNode.Name, nil},
+			expectBind:       &v1.Binding{ObjectMeta: metav1.ObjectMeta{Name: "foo"}, Target: v1.ObjectReference{Kind: "Node", Name: testNode.Name}},
+			expectAssumedPod: podWithID("foo", testNode.Name),
+			injectBindError:  errB,
+			expectError:      errB,
+			expectErrorPod:   podWithID("foo", testNode.Name),
+			expectForgetPod:  podWithID("foo", testNode.Name),
+			eventReason:      "FailedScheduling",
+		}, {
+			sendPod:     deletingPod("foo"),
+			algo:        mockScheduler{"", nil},
+			eventReason: "FailedScheduling",
+		},
+	}
+
+	for i, item := range table {
+		var gotError error
+		var gotPod *v1.Pod
+		var gotForgetPod *v1.Pod
+		var gotAssumedPod *v1.Pod
+		var gotBinding *v1.Binding
+		configurator := &FakeConfigurator{
+			Config: &Config{
+				SchedulerCache: &schedulertesting.FakeCache{
+					ForgetFunc: func(pod *v1.Pod) {
+						gotForgetPod = pod
+					},
+					AssumeFunc: func(pod *v1.Pod) {
+						gotAssumedPod = pod
+					},
+				},
+				NodeLister: schedulertesting.FakeNodeLister(
+					[]*v1.Node{&testNode},
+				),
+				Algorithm: item.algo,
+				Binder: fakeBinder{func(b *v1.Binding) error {
+					gotBinding = b
+					return item.injectBindError
+				}},
+				PodConditionUpdater: fakePodConditionUpdater{},
+				Error: func(p *v1.Pod, err error) {
+					gotPod = p
+					gotError = err
+				},
+				NextPod: func() *v1.Pod {
+					return item.sendPod
+				},
+				Recorder: eventBroadcaster.NewRecorder(api.Scheme, v1.EventSource{Component: "scheduler"}),
+			},
+		}
+
+		s, _ := NewFromConfigurator(configurator, nil...)
+		called := make(chan struct{})
+		events := eventBroadcaster.StartEventWatcher(func(e *v1.Event) {
+			if e, a := item.eventReason, e.Reason; e != a {
+				t.Errorf("%v: expected %v, got %v", i, e, a)
+			}
+			close(called)
+		})
+		s.scheduleOne()
+		<-called
+		if e, a := item.expectAssumedPod, gotAssumedPod; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: assumed pod: wanted %v, got %v", i, e, a)
+		}
+		if e, a := item.expectErrorPod, gotPod; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: error pod: wanted %v, got %v", i, e, a)
+		}
+		if e, a := item.expectForgetPod, gotForgetPod; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: forget pod: wanted %v, got %v", i, e, a)
+		}
+		if e, a := item.expectError, gotError; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: error: wanted %v, got %v", i, e, a)
+		}
+		if e, a := item.expectBind, gotBinding; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: error: %s", i, diff.ObjectDiff(e, a))
+		}
+		events.Stop()
+	}
+}
+
+func TestSchedulerNoPhantomPodAfterExpire(t *testing.T) {
+	stop := make(chan struct{})
+	defer close(stop)
+	queuedPodStore := clientcache.NewFIFO(clientcache.MetaNamespaceKeyFunc)
+	scache := schedulercache.New(100*time.Millisecond, stop)
+	pod := podWithPort("pod.Name", "", 8080)
+	node := v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "machine1"}}
+	scache.AddNode(&node)
+	nodeLister := schedulertesting.FakeNodeLister([]*v1.Node{&node})
+	predicateMap := map[string]algorithm.FitPredicate{"PodFitsHostPorts": predicates.PodFitsHostPorts}
+	scheduler, bindingChan, _ := setupTestSchedulerWithOnePodOnNode(t, queuedPodStore, scache, nodeLister, predicateMap, pod, &node)
+
+	waitPodExpireChan := make(chan struct{})
+	timeout := make(chan struct{})
+	go func() {
+		for {
+			select {
+			case <-timeout:
+				return
+			default:
+			}
+			pods, err := scache.List(labels.Everything())
+			if err != nil {
+				t.Fatalf("cache.List failed: %v", err)
+			}
+			if len(pods) == 0 {
+				close(waitPodExpireChan)
+				return
+			}
+			time.Sleep(100 * time.Millisecond)
+		}
+	}()
+	// waiting for the assumed pod to expire
+	select {
+	case <-waitPodExpireChan:
+	case <-time.After(wait.ForeverTestTimeout):
+		close(timeout)
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+
+	// We use conflicted pod ports to incur fit predicate failure if first pod not removed.
+	secondPod := podWithPort("bar", "", 8080)
+	queuedPodStore.Add(secondPod)
+	scheduler.scheduleOne()
+	select {
+	case b := <-bindingChan:
+		expectBinding := &v1.Binding{
+			ObjectMeta: metav1.ObjectMeta{Name: "bar"},
+			Target:     v1.ObjectReference{Kind: "Node", Name: node.Name},
+		}
+		if !reflect.DeepEqual(expectBinding, b) {
+			t.Errorf("binding want=%v, get=%v", expectBinding, b)
+		}
+	case <-time.After(wait.ForeverTestTimeout):
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+}
+
+func TestSchedulerNoPhantomPodAfterDelete(t *testing.T) {
+	stop := make(chan struct{})
+	defer close(stop)
+	queuedPodStore := clientcache.NewFIFO(clientcache.MetaNamespaceKeyFunc)
+	scache := schedulercache.New(10*time.Minute, stop)
+	firstPod := podWithPort("pod.Name", "", 8080)
+	node := v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "machine1"}}
+	scache.AddNode(&node)
+	nodeLister := schedulertesting.FakeNodeLister([]*v1.Node{&node})
+	predicateMap := map[string]algorithm.FitPredicate{"PodFitsHostPorts": predicates.PodFitsHostPorts}
+	scheduler, bindingChan, errChan := setupTestSchedulerWithOnePodOnNode(t, queuedPodStore, scache, nodeLister, predicateMap, firstPod, &node)
+
+	// We use conflicted pod ports to incur fit predicate failure.
+	secondPod := podWithPort("bar", "", 8080)
+	queuedPodStore.Add(secondPod)
+	// queuedPodStore: [bar:8080]
+	// cache: [(assumed)foo:8080]
+
+	scheduler.scheduleOne()
+	select {
+	case err := <-errChan:
+		expectErr := &core.FitError{
+			Pod:              secondPod,
+			FailedPredicates: core.FailedPredicateMap{node.Name: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts}},
+		}
+		if !reflect.DeepEqual(expectErr, err) {
+			t.Errorf("err want=%v, get=%v", expectErr, err)
+		}
+	case <-time.After(wait.ForeverTestTimeout):
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+
+	// We mimic the workflow of cache behavior when a pod is removed by user.
+	// Note: if the schedulercache timeout would be super short, the first pod would expire
+	// and would be removed itself (without any explicit actions on schedulercache). Even in that case,
+	// explicitly AddPod will as well correct the behavior.
+	firstPod.Spec.NodeName = node.Name
+	if err := scache.AddPod(firstPod); err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if err := scache.RemovePod(firstPod); err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	queuedPodStore.Add(secondPod)
+	scheduler.scheduleOne()
+	select {
+	case b := <-bindingChan:
+		expectBinding := &v1.Binding{
+			ObjectMeta: metav1.ObjectMeta{Name: "bar"},
+			Target:     v1.ObjectReference{Kind: "Node", Name: node.Name},
+		}
+		if !reflect.DeepEqual(expectBinding, b) {
+			t.Errorf("binding want=%v, get=%v", expectBinding, b)
+		}
+	case <-time.After(wait.ForeverTestTimeout):
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+}
+
+// Scheduler should preserve predicate constraint even if binding was longer
+// than cache ttl
+func TestSchedulerErrorWithLongBinding(t *testing.T) {
+	stop := make(chan struct{})
+	defer close(stop)
+
+	firstPod := podWithPort("foo", "", 8080)
+	conflictPod := podWithPort("bar", "", 8080)
+	pods := map[string]*v1.Pod{firstPod.Name: firstPod, conflictPod.Name: conflictPod}
+	for _, test := range []struct {
+		Expected        map[string]bool
+		CacheTTL        time.Duration
+		BindingDuration time.Duration
+	}{
+		{
+			Expected:        map[string]bool{firstPod.Name: true},
+			CacheTTL:        100 * time.Millisecond,
+			BindingDuration: 300 * time.Millisecond,
+		},
+		{
+			Expected:        map[string]bool{firstPod.Name: true},
+			CacheTTL:        10 * time.Second,
+			BindingDuration: 300 * time.Millisecond,
+		},
+	} {
+		queuedPodStore := clientcache.NewFIFO(clientcache.MetaNamespaceKeyFunc)
+		scache := schedulercache.New(test.CacheTTL, stop)
+
+		node := v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "machine1"}}
+		scache.AddNode(&node)
+
+		nodeLister := schedulertesting.FakeNodeLister([]*v1.Node{&node})
+		predicateMap := map[string]algorithm.FitPredicate{"PodFitsHostPorts": predicates.PodFitsHostPorts}
+
+		scheduler, bindingChan := setupTestSchedulerLongBindingWithRetry(
+			queuedPodStore, scache, nodeLister, predicateMap, stop, test.BindingDuration)
+		scheduler.Run()
+		queuedPodStore.Add(firstPod)
+		queuedPodStore.Add(conflictPod)
+
+		resultBindings := map[string]bool{}
+		waitChan := time.After(5 * time.Second)
+		for finished := false; !finished; {
+			select {
+			case b := <-bindingChan:
+				resultBindings[b.Name] = true
+				p := pods[b.Name]
+				p.Spec.NodeName = b.Target.Name
+				scache.AddPod(p)
+			case <-waitChan:
+				finished = true
+			}
+		}
+		if !reflect.DeepEqual(resultBindings, test.Expected) {
+			t.Errorf("Result binding are not equal to expected. %v != %v", resultBindings, test.Expected)
+		}
+	}
+}
+
+// queuedPodStore: pods queued before processing.
+// cache: scheduler cache that might contain assumed pods.
+func setupTestSchedulerWithOnePodOnNode(t *testing.T, queuedPodStore *clientcache.FIFO, scache schedulercache.Cache,
+	nodeLister schedulertesting.FakeNodeLister, predicateMap map[string]algorithm.FitPredicate, pod *v1.Pod, node *v1.Node) (*Scheduler, chan *v1.Binding, chan error) {
+
+	scheduler, bindingChan, errChan := setupTestScheduler(queuedPodStore, scache, nodeLister, predicateMap)
+
+	queuedPodStore.Add(pod)
+	// queuedPodStore: [foo:8080]
+	// cache: []
+
+	scheduler.scheduleOne()
+	// queuedPodStore: []
+	// cache: [(assumed)foo:8080]
+
+	select {
+	case b := <-bindingChan:
+		expectBinding := &v1.Binding{
+			ObjectMeta: metav1.ObjectMeta{Name: pod.Name},
+			Target:     v1.ObjectReference{Kind: "Node", Name: node.Name},
+		}
+		if !reflect.DeepEqual(expectBinding, b) {
+			t.Errorf("binding want=%v, get=%v", expectBinding, b)
+		}
+	case <-time.After(wait.ForeverTestTimeout):
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+	return scheduler, bindingChan, errChan
+}
+
+func TestSchedulerFailedSchedulingReasons(t *testing.T) {
+	stop := make(chan struct{})
+	defer close(stop)
+	queuedPodStore := clientcache.NewFIFO(clientcache.MetaNamespaceKeyFunc)
+	scache := schedulercache.New(10*time.Minute, stop)
+
+	// Design the baseline for the pods, and we will make nodes that dont fit it later.
+	var cpu = int64(4)
+	var mem = int64(500)
+	podWithTooBigResourceRequests := podWithResources("bar", "", v1.ResourceList{
+		v1.ResourceCPU:    *(resource.NewQuantity(cpu, resource.DecimalSI)),
+		v1.ResourceMemory: *(resource.NewQuantity(mem, resource.DecimalSI)),
+	}, v1.ResourceList{
+		v1.ResourceCPU:    *(resource.NewQuantity(cpu, resource.DecimalSI)),
+		v1.ResourceMemory: *(resource.NewQuantity(mem, resource.DecimalSI)),
+	})
+
+	// create several nodes which cannot schedule the above pod
+	nodes := []*v1.Node{}
+	for i := 0; i < 100; i++ {
+		node := v1.Node{
+			ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("machine%v", i)},
+			Status: v1.NodeStatus{
+				Capacity: v1.ResourceList{
+					v1.ResourceCPU:    *(resource.NewQuantity(cpu/2, resource.DecimalSI)),
+					v1.ResourceMemory: *(resource.NewQuantity(mem/5, resource.DecimalSI)),
+					v1.ResourcePods:   *(resource.NewQuantity(10, resource.DecimalSI)),
+				},
+				Allocatable: v1.ResourceList{
+					v1.ResourceCPU:    *(resource.NewQuantity(cpu/2, resource.DecimalSI)),
+					v1.ResourceMemory: *(resource.NewQuantity(mem/5, resource.DecimalSI)),
+					v1.ResourcePods:   *(resource.NewQuantity(10, resource.DecimalSI)),
+				}},
+		}
+		scache.AddNode(&node)
+		nodes = append(nodes, &node)
+	}
+	nodeLister := schedulertesting.FakeNodeLister(nodes)
+	predicateMap := map[string]algorithm.FitPredicate{
+		"PodFitsResources": predicates.PodFitsResources,
+	}
+
+	// Create expected failure reasons for all the nodes.  Hopefully they will get rolled up into a non-spammy summary.
+	failedPredicatesMap := core.FailedPredicateMap{}
+	for _, node := range nodes {
+		failedPredicatesMap[node.Name] = []algorithm.PredicateFailureReason{
+			predicates.NewInsufficientResourceError(v1.ResourceCPU, 4000, 0, 2000),
+			predicates.NewInsufficientResourceError(v1.ResourceMemory, 500, 0, 100),
+		}
+	}
+	scheduler, _, errChan := setupTestScheduler(queuedPodStore, scache, nodeLister, predicateMap)
+
+	queuedPodStore.Add(podWithTooBigResourceRequests)
+	scheduler.scheduleOne()
+	select {
+	case err := <-errChan:
+		expectErr := &core.FitError{
+			Pod:              podWithTooBigResourceRequests,
+			FailedPredicates: failedPredicatesMap,
+		}
+		if len(fmt.Sprint(expectErr)) > 150 {
+			t.Errorf("message is too spammy ! %v ", len(fmt.Sprint(expectErr)))
+		}
+		if !reflect.DeepEqual(expectErr, err) {
+			t.Errorf("\n err \nWANT=%+v,\nGOT=%+v", expectErr, err)
+		}
+	case <-time.After(wait.ForeverTestTimeout):
+		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
+	}
+}
+
+// queuedPodStore: pods queued before processing.
+// scache: scheduler cache that might contain assumed pods.
+func setupTestScheduler(queuedPodStore *clientcache.FIFO, scache schedulercache.Cache, nodeLister schedulertesting.FakeNodeLister, predicateMap map[string]algorithm.FitPredicate) (*Scheduler, chan *v1.Binding, chan error) {
+	algo := core.NewGenericScheduler(
+		scache,
+		nil,
+		predicateMap,
+		algorithm.EmptyPredicateMetadataProducer,
+		[]algorithm.PriorityConfig{},
+		algorithm.EmptyMetadataProducer,
+		[]algorithm.SchedulerExtender{})
+	bindingChan := make(chan *v1.Binding, 1)
+	errChan := make(chan error, 1)
+	configurator := &FakeConfigurator{
+		Config: &Config{
+			SchedulerCache: scache,
+			NodeLister:     nodeLister,
+			Algorithm:      algo,
+			Binder: fakeBinder{func(b *v1.Binding) error {
+				bindingChan <- b
+				return nil
+			}},
+			NextPod: func() *v1.Pod {
+				return clientcache.Pop(queuedPodStore).(*v1.Pod)
+			},
+			Error: func(p *v1.Pod, err error) {
+				errChan <- err
+			},
+			Recorder:            &record.FakeRecorder{},
+			PodConditionUpdater: fakePodConditionUpdater{},
+		},
+	}
+
+	sched, _ := NewFromConfigurator(configurator, nil...)
+
+	return sched, bindingChan, errChan
+}
+
+func setupTestSchedulerLongBindingWithRetry(queuedPodStore *clientcache.FIFO, scache schedulercache.Cache, nodeLister schedulertesting.FakeNodeLister, predicateMap map[string]algorithm.FitPredicate, stop chan struct{}, bindingTime time.Duration) (*Scheduler, chan *v1.Binding) {
+	algo := core.NewGenericScheduler(
+		scache,
+		nil,
+		predicateMap,
+		algorithm.EmptyPredicateMetadataProducer,
+		[]algorithm.PriorityConfig{},
+		algorithm.EmptyMetadataProducer,
+		[]algorithm.SchedulerExtender{})
+	bindingChan := make(chan *v1.Binding, 2)
+	configurator := &FakeConfigurator{
+		Config: &Config{
+			SchedulerCache: scache,
+			NodeLister:     nodeLister,
+			Algorithm:      algo,
+			Binder: fakeBinder{func(b *v1.Binding) error {
+				time.Sleep(bindingTime)
+				bindingChan <- b
+				return nil
+			}},
+			WaitForCacheSync: func() bool {
+				return true
+			},
+			NextPod: func() *v1.Pod {
+				return clientcache.Pop(queuedPodStore).(*v1.Pod)
+			},
+			Error: func(p *v1.Pod, err error) {
+				queuedPodStore.AddIfNotPresent(p)
+			},
+			Recorder:            &record.FakeRecorder{},
+			PodConditionUpdater: fakePodConditionUpdater{},
+			StopEverything:      stop,
+		},
+	}
+
+	sched, _ := NewFromConfigurator(configurator, nil...)
+
+	return sched, bindingChan
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/BUILD

@@ -0,0 +1,56 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cache.go",
+        "interface.go",
+        "node_info.go",
+        "util.go",
+    ],
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["cache_test.go"],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/v1/helper:go_default_library",
+        "//plugin/pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//plugin/pkg/scheduler/util:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/cache.go

@@ -0,0 +1,392 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schedulercache
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/wait"
+
+	"github.com/golang/glog"
+)
+
+var (
+	cleanAssumedPeriod = 1 * time.Second
+)
+
+// New returns a Cache implementation.
+// It automatically starts a go routine that manages expiration of assumed pods.
+// "ttl" is how long the assumed pod will get expired.
+// "stop" is the channel that would close the background goroutine.
+func New(ttl time.Duration, stop <-chan struct{}) Cache {
+	cache := newSchedulerCache(ttl, cleanAssumedPeriod, stop)
+	cache.run()
+	return cache
+}
+
+type schedulerCache struct {
+	stop   <-chan struct{}
+	ttl    time.Duration
+	period time.Duration
+
+	// This mutex guards all fields within this cache struct.
+	mu sync.Mutex
+	// a set of assumed pod keys.
+	// The key could further be used to get an entry in podStates.
+	assumedPods map[string]bool
+	// a map from pod key to podState.
+	podStates map[string]*podState
+	nodes     map[string]*NodeInfo
+}
+
+type podState struct {
+	pod *v1.Pod
+	// Used by assumedPod to determinate expiration.
+	deadline *time.Time
+	// Used to block cache from expiring assumedPod if binding still runs
+	bindingFinished bool
+}
+
+func newSchedulerCache(ttl, period time.Duration, stop <-chan struct{}) *schedulerCache {
+	return &schedulerCache{
+		ttl:    ttl,
+		period: period,
+		stop:   stop,
+
+		nodes:       make(map[string]*NodeInfo),
+		assumedPods: make(map[string]bool),
+		podStates:   make(map[string]*podState),
+	}
+}
+
+func (cache *schedulerCache) UpdateNodeNameToInfoMap(nodeNameToInfo map[string]*NodeInfo) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+	for name, info := range cache.nodes {
+		if current, ok := nodeNameToInfo[name]; !ok || current.generation != info.generation {
+			nodeNameToInfo[name] = info.Clone()
+		}
+	}
+	for name := range nodeNameToInfo {
+		if _, ok := cache.nodes[name]; !ok {
+			delete(nodeNameToInfo, name)
+		}
+	}
+	return nil
+}
+
+func (cache *schedulerCache) List(selector labels.Selector) ([]*v1.Pod, error) {
+	alwaysTrue := func(p *v1.Pod) bool { return true }
+	return cache.FilteredList(alwaysTrue, selector)
+}
+
+func (cache *schedulerCache) FilteredList(podFilter PodFilter, selector labels.Selector) ([]*v1.Pod, error) {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+	var pods []*v1.Pod
+	for _, info := range cache.nodes {
+		for _, pod := range info.pods {
+			if podFilter(pod) && selector.Matches(labels.Set(pod.Labels)) {
+				pods = append(pods, pod)
+			}
+		}
+	}
+	return pods, nil
+}
+
+func (cache *schedulerCache) AssumePod(pod *v1.Pod) error {
+	key, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+	if _, ok := cache.podStates[key]; ok {
+		return fmt.Errorf("pod %v state wasn't initial but get assumed", key)
+	}
+
+	cache.addPod(pod)
+	ps := &podState{
+		pod: pod,
+	}
+	cache.podStates[key] = ps
+	cache.assumedPods[key] = true
+	return nil
+}
+
+func (cache *schedulerCache) FinishBinding(pod *v1.Pod) error {
+	return cache.finishBinding(pod, time.Now())
+}
+
+// finishBinding exists to make tests determinitistic by injecting now as an argument
+func (cache *schedulerCache) finishBinding(pod *v1.Pod, now time.Time) error {
+	key, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	glog.V(5).Infof("Finished binding for pod %v. Can be expired.", key)
+	currState, ok := cache.podStates[key]
+	if ok && cache.assumedPods[key] {
+		dl := now.Add(cache.ttl)
+		currState.bindingFinished = true
+		currState.deadline = &dl
+	}
+	return nil
+}
+
+func (cache *schedulerCache) ForgetPod(pod *v1.Pod) error {
+	key, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	currState, ok := cache.podStates[key]
+	if ok && currState.pod.Spec.NodeName != pod.Spec.NodeName {
+		return fmt.Errorf("pod %v state was assumed on a different node", key)
+	}
+
+	switch {
+	// Only assumed pod can be forgotten.
+	case ok && cache.assumedPods[key]:
+		err := cache.removePod(pod)
+		if err != nil {
+			return err
+		}
+		delete(cache.assumedPods, key)
+		delete(cache.podStates, key)
+	default:
+		return fmt.Errorf("pod %v state wasn't assumed but get forgotten", key)
+	}
+	return nil
+}
+
+// Assumes that lock is already acquired.
+func (cache *schedulerCache) addPod(pod *v1.Pod) {
+	n, ok := cache.nodes[pod.Spec.NodeName]
+	if !ok {
+		n = NewNodeInfo()
+		cache.nodes[pod.Spec.NodeName] = n
+	}
+	n.AddPod(pod)
+}
+
+// Assumes that lock is already acquired.
+func (cache *schedulerCache) updatePod(oldPod, newPod *v1.Pod) error {
+	if err := cache.removePod(oldPod); err != nil {
+		return err
+	}
+	cache.addPod(newPod)
+	return nil
+}
+
+// Assumes that lock is already acquired.
+func (cache *schedulerCache) removePod(pod *v1.Pod) error {
+	n := cache.nodes[pod.Spec.NodeName]
+	if err := n.RemovePod(pod); err != nil {
+		return err
+	}
+	if len(n.pods) == 0 && n.node == nil {
+		delete(cache.nodes, pod.Spec.NodeName)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) AddPod(pod *v1.Pod) error {
+	key, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	currState, ok := cache.podStates[key]
+	switch {
+	case ok && cache.assumedPods[key]:
+		if currState.pod.Spec.NodeName != pod.Spec.NodeName {
+			// The pod was added to a different node than it was assumed to.
+			glog.Warningf("Pod %v assumed to a different node than added to.", key)
+			// Clean this up.
+			cache.removePod(currState.pod)
+			cache.addPod(pod)
+		}
+		delete(cache.assumedPods, key)
+		cache.podStates[key].deadline = nil
+	case !ok:
+		// Pod was expired. We should add it back.
+		cache.addPod(pod)
+		ps := &podState{
+			pod: pod,
+		}
+		cache.podStates[key] = ps
+	default:
+		return fmt.Errorf("pod was already in added state. Pod key: %v", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) UpdatePod(oldPod, newPod *v1.Pod) error {
+	key, err := getPodKey(oldPod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	currState, ok := cache.podStates[key]
+	switch {
+	// An assumed pod won't have Update/Remove event. It needs to have Add event
+	// before Update event, in which case the state would change from Assumed to Added.
+	case ok && !cache.assumedPods[key]:
+		if currState.pod.Spec.NodeName != newPod.Spec.NodeName {
+			glog.Errorf("Pod %v updated on a different node than previously added to.", key)
+			glog.Fatalf("Schedulercache is corrupted and can badly affect scheduling decisions")
+		}
+		if err := cache.updatePod(oldPod, newPod); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("pod %v state wasn't added but get updated", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) RemovePod(pod *v1.Pod) error {
+	key, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	currState, ok := cache.podStates[key]
+	switch {
+	// An assumed pod won't have Delete/Remove event. It needs to have Add event
+	// before Remove event, in which case the state would change from Assumed to Added.
+	case ok && !cache.assumedPods[key]:
+		if currState.pod.Spec.NodeName != pod.Spec.NodeName {
+			glog.Errorf("Pod %v removed from a different node than previously added to.", key)
+			glog.Fatalf("Schedulercache is corrupted and can badly affect scheduling decisions")
+		}
+		err := cache.removePod(currState.pod)
+		if err != nil {
+			return err
+		}
+		delete(cache.podStates, key)
+	default:
+		return fmt.Errorf("pod state wasn't added but get removed. Pod key: %v", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) AddNode(node *v1.Node) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	n, ok := cache.nodes[node.Name]
+	if !ok {
+		n = NewNodeInfo()
+		cache.nodes[node.Name] = n
+	}
+	return n.SetNode(node)
+}
+
+func (cache *schedulerCache) UpdateNode(oldNode, newNode *v1.Node) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	n, ok := cache.nodes[newNode.Name]
+	if !ok {
+		n = NewNodeInfo()
+		cache.nodes[newNode.Name] = n
+	}
+	return n.SetNode(newNode)
+}
+
+func (cache *schedulerCache) RemoveNode(node *v1.Node) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	n := cache.nodes[node.Name]
+	if err := n.RemoveNode(node); err != nil {
+		return err
+	}
+	// We remove NodeInfo for this node only if there aren't any pods on this node.
+	// We can't do it unconditionally, because notifications about pods are delivered
+	// in a different watch, and thus can potentially be observed later, even though
+	// they happened before node removal.
+	if len(n.pods) == 0 && n.node == nil {
+		delete(cache.nodes, node.Name)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) run() {
+	go wait.Until(cache.cleanupExpiredAssumedPods, cache.period, cache.stop)
+}
+
+func (cache *schedulerCache) cleanupExpiredAssumedPods() {
+	cache.cleanupAssumedPods(time.Now())
+}
+
+// cleanupAssumedPods exists for making test deterministic by taking time as input argument.
+func (cache *schedulerCache) cleanupAssumedPods(now time.Time) {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	// The size of assumedPods should be small
+	for key := range cache.assumedPods {
+		ps, ok := cache.podStates[key]
+		if !ok {
+			panic("Key found in assumed set but not in podStates. Potentially a logical error.")
+		}
+		if !ps.bindingFinished {
+			glog.Warningf("Couldn't expire cache for pod %v/%v. Binding is still in progress.",
+				ps.pod.Namespace, ps.pod.Name)
+			continue
+		}
+		if now.After(*ps.deadline) {
+			glog.Warningf("Pod %s/%s expired", ps.pod.Namespace, ps.pod.Name)
+			if err := cache.expirePod(key, ps); err != nil {
+				glog.Errorf("ExpirePod failed for %s: %v", key, err)
+			}
+		}
+	}
+}
+
+func (cache *schedulerCache) expirePod(key string, ps *podState) error {
+	if err := cache.removePod(ps.pod); err != nil {
+		return err
+	}
+	delete(cache.assumedPods, key)
+	delete(cache.podStates, key)
+	return nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/cache_test.go

@@ -0,0 +1,878 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schedulercache
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	schedutil "k8s.io/kubernetes/plugin/pkg/scheduler/util"
+)
+
+func deepEqualWithoutGeneration(t *testing.T, testcase int, actual, expected *NodeInfo) {
+	// Ignore generation field.
+	if actual != nil {
+		actual.generation = 0
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("#%d: node info get=%s, want=%s", testcase, actual, expected)
+	}
+}
+
+// TestAssumePodScheduled tests that after a pod is assumed, its information is aggregated
+// on node level.
+func TestAssumePodScheduled(t *testing.T) {
+	nodeName := "node"
+	testPods := []*v1.Pod{
+		makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test-1", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test-2", "200m", "1Ki", "", []v1.ContainerPort{{HostPort: 8080}}),
+		makeBasePod(t, nodeName, "test-nonzero", "", "", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test", "100m", "500", "oir-foo:3", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test-2", "200m", "1Ki", "oir-foo:5", []v1.ContainerPort{{HostPort: 8080}}),
+		makeBasePod(t, nodeName, "test", "100m", "500", "random-invalid-oir-key:100", []v1.ContainerPort{{}}),
+	}
+
+	tests := []struct {
+		pods []*v1.Pod
+
+		wNodeInfo *NodeInfo
+	}{{
+		pods: []*v1.Pod{testPods[0]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[0]},
+			usedPorts:           map[int]bool{80: true},
+		},
+	}, {
+		pods: []*v1.Pod{testPods[1], testPods[2]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 300,
+				Memory:   1524,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 300,
+				Memory:   1524,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[1], testPods[2]},
+			usedPorts:           map[int]bool{80: true, 8080: true},
+		},
+	}, { // test non-zero request
+		pods: []*v1.Pod{testPods[3]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 0,
+				Memory:   0,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: priorityutil.DefaultMilliCpuRequest,
+				Memory:   priorityutil.DefaultMemoryRequest,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[3]},
+			usedPorts:           map[int]bool{80: true},
+		},
+	}, {
+		pods: []*v1.Pod{testPods[4]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU:          100,
+				Memory:            500,
+				ExtendedResources: map[v1.ResourceName]int64{"pod.alpha.kubernetes.io/opaque-int-resource-oir-foo": 3},
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[4]},
+			usedPorts:           map[int]bool{80: true},
+		},
+	}, {
+		pods: []*v1.Pod{testPods[4], testPods[5]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU:          300,
+				Memory:            1524,
+				ExtendedResources: map[v1.ResourceName]int64{"pod.alpha.kubernetes.io/opaque-int-resource-oir-foo": 8},
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 300,
+				Memory:   1524,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[4], testPods[5]},
+			usedPorts:           map[int]bool{80: true, 8080: true},
+		},
+	}, {
+		pods: []*v1.Pod{testPods[6]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[6]},
+			usedPorts:           map[int]bool{},
+		},
+	},
+	}
+
+	for i, tt := range tests {
+		cache := newSchedulerCache(time.Second, time.Second, nil)
+		for _, pod := range tt.pods {
+			if err := cache.AssumePod(pod); err != nil {
+				t.Fatalf("AssumePod failed: %v", err)
+			}
+		}
+		n := cache.nodes[nodeName]
+		deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo)
+
+		for _, pod := range tt.pods {
+			if err := cache.ForgetPod(pod); err != nil {
+				t.Fatalf("ForgetPod failed: %v", err)
+			}
+		}
+		if cache.nodes[nodeName] != nil {
+			t.Errorf("NodeInfo should be cleaned for %s", nodeName)
+		}
+	}
+}
+
+type testExpirePodStruct struct {
+	pod         *v1.Pod
+	assumedTime time.Time
+}
+
+func assumeAndFinishBinding(cache *schedulerCache, pod *v1.Pod, assumedTime time.Time) error {
+	if err := cache.AssumePod(pod); err != nil {
+		return err
+	}
+	return cache.finishBinding(pod, assumedTime)
+}
+
+// TestExpirePod tests that assumed pods will be removed if expired.
+// The removal will be reflected in node info.
+func TestExpirePod(t *testing.T) {
+	nodeName := "node"
+	testPods := []*v1.Pod{
+		makeBasePod(t, nodeName, "test-1", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test-2", "200m", "1Ki", "", []v1.ContainerPort{{HostPort: 8080}}),
+	}
+	now := time.Now()
+	ttl := 10 * time.Second
+	tests := []struct {
+		pods        []*testExpirePodStruct
+		cleanupTime time.Time
+
+		wNodeInfo *NodeInfo
+	}{{ // assumed pod would expires
+		pods: []*testExpirePodStruct{
+			{pod: testPods[0], assumedTime: now},
+		},
+		cleanupTime: now.Add(2 * ttl),
+		wNodeInfo:   nil,
+	}, { // first one would expire, second one would not.
+		pods: []*testExpirePodStruct{
+			{pod: testPods[0], assumedTime: now},
+			{pod: testPods[1], assumedTime: now.Add(3 * ttl / 2)},
+		},
+		cleanupTime: now.Add(2 * ttl),
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[1]},
+			usedPorts:           map[int]bool{80: false, 8080: true},
+		},
+	}}
+
+	for i, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+
+		for _, pod := range tt.pods {
+			if err := assumeAndFinishBinding(cache, pod.pod, pod.assumedTime); err != nil {
+				t.Fatalf("assumePod failed: %v", err)
+			}
+		}
+		// pods that have assumedTime + ttl < cleanupTime will get expired and removed
+		cache.cleanupAssumedPods(tt.cleanupTime)
+		n := cache.nodes[nodeName]
+		deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo)
+	}
+}
+
+// TestAddPodWillConfirm tests that a pod being Add()ed will be confirmed if assumed.
+// The pod info should still exist after manually expiring unconfirmed pods.
+func TestAddPodWillConfirm(t *testing.T) {
+	nodeName := "node"
+	now := time.Now()
+	ttl := 10 * time.Second
+
+	testPods := []*v1.Pod{
+		makeBasePod(t, nodeName, "test-1", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test-2", "200m", "1Ki", "", []v1.ContainerPort{{HostPort: 8080}}),
+	}
+	tests := []struct {
+		podsToAssume []*v1.Pod
+		podsToAdd    []*v1.Pod
+
+		wNodeInfo *NodeInfo
+	}{{ // two pod were assumed at same time. But first one is called Add() and gets confirmed.
+		podsToAssume: []*v1.Pod{testPods[0], testPods[1]},
+		podsToAdd:    []*v1.Pod{testPods[0]},
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[0]},
+			usedPorts:           map[int]bool{80: true, 8080: false},
+		},
+	}}
+
+	for i, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+		for _, podToAssume := range tt.podsToAssume {
+			if err := assumeAndFinishBinding(cache, podToAssume, now); err != nil {
+				t.Fatalf("assumePod failed: %v", err)
+			}
+		}
+		for _, podToAdd := range tt.podsToAdd {
+			if err := cache.AddPod(podToAdd); err != nil {
+				t.Fatalf("AddPod failed: %v", err)
+			}
+		}
+		cache.cleanupAssumedPods(now.Add(2 * ttl))
+		// check after expiration. confirmed pods shouldn't be expired.
+		n := cache.nodes[nodeName]
+		deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo)
+	}
+}
+
+// TestAddPodAfterExpiration tests that a pod being Add()ed will be added back if expired.
+func TestAddPodAfterExpiration(t *testing.T) {
+	nodeName := "node"
+	ttl := 10 * time.Second
+	basePod := makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}})
+	tests := []struct {
+		pod *v1.Pod
+
+		wNodeInfo *NodeInfo
+	}{{
+		pod: basePod,
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{basePod},
+			usedPorts:           map[int]bool{80: true},
+		},
+	}}
+
+	now := time.Now()
+	for i, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+		if err := assumeAndFinishBinding(cache, tt.pod, now); err != nil {
+			t.Fatalf("assumePod failed: %v", err)
+		}
+		cache.cleanupAssumedPods(now.Add(2 * ttl))
+		// It should be expired and removed.
+		n := cache.nodes[nodeName]
+		if n != nil {
+			t.Errorf("#%d: expecting nil node info, but get=%v", i, n)
+		}
+		if err := cache.AddPod(tt.pod); err != nil {
+			t.Fatalf("AddPod failed: %v", err)
+		}
+		// check after expiration. confirmed pods shouldn't be expired.
+		n = cache.nodes[nodeName]
+		deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo)
+	}
+}
+
+// TestUpdatePod tests that a pod will be updated if added before.
+func TestUpdatePod(t *testing.T) {
+	nodeName := "node"
+	ttl := 10 * time.Second
+	testPods := []*v1.Pod{
+		makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test", "200m", "1Ki", "", []v1.ContainerPort{{HostPort: 8080}}),
+	}
+	tests := []struct {
+		podsToAssume []*v1.Pod
+		podsToAdd    []*v1.Pod
+		podsToUpdate []*v1.Pod
+
+		wNodeInfo []*NodeInfo
+	}{{ // add a pod and then update it twice
+		podsToAdd:    []*v1.Pod{testPods[0]},
+		podsToUpdate: []*v1.Pod{testPods[0], testPods[1], testPods[0]},
+		wNodeInfo: []*NodeInfo{{
+			requestedResource: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[1]},
+			usedPorts:           map[int]bool{8080: true},
+		}, {
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[0]},
+			usedPorts:           map[int]bool{80: true},
+		}},
+	}}
+
+	for _, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+		for _, podToAdd := range tt.podsToAdd {
+			if err := cache.AddPod(podToAdd); err != nil {
+				t.Fatalf("AddPod failed: %v", err)
+			}
+		}
+
+		for i := range tt.podsToUpdate {
+			if i == 0 {
+				continue
+			}
+			if err := cache.UpdatePod(tt.podsToUpdate[i-1], tt.podsToUpdate[i]); err != nil {
+				t.Fatalf("UpdatePod failed: %v", err)
+			}
+			// check after expiration. confirmed pods shouldn't be expired.
+			n := cache.nodes[nodeName]
+			deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo[i-1])
+		}
+	}
+}
+
+// TestExpireAddUpdatePod test the sequence that a pod is expired, added, then updated
+func TestExpireAddUpdatePod(t *testing.T) {
+	nodeName := "node"
+	ttl := 10 * time.Second
+	testPods := []*v1.Pod{
+		makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}}),
+		makeBasePod(t, nodeName, "test", "200m", "1Ki", "", []v1.ContainerPort{{HostPort: 8080}}),
+	}
+	tests := []struct {
+		podsToAssume []*v1.Pod
+		podsToAdd    []*v1.Pod
+		podsToUpdate []*v1.Pod
+
+		wNodeInfo []*NodeInfo
+	}{{ // Pod is assumed, expired, and added. Then it would be updated twice.
+		podsToAssume: []*v1.Pod{testPods[0]},
+		podsToAdd:    []*v1.Pod{testPods[0]},
+		podsToUpdate: []*v1.Pod{testPods[0], testPods[1], testPods[0]},
+		wNodeInfo: []*NodeInfo{{
+			requestedResource: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 200,
+				Memory:   1024,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[1]},
+			usedPorts:           map[int]bool{8080: true},
+		}, {
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{testPods[0]},
+			usedPorts:           map[int]bool{80: true},
+		}},
+	}}
+
+	now := time.Now()
+	for _, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+		for _, podToAssume := range tt.podsToAssume {
+			if err := assumeAndFinishBinding(cache, podToAssume, now); err != nil {
+				t.Fatalf("assumePod failed: %v", err)
+			}
+		}
+		cache.cleanupAssumedPods(now.Add(2 * ttl))
+
+		for _, podToAdd := range tt.podsToAdd {
+			if err := cache.AddPod(podToAdd); err != nil {
+				t.Fatalf("AddPod failed: %v", err)
+			}
+		}
+
+		for i := range tt.podsToUpdate {
+			if i == 0 {
+				continue
+			}
+			if err := cache.UpdatePod(tt.podsToUpdate[i-1], tt.podsToUpdate[i]); err != nil {
+				t.Fatalf("UpdatePod failed: %v", err)
+			}
+			// check after expiration. confirmed pods shouldn't be expired.
+			n := cache.nodes[nodeName]
+			deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo[i-1])
+		}
+	}
+}
+
+// TestRemovePod tests after added pod is removed, its information should also be subtracted.
+func TestRemovePod(t *testing.T) {
+	nodeName := "node"
+	basePod := makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}})
+	tests := []struct {
+		pod       *v1.Pod
+		wNodeInfo *NodeInfo
+	}{{
+		pod: basePod,
+		wNodeInfo: &NodeInfo{
+			requestedResource: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			nonzeroRequest: &Resource{
+				MilliCPU: 100,
+				Memory:   500,
+			},
+			allocatableResource: &Resource{},
+			pods:                []*v1.Pod{basePod},
+			usedPorts:           map[int]bool{80: true},
+		},
+	}}
+
+	for i, tt := range tests {
+		cache := newSchedulerCache(time.Second, time.Second, nil)
+		if err := cache.AddPod(tt.pod); err != nil {
+			t.Fatalf("AddPod failed: %v", err)
+		}
+		n := cache.nodes[nodeName]
+		deepEqualWithoutGeneration(t, i, n, tt.wNodeInfo)
+
+		if err := cache.RemovePod(tt.pod); err != nil {
+			t.Fatalf("RemovePod failed: %v", err)
+		}
+
+		n = cache.nodes[nodeName]
+		if n != nil {
+			t.Errorf("#%d: expecting pod deleted and nil node info, get=%s", i, n)
+		}
+	}
+}
+
+func TestForgetPod(t *testing.T) {
+	nodeName := "node"
+	basePod := makeBasePod(t, nodeName, "test", "100m", "500", "", []v1.ContainerPort{{HostPort: 80}})
+	tests := []struct {
+		pods []*v1.Pod
+	}{{
+		pods: []*v1.Pod{basePod},
+	}}
+	now := time.Now()
+	ttl := 10 * time.Second
+
+	for i, tt := range tests {
+		cache := newSchedulerCache(ttl, time.Second, nil)
+		for _, pod := range tt.pods {
+			if err := assumeAndFinishBinding(cache, pod, now); err != nil {
+				t.Fatalf("assumePod failed: %v", err)
+			}
+		}
+		for _, pod := range tt.pods {
+			if err := cache.ForgetPod(pod); err != nil {
+				t.Fatalf("ForgetPod failed: %v", err)
+			}
+		}
+		cache.cleanupAssumedPods(now.Add(2 * ttl))
+		if n := cache.nodes[nodeName]; n != nil {
+			t.Errorf("#%d: expecting pod deleted and nil node info, get=%s", i, n)
+		}
+	}
+}
+
+// getResourceRequest returns the resource request of all containers in Pods;
+// excuding initContainers.
+func getResourceRequest(pod *v1.Pod) v1.ResourceList {
+	result := &Resource{}
+	for _, container := range pod.Spec.Containers {
+		result.Add(container.Resources.Requests)
+	}
+
+	return result.ResourceList()
+}
+
+// buildNodeInfo creates a NodeInfo by simulating node operations in cache.
+func buildNodeInfo(node *v1.Node, pods []*v1.Pod) *NodeInfo {
+	expected := NewNodeInfo()
+
+	// Simulate SetNode.
+	expected.node = node
+	expected.allocatableResource = NewResource(node.Status.Allocatable)
+	expected.taints = node.Spec.Taints
+	expected.generation++
+
+	for _, pod := range pods {
+		// Simulate AddPod
+		expected.pods = append(expected.pods, pod)
+		expected.requestedResource.Add(getResourceRequest(pod))
+		expected.nonzeroRequest.Add(getResourceRequest(pod))
+		expected.usedPorts = schedutil.GetUsedPorts(pod)
+		expected.generation++
+	}
+
+	return expected
+}
+
+// TestNodeOperators tests node operations of cache, including add, update
+// and remove.
+func TestNodeOperators(t *testing.T) {
+	// Test datas
+	nodeName := "test-node"
+	cpu_1 := resource.MustParse("1000m")
+	mem_100m := resource.MustParse("100m")
+	cpu_half := resource.MustParse("500m")
+	mem_50m := resource.MustParse("50m")
+	resourceFooName := "pod.alpha.kubernetes.io/opaque-int-resource-foo"
+	resourceFoo := resource.MustParse("1")
+
+	tests := []struct {
+		node *v1.Node
+		pods []*v1.Pod
+	}{
+		{
+			node: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: nodeName,
+				},
+				Status: v1.NodeStatus{
+					Allocatable: v1.ResourceList{
+						v1.ResourceCPU:                   cpu_1,
+						v1.ResourceMemory:                mem_100m,
+						v1.ResourceName(resourceFooName): resourceFoo,
+					},
+				},
+				Spec: v1.NodeSpec{
+					Taints: []v1.Taint{
+						{
+							Key:    "test-key",
+							Value:  "test-value",
+							Effect: v1.TaintEffectPreferNoSchedule,
+						},
+					},
+				},
+			},
+			pods: []*v1.Pod{
+				{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: "pod1",
+					},
+					Spec: v1.PodSpec{
+						NodeName: nodeName,
+						Containers: []v1.Container{
+							{
+								Resources: v1.ResourceRequirements{
+									Requests: v1.ResourceList{
+										v1.ResourceCPU:    cpu_half,
+										v1.ResourceMemory: mem_50m,
+									},
+								},
+								Ports: []v1.ContainerPort{
+									{
+										Name:          "http",
+										HostPort:      80,
+										ContainerPort: 80,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			node: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: nodeName,
+				},
+				Status: v1.NodeStatus{
+					Allocatable: v1.ResourceList{
+						v1.ResourceCPU:                   cpu_1,
+						v1.ResourceMemory:                mem_100m,
+						v1.ResourceName(resourceFooName): resourceFoo,
+					},
+				},
+				Spec: v1.NodeSpec{
+					Taints: []v1.Taint{
+						{
+							Key:    "test-key",
+							Value:  "test-value",
+							Effect: v1.TaintEffectPreferNoSchedule,
+						},
+					},
+				},
+			},
+			pods: []*v1.Pod{
+				{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: "pod1",
+					},
+					Spec: v1.PodSpec{
+						NodeName: nodeName,
+						Containers: []v1.Container{
+							{
+								Resources: v1.ResourceRequirements{
+									Requests: v1.ResourceList{
+										v1.ResourceCPU:    cpu_half,
+										v1.ResourceMemory: mem_50m,
+									},
+								},
+							},
+						},
+					},
+				},
+				{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: "pod2",
+					},
+					Spec: v1.PodSpec{
+						NodeName: nodeName,
+						Containers: []v1.Container{
+							{
+								Resources: v1.ResourceRequirements{
+									Requests: v1.ResourceList{
+										v1.ResourceCPU:    cpu_half,
+										v1.ResourceMemory: mem_50m,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		expected := buildNodeInfo(test.node, test.pods)
+		node := test.node
+
+		cache := newSchedulerCache(time.Second, time.Second, nil)
+		cache.AddNode(node)
+		for _, pod := range test.pods {
+			cache.AddPod(pod)
+		}
+
+		// Case 1: the node was added into cache successfully.
+		got, found := cache.nodes[node.Name]
+		if !found {
+			t.Errorf("Failed to find node %v in schedulercache.", node.Name)
+		}
+
+		if !reflect.DeepEqual(got, expected) {
+			t.Errorf("Failed to add node into schedulercache:\n got: %+v \nexpected: %+v", got, expected)
+		}
+
+		// Case 2: dump cached nodes successfully.
+		cachedNodes := map[string]*NodeInfo{}
+		cache.UpdateNodeNameToInfoMap(cachedNodes)
+		newNode, found := cachedNodes[node.Name]
+		if !found || len(cachedNodes) != 1 {
+			t.Errorf("failed to dump cached nodes:\n got: %v \nexpected: %v", cachedNodes, cache.nodes)
+		}
+		if !reflect.DeepEqual(newNode, expected) {
+			t.Errorf("Failed to clone node:\n got: %+v, \n expected: %+v", newNode, expected)
+		}
+
+		// Case 3: update node attribute successfully.
+		node.Status.Allocatable[v1.ResourceMemory] = mem_50m
+		expected.allocatableResource.Memory = mem_50m.Value()
+		expected.generation++
+		cache.UpdateNode(nil, node)
+		got, found = cache.nodes[node.Name]
+		if !found {
+			t.Errorf("Failed to find node %v in schedulercache after UpdateNode.", node.Name)
+		}
+
+		if !reflect.DeepEqual(got, expected) {
+			t.Errorf("Failed to update node in schedulercache:\n got: %+v \nexpected: %+v", got, expected)
+		}
+
+		// Case 4: the node can not be removed if pods is not empty.
+		cache.RemoveNode(node)
+		if _, found := cache.nodes[node.Name]; !found {
+			t.Errorf("The node %v should not be removed if pods is not empty.", node.Name)
+		}
+	}
+}
+
+func BenchmarkList1kNodes30kPods(b *testing.B) {
+	cache := setupCacheOf1kNodes30kPods(b)
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		cache.List(labels.Everything())
+	}
+}
+
+func BenchmarkExpire100Pods(b *testing.B) {
+	benchmarkExpire(b, 100)
+}
+
+func BenchmarkExpire1kPods(b *testing.B) {
+	benchmarkExpire(b, 1000)
+}
+
+func BenchmarkExpire10kPods(b *testing.B) {
+	benchmarkExpire(b, 10000)
+}
+
+func benchmarkExpire(b *testing.B, podNum int) {
+	now := time.Now()
+	for n := 0; n < b.N; n++ {
+		b.StopTimer()
+		cache := setupCacheWithAssumedPods(b, podNum, now)
+		b.StartTimer()
+		cache.cleanupAssumedPods(now.Add(2 * time.Second))
+	}
+}
+
+type testingMode interface {
+	Fatalf(format string, args ...interface{})
+}
+
+func makeBasePod(t testingMode, nodeName, objName, cpu, mem, oir string, ports []v1.ContainerPort) *v1.Pod {
+	req := v1.ResourceList{}
+	if cpu != "" {
+		req = v1.ResourceList{
+			v1.ResourceCPU:    resource.MustParse(cpu),
+			v1.ResourceMemory: resource.MustParse(mem),
+		}
+		if oir != "" {
+			if len(strings.Split(oir, ":")) != 2 {
+				t.Fatalf("Invalid OIR string")
+			}
+			var name v1.ResourceName
+			if strings.Split(oir, ":")[0] != "random-invalid-oir-key" {
+				name = v1helper.OpaqueIntResourceName(strings.Split(oir, ":")[0])
+			} else {
+				name = v1.ResourceName(strings.Split(oir, ":")[0])
+			}
+			quantity := resource.MustParse(strings.Split(oir, ":")[1])
+			req[name] = quantity
+		}
+	}
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "node_info_cache_test",
+			Name:      objName,
+		},
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{{
+				Resources: v1.ResourceRequirements{
+					Requests: req,
+				},
+				Ports: ports,
+			}},
+			NodeName: nodeName,
+		},
+	}
+}
+
+func setupCacheOf1kNodes30kPods(b *testing.B) Cache {
+	cache := newSchedulerCache(time.Second, time.Second, nil)
+	for i := 0; i < 1000; i++ {
+		nodeName := fmt.Sprintf("node-%d", i)
+		for j := 0; j < 30; j++ {
+			objName := fmt.Sprintf("%s-pod-%d", nodeName, j)
+			pod := makeBasePod(b, nodeName, objName, "0", "0", "", nil)
+
+			if err := cache.AddPod(pod); err != nil {
+				b.Fatalf("AddPod failed: %v", err)
+			}
+		}
+	}
+	return cache
+}
+
+func setupCacheWithAssumedPods(b *testing.B, podNum int, assumedTime time.Time) *schedulerCache {
+	cache := newSchedulerCache(time.Second, time.Second, nil)
+	for i := 0; i < podNum; i++ {
+		nodeName := fmt.Sprintf("node-%d", i/10)
+		objName := fmt.Sprintf("%s-pod-%d", nodeName, i%10)
+		pod := makeBasePod(b, nodeName, objName, "0", "0", "", nil)
+
+		err := assumeAndFinishBinding(cache, pod, assumedTime)
+		if err != nil {
+			b.Fatalf("assumePod failed: %v", err)
+		}
+	}
+	return cache
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/interface.go

@@ -0,0 +1,101 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schedulercache
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+type PodFilter func(*v1.Pod) bool
+
+// Cache collects pods' information and provides node-level aggregated information.
+// It's intended for generic scheduler to do efficient lookup.
+// Cache's operations are pod centric. It does incremental updates based on pod events.
+// Pod events are sent via network. We don't have guaranteed delivery of all events:
+// We use Reflector to list and watch from remote.
+// Reflector might be slow and do a relist, which would lead to missing events.
+//
+// State Machine of a pod's events in scheduler's cache:
+//
+//
+//   +-------------------------------------------+  +----+
+//   |                            Add            |  |    |
+//   |                                           |  |    | Update
+//   +      Assume                Add            v  v    |
+//Initial +--------> Assumed +------------+---> Added <--+
+//   ^                +   +               |       +
+//   |                |   |               |       |
+//   |                |   |           Add |       | Remove
+//   |                |   |               |       |
+//   |                |   |               +       |
+//   +----------------+   +-----------> Expired   +----> Deleted
+//         Forget             Expire
+//
+//
+// Note that an assumed pod can expire, because if we haven't received Add event notifying us
+// for a while, there might be some problems and we shouldn't keep the pod in cache anymore.
+//
+// Note that "Initial", "Expired", and "Deleted" pods do not actually exist in cache.
+// Based on existing use cases, we are making the following assumptions:
+// - No pod would be assumed twice
+// - A pod could be added without going through scheduler. In this case, we will see Add but not Assume event.
+// - If a pod wasn't added, it wouldn't be removed or updated.
+// - Both "Expired" and "Deleted" are valid end states. In case of some problems, e.g. network issue,
+//   a pod might have changed its state (e.g. added and deleted) without delivering notification to the cache.
+type Cache interface {
+	// AssumePod assumes a pod scheduled and aggregates the pod's information into its node.
+	// The implementation also decides the policy to expire pod before being confirmed (receiving Add event).
+	// After expiration, its information would be subtracted.
+	AssumePod(pod *v1.Pod) error
+
+	// FinishBinding signals that cache for assumed pod can be expired
+	FinishBinding(pod *v1.Pod) error
+
+	// ForgetPod removes an assumed pod from cache.
+	ForgetPod(pod *v1.Pod) error
+
+	// AddPod either confirms a pod if it's assumed, or adds it back if it's expired.
+	// If added back, the pod's information would be added again.
+	AddPod(pod *v1.Pod) error
+
+	// UpdatePod removes oldPod's information and adds newPod's information.
+	UpdatePod(oldPod, newPod *v1.Pod) error
+
+	// RemovePod removes a pod. The pod's information would be subtracted from assigned node.
+	RemovePod(pod *v1.Pod) error
+
+	// AddNode adds overall information about node.
+	AddNode(node *v1.Node) error
+
+	// UpdateNode updates overall information about node.
+	UpdateNode(oldNode, newNode *v1.Node) error
+
+	// RemoveNode removes overall information about node.
+	RemoveNode(node *v1.Node) error
+
+	// UpdateNodeNameToInfoMap updates the passed infoMap to the current contents of Cache.
+	// The node info contains aggregated information of pods scheduled (including assumed to be)
+	// on this node.
+	UpdateNodeNameToInfoMap(infoMap map[string]*NodeInfo) error
+
+	// List lists all cached pods (including assumed ones).
+	List(labels.Selector) ([]*v1.Pod, error)
+
+	// FilteredList returns all cached pods that pass the filter.
+	FilteredList(filter PodFilter, selector labels.Selector) ([]*v1.Pod, error)
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/node_info.go

@@ -0,0 +1,531 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schedulercache
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	clientcache "k8s.io/client-go/tools/cache"
+	v1helper "k8s.io/kubernetes/pkg/api/v1/helper"
+	priorityutil "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm/priorities/util"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+)
+
+var emptyResource = Resource{}
+
+// NodeInfo is node level aggregated information.
+type NodeInfo struct {
+	// Overall node information.
+	node *v1.Node
+
+	pods             []*v1.Pod
+	podsWithAffinity []*v1.Pod
+	usedPorts        map[int]bool
+
+	// Total requested resource of all pods on this node.
+	// It includes assumed pods which scheduler sends binding to apiserver but
+	// didn't get it as scheduled yet.
+	requestedResource *Resource
+	nonzeroRequest    *Resource
+	// We store allocatedResources (which is Node.Status.Allocatable.*) explicitly
+	// as int64, to avoid conversions and accessing map.
+	allocatableResource *Resource
+
+	// Cached tains of the node for faster lookup.
+	taints    []v1.Taint
+	taintsErr error
+
+	// Cached conditions of node for faster lookup.
+	memoryPressureCondition v1.ConditionStatus
+	diskPressureCondition   v1.ConditionStatus
+
+	// Whenever NodeInfo changes, generation is bumped.
+	// This is used to avoid cloning it if the object didn't change.
+	generation int64
+}
+
+// Resource is a collection of compute resource.
+type Resource struct {
+	MilliCPU         int64
+	Memory           int64
+	NvidiaGPU        int64
+	EphemeralStorage int64
+	// We store allowedPodNumber (which is Node.Status.Allocatable.Pods().Value())
+	// explicitly as int, to avoid conversions and improve performance.
+	AllowedPodNumber  int
+	ExtendedResources map[v1.ResourceName]int64
+	HugePages         map[v1.ResourceName]int64
+}
+
+// New creates a Resource from ResourceList
+func NewResource(rl v1.ResourceList) *Resource {
+	r := &Resource{}
+	r.Add(rl)
+	return r
+}
+
+// Add adds ResourceList into Resource.
+func (r *Resource) Add(rl v1.ResourceList) {
+	if r == nil {
+		return
+	}
+
+	for rName, rQuant := range rl {
+		switch rName {
+		case v1.ResourceCPU:
+			r.MilliCPU += rQuant.MilliValue()
+		case v1.ResourceMemory:
+			r.Memory += rQuant.Value()
+		case v1.ResourceNvidiaGPU:
+			r.NvidiaGPU += rQuant.Value()
+		case v1.ResourcePods:
+			r.AllowedPodNumber += int(rQuant.Value())
+		case v1.ResourceEphemeralStorage:
+			r.EphemeralStorage += rQuant.Value()
+		default:
+			if v1helper.IsExtendedResourceName(rName) {
+				r.AddExtended(rName, rQuant.Value())
+			}
+			if v1helper.IsHugePageResourceName(rName) {
+				r.AddHugePages(rName, rQuant.Value())
+			}
+		}
+	}
+}
+
+func (r *Resource) ResourceList() v1.ResourceList {
+	result := v1.ResourceList{
+		v1.ResourceCPU:              *resource.NewMilliQuantity(r.MilliCPU, resource.DecimalSI),
+		v1.ResourceMemory:           *resource.NewQuantity(r.Memory, resource.BinarySI),
+		v1.ResourceNvidiaGPU:        *resource.NewQuantity(r.NvidiaGPU, resource.DecimalSI),
+		v1.ResourcePods:             *resource.NewQuantity(int64(r.AllowedPodNumber), resource.BinarySI),
+		v1.ResourceEphemeralStorage: *resource.NewQuantity(r.EphemeralStorage, resource.BinarySI),
+	}
+	for rName, rQuant := range r.ExtendedResources {
+		result[rName] = *resource.NewQuantity(rQuant, resource.DecimalSI)
+	}
+	for rName, rQuant := range r.HugePages {
+		result[rName] = *resource.NewQuantity(rQuant, resource.BinarySI)
+	}
+	return result
+}
+
+func (r *Resource) Clone() *Resource {
+	res := &Resource{
+		MilliCPU:         r.MilliCPU,
+		Memory:           r.Memory,
+		NvidiaGPU:        r.NvidiaGPU,
+		AllowedPodNumber: r.AllowedPodNumber,
+		EphemeralStorage: r.EphemeralStorage,
+	}
+	if r.ExtendedResources != nil {
+		res.ExtendedResources = make(map[v1.ResourceName]int64)
+		for k, v := range r.ExtendedResources {
+			res.ExtendedResources[k] = v
+		}
+	}
+	if r.HugePages != nil {
+		res.HugePages = make(map[v1.ResourceName]int64)
+		for k, v := range r.HugePages {
+			res.HugePages[k] = v
+		}
+	}
+	return res
+}
+
+func (r *Resource) AddExtended(name v1.ResourceName, quantity int64) {
+	r.SetExtended(name, r.ExtendedResources[name]+quantity)
+}
+
+func (r *Resource) SetExtended(name v1.ResourceName, quantity int64) {
+	// Lazily allocate opaque integer resource map.
+	if r.ExtendedResources == nil {
+		r.ExtendedResources = map[v1.ResourceName]int64{}
+	}
+	r.ExtendedResources[name] = quantity
+}
+
+func (r *Resource) AddHugePages(name v1.ResourceName, quantity int64) {
+	r.SetHugePages(name, r.HugePages[name]+quantity)
+}
+
+func (r *Resource) SetHugePages(name v1.ResourceName, quantity int64) {
+	// Lazily allocate hugepages resource map.
+	if r.HugePages == nil {
+		r.HugePages = map[v1.ResourceName]int64{}
+	}
+	r.HugePages[name] = quantity
+}
+
+// NewNodeInfo returns a ready to use empty NodeInfo object.
+// If any pods are given in arguments, their information will be aggregated in
+// the returned object.
+func NewNodeInfo(pods ...*v1.Pod) *NodeInfo {
+	ni := &NodeInfo{
+		requestedResource:   &Resource{},
+		nonzeroRequest:      &Resource{},
+		allocatableResource: &Resource{},
+		generation:          0,
+		usedPorts:           make(map[int]bool),
+	}
+	for _, pod := range pods {
+		ni.AddPod(pod)
+	}
+	return ni
+}
+
+// Returns overall information about this node.
+func (n *NodeInfo) Node() *v1.Node {
+	if n == nil {
+		return nil
+	}
+	return n.node
+}
+
+// Pods return all pods scheduled (including assumed to be) on this node.
+func (n *NodeInfo) Pods() []*v1.Pod {
+	if n == nil {
+		return nil
+	}
+	return n.pods
+}
+
+func (n *NodeInfo) UsedPorts() map[int]bool {
+	if n == nil {
+		return nil
+	}
+	return n.usedPorts
+}
+
+// PodsWithAffinity return all pods with (anti)affinity constraints on this node.
+func (n *NodeInfo) PodsWithAffinity() []*v1.Pod {
+	if n == nil {
+		return nil
+	}
+	return n.podsWithAffinity
+}
+
+func (n *NodeInfo) AllowedPodNumber() int {
+	if n == nil || n.allocatableResource == nil {
+		return 0
+	}
+	return n.allocatableResource.AllowedPodNumber
+}
+
+func (n *NodeInfo) Taints() ([]v1.Taint, error) {
+	if n == nil {
+		return nil, nil
+	}
+	return n.taints, n.taintsErr
+}
+
+func (n *NodeInfo) MemoryPressureCondition() v1.ConditionStatus {
+	if n == nil {
+		return v1.ConditionUnknown
+	}
+	return n.memoryPressureCondition
+}
+
+func (n *NodeInfo) DiskPressureCondition() v1.ConditionStatus {
+	if n == nil {
+		return v1.ConditionUnknown
+	}
+	return n.diskPressureCondition
+}
+
+// RequestedResource returns aggregated resource request of pods on this node.
+func (n *NodeInfo) RequestedResource() Resource {
+	if n == nil {
+		return emptyResource
+	}
+	return *n.requestedResource
+}
+
+// NonZeroRequest returns aggregated nonzero resource request of pods on this node.
+func (n *NodeInfo) NonZeroRequest() Resource {
+	if n == nil {
+		return emptyResource
+	}
+	return *n.nonzeroRequest
+}
+
+// AllocatableResource returns allocatable resources on a given node.
+func (n *NodeInfo) AllocatableResource() Resource {
+	if n == nil {
+		return emptyResource
+	}
+	return *n.allocatableResource
+}
+
+func (n *NodeInfo) Clone() *NodeInfo {
+	clone := &NodeInfo{
+		node:                    n.node,
+		requestedResource:       n.requestedResource.Clone(),
+		nonzeroRequest:          n.nonzeroRequest.Clone(),
+		allocatableResource:     n.allocatableResource.Clone(),
+		taintsErr:               n.taintsErr,
+		memoryPressureCondition: n.memoryPressureCondition,
+		diskPressureCondition:   n.diskPressureCondition,
+		usedPorts:               make(map[int]bool),
+		generation:              n.generation,
+	}
+	if len(n.pods) > 0 {
+		clone.pods = append([]*v1.Pod(nil), n.pods...)
+	}
+	if len(n.usedPorts) > 0 {
+		for k, v := range n.usedPorts {
+			clone.usedPorts[k] = v
+		}
+	}
+	if len(n.podsWithAffinity) > 0 {
+		clone.podsWithAffinity = append([]*v1.Pod(nil), n.podsWithAffinity...)
+	}
+	if len(n.taints) > 0 {
+		clone.taints = append([]v1.Taint(nil), n.taints...)
+	}
+	return clone
+}
+
+// String returns representation of human readable format of this NodeInfo.
+func (n *NodeInfo) String() string {
+	podKeys := make([]string, len(n.pods))
+	for i, pod := range n.pods {
+		podKeys[i] = pod.Name
+	}
+	return fmt.Sprintf("&NodeInfo{Pods:%v, RequestedResource:%#v, NonZeroRequest: %#v, UsedPort: %#v, AllocatableResource:%#v}",
+		podKeys, n.requestedResource, n.nonzeroRequest, n.usedPorts, n.allocatableResource)
+}
+
+func hasPodAffinityConstraints(pod *v1.Pod) bool {
+	affinity := pod.Spec.Affinity
+	return affinity != nil && (affinity.PodAffinity != nil || affinity.PodAntiAffinity != nil)
+}
+
+// AddPod adds pod information to this NodeInfo.
+func (n *NodeInfo) AddPod(pod *v1.Pod) {
+	res, non0_cpu, non0_mem := calculateResource(pod)
+	n.requestedResource.MilliCPU += res.MilliCPU
+	n.requestedResource.Memory += res.Memory
+	n.requestedResource.NvidiaGPU += res.NvidiaGPU
+	n.requestedResource.EphemeralStorage += res.EphemeralStorage
+	if n.requestedResource.ExtendedResources == nil && len(res.ExtendedResources) > 0 {
+		n.requestedResource.ExtendedResources = map[v1.ResourceName]int64{}
+	}
+	for rName, rQuant := range res.ExtendedResources {
+		n.requestedResource.ExtendedResources[rName] += rQuant
+	}
+	if n.requestedResource.HugePages == nil && len(res.HugePages) > 0 {
+		n.requestedResource.HugePages = map[v1.ResourceName]int64{}
+	}
+	for rName, rQuant := range res.HugePages {
+		n.requestedResource.HugePages[rName] += rQuant
+	}
+	n.nonzeroRequest.MilliCPU += non0_cpu
+	n.nonzeroRequest.Memory += non0_mem
+	n.pods = append(n.pods, pod)
+	if hasPodAffinityConstraints(pod) {
+		n.podsWithAffinity = append(n.podsWithAffinity, pod)
+	}
+
+	// Consume ports when pods added.
+	n.updateUsedPorts(pod, true)
+
+	n.generation++
+}
+
+// RemovePod subtracts pod information from this NodeInfo.
+func (n *NodeInfo) RemovePod(pod *v1.Pod) error {
+	k1, err := getPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	for i := range n.podsWithAffinity {
+		k2, err := getPodKey(n.podsWithAffinity[i])
+		if err != nil {
+			glog.Errorf("Cannot get pod key, err: %v", err)
+			continue
+		}
+		if k1 == k2 {
+			// delete the element
+			n.podsWithAffinity[i] = n.podsWithAffinity[len(n.podsWithAffinity)-1]
+			n.podsWithAffinity = n.podsWithAffinity[:len(n.podsWithAffinity)-1]
+			break
+		}
+	}
+	for i := range n.pods {
+		k2, err := getPodKey(n.pods[i])
+		if err != nil {
+			glog.Errorf("Cannot get pod key, err: %v", err)
+			continue
+		}
+		if k1 == k2 {
+			// delete the element
+			n.pods[i] = n.pods[len(n.pods)-1]
+			n.pods = n.pods[:len(n.pods)-1]
+			// reduce the resource data
+			res, non0_cpu, non0_mem := calculateResource(pod)
+
+			n.requestedResource.MilliCPU -= res.MilliCPU
+			n.requestedResource.Memory -= res.Memory
+			n.requestedResource.NvidiaGPU -= res.NvidiaGPU
+			if len(res.ExtendedResources) > 0 && n.requestedResource.ExtendedResources == nil {
+				n.requestedResource.ExtendedResources = map[v1.ResourceName]int64{}
+			}
+			for rName, rQuant := range res.ExtendedResources {
+				n.requestedResource.ExtendedResources[rName] -= rQuant
+			}
+			if len(res.HugePages) > 0 && n.requestedResource.HugePages == nil {
+				n.requestedResource.HugePages = map[v1.ResourceName]int64{}
+			}
+			for rName, rQuant := range res.HugePages {
+				n.requestedResource.HugePages[rName] -= rQuant
+			}
+			n.nonzeroRequest.MilliCPU -= non0_cpu
+			n.nonzeroRequest.Memory -= non0_mem
+
+			// Release ports when remove Pods.
+			n.updateUsedPorts(pod, false)
+
+			n.generation++
+
+			return nil
+		}
+	}
+	return fmt.Errorf("no corresponding pod %s in pods of node %s", pod.Name, n.node.Name)
+}
+
+func calculateResource(pod *v1.Pod) (res Resource, non0_cpu int64, non0_mem int64) {
+	resPtr := &res
+	for _, c := range pod.Spec.Containers {
+		resPtr.Add(c.Resources.Requests)
+
+		non0_cpu_req, non0_mem_req := priorityutil.GetNonzeroRequests(&c.Resources.Requests)
+		non0_cpu += non0_cpu_req
+		non0_mem += non0_mem_req
+		// No non-zero resources for GPUs or opaque resources.
+	}
+
+	return
+}
+
+func (n *NodeInfo) updateUsedPorts(pod *v1.Pod, used bool) {
+	for j := range pod.Spec.Containers {
+		container := &pod.Spec.Containers[j]
+		for k := range container.Ports {
+			podPort := &container.Ports[k]
+			// "0" is explicitly ignored in PodFitsHostPorts,
+			// which is the only function that uses this value.
+			if podPort.HostPort != 0 {
+				n.usedPorts[int(podPort.HostPort)] = used
+			}
+		}
+	}
+}
+
+// Sets the overall node information.
+func (n *NodeInfo) SetNode(node *v1.Node) error {
+	n.node = node
+
+	n.allocatableResource = NewResource(node.Status.Allocatable)
+
+	n.taints = node.Spec.Taints
+	for i := range node.Status.Conditions {
+		cond := &node.Status.Conditions[i]
+		switch cond.Type {
+		case v1.NodeMemoryPressure:
+			n.memoryPressureCondition = cond.Status
+		case v1.NodeDiskPressure:
+			n.diskPressureCondition = cond.Status
+		default:
+			// We ignore other conditions.
+		}
+	}
+	n.generation++
+	return nil
+}
+
+// Removes the overall information about the node.
+func (n *NodeInfo) RemoveNode(node *v1.Node) error {
+	// We don't remove NodeInfo for because there can still be some pods on this node -
+	// this is because notifications about pods are delivered in a different watch,
+	// and thus can potentially be observed later, even though they happened before
+	// node removal. This is handled correctly in cache.go file.
+	n.node = nil
+	n.allocatableResource = &Resource{}
+	n.taints, n.taintsErr = nil, nil
+	n.memoryPressureCondition = v1.ConditionUnknown
+	n.diskPressureCondition = v1.ConditionUnknown
+	n.generation++
+	return nil
+}
+
+// FilterOutPods receives a list of pods and filters out those whose node names
+// are equal to the node of this NodeInfo, but are not found in the pods of this NodeInfo.
+//
+// Preemption logic simulates removal of pods on a node by removing them from the
+// corresponding NodeInfo. In order for the simulation to work, we call this method
+// on the pods returned from SchedulerCache, so that predicate functions see
+// only the pods that are not removed from the NodeInfo.
+func (n *NodeInfo) FilterOutPods(pods []*v1.Pod) []*v1.Pod {
+	node := n.Node()
+	if node == nil {
+		return pods
+	}
+	filtered := make([]*v1.Pod, 0, len(pods))
+	for _, p := range pods {
+		if p.Spec.NodeName == node.Name {
+			// If pod is on the given node, add it to 'filtered' only if it is present in nodeInfo.
+			podKey, _ := getPodKey(p)
+			for _, np := range n.Pods() {
+				npodkey, _ := getPodKey(np)
+				if npodkey == podKey {
+					filtered = append(filtered, p)
+					break
+				}
+			}
+		} else {
+			filtered = append(filtered, p)
+		}
+	}
+	return filtered
+}
+
+// getPodKey returns the string key of a pod.
+func getPodKey(pod *v1.Pod) (string, error) {
+	return clientcache.MetaNamespaceKeyFunc(pod)
+}
+
+// Filter implements PodFilter interface. It returns false only if the pod node name
+// matches NodeInfo.node and the pod is not found in the pods list. Otherwise,
+// returns true.
+func (n *NodeInfo) Filter(pod *v1.Pod) bool {
+	pFullName := util.GetPodFullName(pod)
+	if pod.Spec.NodeName != n.node.Name {
+		return true
+	}
+	for _, p := range n.pods {
+		if util.GetPodFullName(p) == pFullName {
+			return true
+		}
+	}
+	return false
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache/util.go

@@ -0,0 +1,39 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schedulercache
+
+import "k8s.io/api/core/v1"
+
+// CreateNodeNameToInfoMap obtains a list of pods and pivots that list into a map where the keys are node names
+// and the values are the aggregated information for that node.
+func CreateNodeNameToInfoMap(pods []*v1.Pod, nodes []*v1.Node) map[string]*NodeInfo {
+	nodeNameToInfo := make(map[string]*NodeInfo)
+	for _, pod := range pods {
+		nodeName := pod.Spec.NodeName
+		if _, ok := nodeNameToInfo[nodeName]; !ok {
+			nodeNameToInfo[nodeName] = NewNodeInfo()
+		}
+		nodeNameToInfo[nodeName].AddPod(pod)
+	}
+	for _, node := range nodes {
+		if _, ok := nodeNameToInfo[node.Name]; !ok {
+			nodeNameToInfo[node.Name] = NewNodeInfo()
+		}
+		nodeNameToInfo[node.Name].SetNode(node)
+	}
+	return nodeNameToInfo
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/testing/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "fake_cache.go",
+        "fake_lister.go",
+        "pods_to_cache.go",
+    ],
+    deps = [
+        "//plugin/pkg/scheduler/algorithm:go_default_library",
+        "//plugin/pkg/scheduler/schedulercache:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/testing/fake_cache.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testing
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// FakeCache is used for testing
+type FakeCache struct {
+	AssumeFunc func(*v1.Pod)
+	ForgetFunc func(*v1.Pod)
+}
+
+func (f *FakeCache) AssumePod(pod *v1.Pod) error {
+	f.AssumeFunc(pod)
+	return nil
+}
+
+func (f *FakeCache) FinishBinding(pod *v1.Pod) error { return nil }
+
+func (f *FakeCache) ForgetPod(pod *v1.Pod) error {
+	f.ForgetFunc(pod)
+	return nil
+}
+
+func (f *FakeCache) AddPod(pod *v1.Pod) error { return nil }
+
+func (f *FakeCache) UpdatePod(oldPod, newPod *v1.Pod) error { return nil }
+
+func (f *FakeCache) RemovePod(pod *v1.Pod) error { return nil }
+
+func (f *FakeCache) AddNode(node *v1.Node) error { return nil }
+
+func (f *FakeCache) UpdateNode(oldNode, newNode *v1.Node) error { return nil }
+
+func (f *FakeCache) RemoveNode(node *v1.Node) error { return nil }
+
+func (f *FakeCache) UpdateNodeNameToInfoMap(infoMap map[string]*schedulercache.NodeInfo) error {
+	return nil
+}
+
+func (f *FakeCache) List(s labels.Selector) ([]*v1.Pod, error) { return nil, nil }
+
+func (f *FakeCache) FilteredList(filter schedulercache.PodFilter, selector labels.Selector) ([]*v1.Pod, error) {
+	return nil, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/testing/fake_lister.go

@@ -0,0 +1,178 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testing
+
+import (
+	"fmt"
+
+	apps "k8s.io/api/apps/v1beta1"
+	"k8s.io/api/core/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	. "k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+var _ NodeLister = &FakeNodeLister{}
+
+// FakeNodeLister implements NodeLister on a []string for test purposes.
+type FakeNodeLister []*v1.Node
+
+// List returns nodes as a []string.
+func (f FakeNodeLister) List() ([]*v1.Node, error) {
+	return f, nil
+}
+
+var _ PodLister = &FakePodLister{}
+
+// FakePodLister implements PodLister on an []v1.Pods for test purposes.
+type FakePodLister []*v1.Pod
+
+// List returns []*v1.Pod matching a query.
+func (f FakePodLister) List(s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range f {
+		if s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}
+
+func (f FakePodLister) FilteredList(podFilter schedulercache.PodFilter, s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range f {
+		if podFilter(pod) && s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}
+
+var _ ServiceLister = &FakeServiceLister{}
+
+// FakeServiceLister implements ServiceLister on []v1.Service for test purposes.
+type FakeServiceLister []*v1.Service
+
+// List returns v1.ServiceList, the list of all services.
+func (f FakeServiceLister) List(labels.Selector) ([]*v1.Service, error) {
+	return f, nil
+}
+
+// GetPodServices gets the services that have the selector that match the labels on the given pod.
+func (f FakeServiceLister) GetPodServices(pod *v1.Pod) (services []*v1.Service, err error) {
+	var selector labels.Selector
+
+	for i := range f {
+		service := f[i]
+		// consider only services that are in the same namespace as the pod
+		if service.Namespace != pod.Namespace {
+			continue
+		}
+		selector = labels.Set(service.Spec.Selector).AsSelectorPreValidated()
+		if selector.Matches(labels.Set(pod.Labels)) {
+			services = append(services, service)
+		}
+	}
+	return
+}
+
+var _ ControllerLister = &FakeControllerLister{}
+
+// FakeControllerLister implements ControllerLister on []v1.ReplicationController for test purposes.
+type FakeControllerLister []*v1.ReplicationController
+
+// List returns []v1.ReplicationController, the list of all ReplicationControllers.
+func (f FakeControllerLister) List(labels.Selector) ([]*v1.ReplicationController, error) {
+	return f, nil
+}
+
+// GetPodControllers gets the ReplicationControllers that have the selector that match the labels on the given pod
+func (f FakeControllerLister) GetPodControllers(pod *v1.Pod) (controllers []*v1.ReplicationController, err error) {
+	var selector labels.Selector
+
+	for i := range f {
+		controller := f[i]
+		if controller.Namespace != pod.Namespace {
+			continue
+		}
+		selector = labels.Set(controller.Spec.Selector).AsSelectorPreValidated()
+		if selector.Matches(labels.Set(pod.Labels)) {
+			controllers = append(controllers, controller)
+		}
+	}
+	if len(controllers) == 0 {
+		err = fmt.Errorf("Could not find Replication Controller for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+
+	return
+}
+
+var _ ReplicaSetLister = &FakeReplicaSetLister{}
+
+// FakeReplicaSetLister implements ControllerLister on []extensions.ReplicaSet for test purposes.
+type FakeReplicaSetLister []*extensions.ReplicaSet
+
+// GetPodReplicaSets gets the ReplicaSets that have the selector that match the labels on the given pod
+func (f FakeReplicaSetLister) GetPodReplicaSets(pod *v1.Pod) (rss []*extensions.ReplicaSet, err error) {
+	var selector labels.Selector
+
+	for _, rs := range f {
+		if rs.Namespace != pod.Namespace {
+			continue
+		}
+		selector, err = metav1.LabelSelectorAsSelector(rs.Spec.Selector)
+		if err != nil {
+			return
+		}
+
+		if selector.Matches(labels.Set(pod.Labels)) {
+			rss = append(rss, rs)
+		}
+	}
+	if len(rss) == 0 {
+		err = fmt.Errorf("Could not find ReplicaSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+
+	return
+}
+
+var _ StatefulSetLister = &FakeStatefulSetLister{}
+
+// FakeStatefulSetLister implements ControllerLister on []apps.StatefulSet for testing purposes.
+type FakeStatefulSetLister []*apps.StatefulSet
+
+// GetPodStatefulSets gets the StatefulSets that have the selector that match the labels on the given pod.
+func (f FakeStatefulSetLister) GetPodStatefulSets(pod *v1.Pod) (sss []*apps.StatefulSet, err error) {
+	var selector labels.Selector
+
+	for _, ss := range f {
+		if ss.Namespace != pod.Namespace {
+			continue
+		}
+		selector, err = metav1.LabelSelectorAsSelector(ss.Spec.Selector)
+		if err != nil {
+			return
+		}
+		if selector.Matches(labels.Set(pod.Labels)) {
+			sss = append(sss, ss)
+		}
+	}
+	if len(sss) == 0 {
+		err = fmt.Errorf("Could not find StatefulSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+	return
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/testing/pods_to_cache.go

@@ -0,0 +1,55 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testing
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/schedulercache"
+)
+
+// PodsToCache is used for testing
+type PodsToCache []*v1.Pod
+
+func (p PodsToCache) AssumePod(pod *v1.Pod) error { return nil }
+
+func (p PodsToCache) ForgetPod(pod *v1.Pod) error { return nil }
+
+func (p PodsToCache) AddPod(pod *v1.Pod) error { return nil }
+
+func (p PodsToCache) UpdatePod(oldPod, newPod *v1.Pod) error { return nil }
+
+func (p PodsToCache) RemovePod(pod *v1.Pod) error { return nil }
+
+func (p PodsToCache) AddNode(node *v1.Node) error { return nil }
+
+func (p PodsToCache) UpdateNode(oldNode, newNode *v1.Node) error { return nil }
+
+func (p PodsToCache) RemoveNode(node *v1.Node) error { return nil }
+
+func (p PodsToCache) UpdateNodeNameToInfoMap(infoMap map[string]*schedulercache.NodeInfo) error {
+	return nil
+}
+
+func (p PodsToCache) List(s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range p {
+		if s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/testutil.go

@@ -0,0 +1,115 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package scheduler
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	clientset "k8s.io/client-go/kubernetes"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/algorithm"
+	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
+	"k8s.io/kubernetes/plugin/pkg/scheduler/util"
+)
+
+// FakeConfigurator is an implementation for test.
+type FakeConfigurator struct {
+	Config *Config
+}
+
+// GetPriorityFunctionConfigs is not implemented yet.
+func (fc *FakeConfigurator) GetPriorityFunctionConfigs(priorityKeys sets.String) ([]algorithm.PriorityConfig, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// GetPriorityMetadataProducer is not implemented yet.
+func (fc *FakeConfigurator) GetPriorityMetadataProducer() (algorithm.MetadataProducer, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// GetPredicateMetadataProducer is not implemented yet.
+func (fc *FakeConfigurator) GetPredicateMetadataProducer() (algorithm.PredicateMetadataProducer, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// GetPredicates is not implemented yet.
+func (fc *FakeConfigurator) GetPredicates(predicateKeys sets.String) (map[string]algorithm.FitPredicate, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// GetHardPodAffinitySymmetricWeight is not implemented yet.
+func (fc *FakeConfigurator) GetHardPodAffinitySymmetricWeight() int {
+	panic("not implemented")
+}
+
+// GetSchedulerName is not implemented yet.
+func (fc *FakeConfigurator) GetSchedulerName() string {
+	panic("not implemented")
+}
+
+// MakeDefaultErrorFunc is not implemented yet.
+func (fc *FakeConfigurator) MakeDefaultErrorFunc(backoff *util.PodBackoff, podQueue *cache.FIFO) func(pod *v1.Pod, err error) {
+	return nil
+}
+
+// ResponsibleForPod is not implemented yet.
+func (fc *FakeConfigurator) ResponsibleForPod(pod *v1.Pod) bool {
+	panic("not implemented")
+}
+
+// GetNodeLister is not implemented yet.
+func (fc *FakeConfigurator) GetNodeLister() corelisters.NodeLister {
+	return nil
+}
+
+// GetClient is not implemented yet.
+func (fc *FakeConfigurator) GetClient() clientset.Interface {
+	return nil
+}
+
+// GetScheduledPodLister is not implemented yet.
+func (fc *FakeConfigurator) GetScheduledPodLister() corelisters.PodLister {
+	return nil
+}
+
+// Run is not implemented yet.
+func (fc *FakeConfigurator) Run() {
+	panic("not implemented")
+}
+
+// Create returns FakeConfigurator.Config
+func (fc *FakeConfigurator) Create() (*Config, error) {
+	return fc.Config, nil
+}
+
+// CreateFromProvider returns FakeConfigurator.Config
+func (fc *FakeConfigurator) CreateFromProvider(providerName string) (*Config, error) {
+	return fc.Config, nil
+}
+
+// CreateFromConfig returns FakeConfigurator.Config
+func (fc *FakeConfigurator) CreateFromConfig(policy schedulerapi.Policy) (*Config, error) {
+	return fc.Config, nil
+}
+
+// CreateFromKeys returns FakeConfigurator.Config
+func (fc *FakeConfigurator) CreateFromKeys(predicateKeys, priorityKeys sets.String, extenders []algorithm.SchedulerExtender) (*Config, error) {
+	return fc.Config, nil
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/util/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "backoff_utils_test.go",
+        "utils_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/scheduling:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "backoff_utils.go",
+        "testutil.go",
+        "utils.go",
+    ],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/install:go_default_library",
+        "//pkg/apis/scheduling:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/util/backoff_utils.go

@@ -0,0 +1,137 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	ktypes "k8s.io/apimachinery/pkg/types"
+
+	"github.com/golang/glog"
+)
+
+type clock interface {
+	Now() time.Time
+}
+
+type realClock struct{}
+
+func (realClock) Now() time.Time {
+	return time.Now()
+}
+
+// backoffEntry is single threaded.  in particular, it only allows a single action to be waiting on backoff at a time.
+// It is expected that all users will only use the public TryWait(...) method
+// It is also not safe to copy this object.
+type backoffEntry struct {
+	backoff     time.Duration
+	lastUpdate  time.Time
+	reqInFlight int32
+}
+
+// tryLock attempts to acquire a lock via atomic compare and swap.
+// returns true if the lock was acquired, false otherwise
+func (b *backoffEntry) tryLock() bool {
+	return atomic.CompareAndSwapInt32(&b.reqInFlight, 0, 1)
+}
+
+// unlock returns the lock.  panics if the lock isn't held
+func (b *backoffEntry) unlock() {
+	if !atomic.CompareAndSwapInt32(&b.reqInFlight, 1, 0) {
+		panic(fmt.Sprintf("unexpected state on unlocking: %+v", b))
+	}
+}
+
+// TryWait tries to acquire the backoff lock, maxDuration is the maximum allowed period to wait for.
+func (b *backoffEntry) TryWait(maxDuration time.Duration) bool {
+	if !b.tryLock() {
+		return false
+	}
+	defer b.unlock()
+	b.wait(maxDuration)
+	return true
+}
+
+func (entry *backoffEntry) getBackoff(maxDuration time.Duration) time.Duration {
+	duration := entry.backoff
+	newDuration := time.Duration(duration) * 2
+	if newDuration > maxDuration {
+		newDuration = maxDuration
+	}
+	entry.backoff = newDuration
+	glog.V(4).Infof("Backing off %s", duration.String())
+	return duration
+}
+
+func (entry *backoffEntry) wait(maxDuration time.Duration) {
+	time.Sleep(entry.getBackoff(maxDuration))
+}
+
+type PodBackoff struct {
+	perPodBackoff   map[ktypes.NamespacedName]*backoffEntry
+	lock            sync.Mutex
+	clock           clock
+	defaultDuration time.Duration
+	maxDuration     time.Duration
+}
+
+func (p *PodBackoff) MaxDuration() time.Duration {
+	return p.maxDuration
+}
+
+func CreateDefaultPodBackoff() *PodBackoff {
+	return CreatePodBackoff(1*time.Second, 60*time.Second)
+}
+
+func CreatePodBackoff(defaultDuration, maxDuration time.Duration) *PodBackoff {
+	return CreatePodBackoffWithClock(defaultDuration, maxDuration, realClock{})
+}
+
+func CreatePodBackoffWithClock(defaultDuration, maxDuration time.Duration, clock clock) *PodBackoff {
+	return &PodBackoff{
+		perPodBackoff:   map[ktypes.NamespacedName]*backoffEntry{},
+		clock:           clock,
+		defaultDuration: defaultDuration,
+		maxDuration:     maxDuration,
+	}
+}
+
+func (p *PodBackoff) GetEntry(podID ktypes.NamespacedName) *backoffEntry {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	entry, ok := p.perPodBackoff[podID]
+	if !ok {
+		entry = &backoffEntry{backoff: p.defaultDuration}
+		p.perPodBackoff[podID] = entry
+	}
+	entry.lastUpdate = p.clock.Now()
+	return entry
+}
+
+func (p *PodBackoff) Gc() {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	now := p.clock.Now()
+	for podID, entry := range p.perPodBackoff {
+		if now.Sub(entry.lastUpdate) > p.maxDuration {
+			delete(p.perPodBackoff, podID)
+		}
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/util/backoff_utils_test.go

@@ -0,0 +1,86 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"testing"
+	"time"
+
+	ktypes "k8s.io/apimachinery/pkg/types"
+)
+
+type fakeClock struct {
+	t time.Time
+}
+
+func (f *fakeClock) Now() time.Time {
+	return f.t
+}
+
+func TestBackoff(t *testing.T) {
+	clock := fakeClock{}
+	backoff := CreatePodBackoffWithClock(1*time.Second, 60*time.Second, &clock)
+	tests := []struct {
+		podID            ktypes.NamespacedName
+		expectedDuration time.Duration
+		advanceClock     time.Duration
+	}{
+		{
+			podID:            ktypes.NamespacedName{Namespace: "default", Name: "foo"},
+			expectedDuration: 1 * time.Second,
+		},
+		{
+			podID:            ktypes.NamespacedName{Namespace: "default", Name: "foo"},
+			expectedDuration: 2 * time.Second,
+		},
+		{
+			podID:            ktypes.NamespacedName{Namespace: "default", Name: "foo"},
+			expectedDuration: 4 * time.Second,
+		},
+		{
+			podID:            ktypes.NamespacedName{Namespace: "default", Name: "bar"},
+			expectedDuration: 1 * time.Second,
+			advanceClock:     120 * time.Second,
+		},
+		// 'foo' should have been gc'd here.
+		{
+			podID:            ktypes.NamespacedName{Namespace: "default", Name: "foo"},
+			expectedDuration: 1 * time.Second,
+		},
+	}
+
+	for _, test := range tests {
+		duration := backoff.GetEntry(test.podID).getBackoff(backoff.maxDuration)
+		if duration != test.expectedDuration {
+			t.Errorf("expected: %s, got %s for %s", test.expectedDuration.String(), duration.String(), test.podID)
+		}
+		clock.t = clock.t.Add(test.advanceClock)
+		backoff.Gc()
+	}
+	fooID := ktypes.NamespacedName{Namespace: "default", Name: "foo"}
+	backoff.perPodBackoff[fooID].backoff = 60 * time.Second
+	duration := backoff.GetEntry(fooID).getBackoff(backoff.maxDuration)
+	if duration != 60*time.Second {
+		t.Errorf("expected: 60, got %s", duration.String())
+	}
+	// Verify that we split on namespaces correctly, same name, different namespace
+	fooID.Namespace = "other"
+	duration = backoff.GetEntry(fooID).getBackoff(backoff.maxDuration)
+	if duration != 1*time.Second {
+		t.Errorf("expected: 1, got %s", duration.String())
+	}
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/util/testutil.go

@@ -0,0 +1,168 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"fmt"
+	"mime"
+	"os"
+	"reflect"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/api"
+
+	_ "k8s.io/kubernetes/pkg/api/install"
+)
+
+type TestGroup struct {
+	externalGroupVersion schema.GroupVersion
+	internalGroupVersion schema.GroupVersion
+	internalTypes        map[string]reflect.Type
+	externalTypes        map[string]reflect.Type
+}
+
+var (
+	Groups = make(map[string]TestGroup)
+	Test   TestGroup
+
+	serializer runtime.SerializerInfo
+)
+
+func init() {
+	if apiMediaType := os.Getenv("KUBE_TEST_API_TYPE"); len(apiMediaType) > 0 {
+		var ok bool
+		mediaType, _, err := mime.ParseMediaType(apiMediaType)
+		if err != nil {
+			panic(err)
+		}
+		serializer, ok = runtime.SerializerInfoForMediaType(api.Codecs.SupportedMediaTypes(), mediaType)
+		if !ok {
+			panic(fmt.Sprintf("no serializer for %s", apiMediaType))
+		}
+	}
+
+	kubeTestAPI := os.Getenv("KUBE_TEST_API")
+	if len(kubeTestAPI) != 0 {
+		// priority is "first in list preferred", so this has to run in reverse order
+		testGroupVersions := strings.Split(kubeTestAPI, ",")
+		for i := len(testGroupVersions) - 1; i >= 0; i-- {
+			gvString := testGroupVersions[i]
+			groupVersion, err := schema.ParseGroupVersion(gvString)
+			if err != nil {
+				panic(fmt.Sprintf("Error parsing groupversion %v: %v", gvString, err))
+			}
+
+			internalGroupVersion := schema.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}
+			Groups[groupVersion.Group] = TestGroup{
+				externalGroupVersion: groupVersion,
+				internalGroupVersion: internalGroupVersion,
+				internalTypes:        api.Scheme.KnownTypes(internalGroupVersion),
+				externalTypes:        api.Scheme.KnownTypes(groupVersion),
+			}
+		}
+	}
+
+	if _, ok := Groups[api.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: api.GroupName, Version: api.Registry.GroupOrDie(api.GroupName).GroupVersion.Version}
+		Groups[api.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: api.SchemeGroupVersion,
+			internalTypes:        api.Scheme.KnownTypes(api.SchemeGroupVersion),
+			externalTypes:        api.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+
+	Test = Groups[api.GroupName]
+}
+
+// Codec returns the codec for the API version to test against, as set by the
+// KUBE_TEST_API_TYPE env var.
+func (g TestGroup) Codec() runtime.Codec {
+	if serializer.Serializer == nil {
+		return api.Codecs.LegacyCodec(g.externalGroupVersion)
+	}
+	return api.Codecs.CodecForVersions(serializer.Serializer, api.Codecs.UniversalDeserializer(), schema.GroupVersions{g.externalGroupVersion}, nil)
+}
+
+// SelfLink returns a self link that will appear to be for the version Version().
+// 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be
+// empty for lists.
+func (g TestGroup) SelfLink(resource, name string) string {
+	if g.externalGroupVersion.Group == api.GroupName {
+		if name == "" {
+			return fmt.Sprintf("/api/%s/%s", g.externalGroupVersion.Version, resource)
+		}
+		return fmt.Sprintf("/api/%s/%s/%s", g.externalGroupVersion.Version, resource, name)
+	}
+
+	// TODO: will need a /apis prefix once we have proper multi-group
+	// support
+	if name == "" {
+		return fmt.Sprintf("/apis/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource)
+	}
+	return fmt.Sprintf("/apis/%s/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource, name)
+}
+
+// ResourcePathWithPrefix returns the appropriate path for the given prefix (watch, proxy, redirect, etc), resource, namespace and name.
+// For ex, this is of the form:
+// /api/v1/watch/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePathWithPrefix(prefix, resource, namespace, name string) string {
+	var path string
+	if g.externalGroupVersion.Group == api.GroupName {
+		path = "/api/" + g.externalGroupVersion.Version
+	} else {
+		// TODO: switch back once we have proper multiple group support
+		// path = "/apis/" + g.Group + "/" + Version(group...)
+		path = "/apis/" + g.externalGroupVersion.Group + "/" + g.externalGroupVersion.Version
+	}
+
+	if prefix != "" {
+		path = path + "/" + prefix
+	}
+	if namespace != "" {
+		path = path + "/namespaces/" + namespace
+	}
+	// Resource names are lower case.
+	resource = strings.ToLower(resource)
+	if resource != "" {
+		path = path + "/" + resource
+	}
+	if name != "" {
+		path = path + "/" + name
+	}
+	return path
+}
+
+// ResourcePath returns the appropriate path for the given resource, namespace and name.
+// For example, this is of the form:
+// /api/v1/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePath(resource, namespace, name string) string {
+	return g.ResourcePathWithPrefix("", resource, namespace, name)
+}
+
+// SubResourcePath returns the appropriate path for the given resource, namespace,
+// name and subresource.
+func (g TestGroup) SubResourcePath(resource, namespace, name, sub string) string {
+	path := g.ResourcePathWithPrefix("", resource, namespace, name)
+	if sub != "" {
+		path = path + "/" + sub
+	}
+
+	return path
+}

vendor/k8s.io/kubernetes/plugin/pkg/scheduler/util/utils.go

@@ -0,0 +1,97 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"sort"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/pkg/apis/scheduling"
+)
+
+// GetUsedPorts returns the used host ports of Pods: if 'port' was used, a 'port:true' pair
+// will be in the result; but it does not resolve port conflict.
+func GetUsedPorts(pods ...*v1.Pod) map[int]bool {
+	ports := make(map[int]bool)
+	for _, pod := range pods {
+		for j := range pod.Spec.Containers {
+			container := &pod.Spec.Containers[j]
+			for k := range container.Ports {
+				podPort := &container.Ports[k]
+				// "0" is explicitly ignored in PodFitsHostPorts,
+				// which is the only function that uses this value.
+				if podPort.HostPort != 0 {
+					ports[int(podPort.HostPort)] = true
+				}
+			}
+		}
+	}
+	return ports
+}
+
+// GetPodFullName returns a name that uniquely identifies a pod.
+func GetPodFullName(pod *v1.Pod) string {
+	// Use underscore as the delimiter because it is not allowed in pod name
+	// (DNS subdomain format).
+	return pod.Name + "_" + pod.Namespace
+}
+
+// GetPodPriority return priority of the given pod.
+func GetPodPriority(pod *v1.Pod) int32 {
+	if pod.Spec.Priority != nil {
+		return *pod.Spec.Priority
+	}
+	// When priority of a running pod is nil, it means it was created at a time
+	// that there was no global default priority class and the priority class
+	// name of the pod was empty. So, we resolve to the static default priority.
+	return scheduling.DefaultPriorityWhenNoDefaultClassExists
+}
+
+// SortableList is a list that implements sort.Interface.
+type SortableList struct {
+	Items    []interface{}
+	CompFunc LessFunc
+}
+
+// LessFunc is a function that receives two items and returns true if the first
+// item should be placed before the second one when the list is sorted.
+type LessFunc func(item1, item2 interface{}) bool
+
+var _ = sort.Interface(&SortableList{})
+
+func (l *SortableList) Len() int { return len(l.Items) }
+
+func (l *SortableList) Less(i, j int) bool {
+	return l.CompFunc(l.Items[i], l.Items[j])
+}
+
+func (l *SortableList) Swap(i, j int) {
+	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
+}
+
+// Sort sorts the items in the list using the given CompFunc. Item1 is placed
+// before Item2 when CompFunc(Item1, Item2) returns true.
+func (l *SortableList) Sort() {
+	sort.Sort(l)
+}
+
+// HigherPriorityPod return true when priority of the first pod is higher than
+// the second one. It takes arguments of the type "interface{}" to be used with
+// SortableList, but expects those arguments to be *v1.Pod.
+func HigherPriorityPod(pod1, pod2 interface{}) bool {
+	return GetPodPriority(pod1.(*v1.Pod)) > GetPodPriority(pod2.(*v1.Pod))
+}