Fresh dep ensure

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/BUILD

@@ -0,0 +1,64 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cache.go",
+        "interface.go",
+        "node_tree.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/scheduler/internal/cache",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/features:go_default_library",
+        "//pkg/scheduler/cache:go_default_library",
+        "//pkg/util/node:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//vendor/k8s.io/klog:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "cache_test.go",
+        "main_test.go",
+        "node_tree_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/features:go_default_library",
+        "//pkg/kubelet/apis:go_default_library",
+        "//pkg/scheduler/algorithm/priorities/util:go_default_library",
+        "//pkg/scheduler/cache:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/scheduler/internal/cache/debugger:all-srcs",
+        "//pkg/scheduler/internal/cache/fake:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/cache.go

@@ -0,0 +1,553 @@
+/*
+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 cache
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/wait"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/features"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+
+	"k8s.io/klog"
+)
+
+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.RWMutex
+	// 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]*schedulercache.NodeInfo
+	nodeTree  *NodeTree
+	// A map from image name to its imageState.
+	imageStates map[string]*imageState
+}
+
+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
+}
+
+type imageState struct {
+	// Size of the image
+	size int64
+	// A set of node names for nodes having this image present
+	nodes sets.String
+}
+
+// createImageStateSummary returns a summarizing snapshot of the given image's state.
+func (cache *schedulerCache) createImageStateSummary(state *imageState) *schedulercache.ImageStateSummary {
+	return &schedulercache.ImageStateSummary{
+		Size:     state.size,
+		NumNodes: len(state.nodes),
+	}
+}
+
+func newSchedulerCache(ttl, period time.Duration, stop <-chan struct{}) *schedulerCache {
+	return &schedulerCache{
+		ttl:    ttl,
+		period: period,
+		stop:   stop,
+
+		nodes:       make(map[string]*schedulercache.NodeInfo),
+		nodeTree:    newNodeTree(nil),
+		assumedPods: make(map[string]bool),
+		podStates:   make(map[string]*podState),
+		imageStates: make(map[string]*imageState),
+	}
+}
+
+// Snapshot takes a snapshot of the current schedulerinternalcache. The method has performance impact,
+// and should be only used in non-critical path.
+func (cache *schedulerCache) Snapshot() *Snapshot {
+	cache.mu.RLock()
+	defer cache.mu.RUnlock()
+
+	nodes := make(map[string]*schedulercache.NodeInfo)
+	for k, v := range cache.nodes {
+		nodes[k] = v.Clone()
+	}
+
+	assumedPods := make(map[string]bool)
+	for k, v := range cache.assumedPods {
+		assumedPods[k] = v
+	}
+
+	return &Snapshot{
+		Nodes:       nodes,
+		AssumedPods: assumedPods,
+	}
+}
+
+func (cache *schedulerCache) UpdateNodeNameToInfoMap(nodeNameToInfo map[string]*schedulercache.NodeInfo) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	for name, info := range cache.nodes {
+		if utilfeature.DefaultFeatureGate.Enabled(features.BalanceAttachedNodeVolumes) && info.TransientInfo != nil {
+			// Transient scheduler info is reset here.
+			info.TransientInfo.ResetTransientSchedulerInfo()
+		}
+		if current, ok := nodeNameToInfo[name]; !ok || current.GetGeneration() != info.GetGeneration() {
+			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.RLock()
+	defer cache.mu.RUnlock()
+	// podFilter is expected to return true for most or all of the pods. We
+	// can avoid expensive array growth without wasting too much memory by
+	// pre-allocating capacity.
+	maxSize := 0
+	for _, info := range cache.nodes {
+		maxSize += len(info.Pods())
+	}
+	pods := make([]*v1.Pod, 0, maxSize)
+	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 := schedulercache.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 is in the cache, so can't be 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 := schedulercache.GetPodKey(pod)
+	if err != nil {
+		return err
+	}
+
+	cache.mu.RLock()
+	defer cache.mu.RUnlock()
+
+	klog.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 := schedulercache.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 was assumed on %v but assigned to %v", key, pod.Spec.NodeName, currState.pod.Spec.NodeName)
+	}
+
+	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 wasn't assumed so cannot be 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 = schedulercache.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 := schedulercache.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.
+			klog.Warningf("Pod %v was assumed to be on %v but got added to %v", key, pod.Spec.NodeName, currState.pod.Spec.NodeName)
+			// Clean this up.
+			cache.removePod(currState.pod)
+			cache.addPod(pod)
+		}
+		delete(cache.assumedPods, key)
+		cache.podStates[key].deadline = nil
+		cache.podStates[key].pod = pod
+	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 %v was already in added state", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) UpdatePod(oldPod, newPod *v1.Pod) error {
+	key, err := schedulercache.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 {
+			klog.Errorf("Pod %v updated on a different node than previously added to.", key)
+			klog.Fatalf("Schedulercache is corrupted and can badly affect scheduling decisions")
+		}
+		if err := cache.updatePod(oldPod, newPod); err != nil {
+			return err
+		}
+		currState.pod = newPod
+	default:
+		return fmt.Errorf("pod %v is not added to scheduler cache, so cannot be updated", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) RemovePod(pod *v1.Pod) error {
+	key, err := schedulercache.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 {
+			klog.Errorf("Pod %v was assumed to be on %v but got added to %v", key, pod.Spec.NodeName, currState.pod.Spec.NodeName)
+			klog.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 %v is not found in scheduler cache, so cannot be removed from it", key)
+	}
+	return nil
+}
+
+func (cache *schedulerCache) IsAssumedPod(pod *v1.Pod) (bool, error) {
+	key, err := schedulercache.GetPodKey(pod)
+	if err != nil {
+		return false, err
+	}
+
+	cache.mu.RLock()
+	defer cache.mu.RUnlock()
+
+	b, found := cache.assumedPods[key]
+	if !found {
+		return false, nil
+	}
+	return b, nil
+}
+
+func (cache *schedulerCache) GetPod(pod *v1.Pod) (*v1.Pod, error) {
+	key, err := schedulercache.GetPodKey(pod)
+	if err != nil {
+		return nil, err
+	}
+
+	cache.mu.RLock()
+	defer cache.mu.RUnlock()
+
+	podState, ok := cache.podStates[key]
+	if !ok {
+		return nil, fmt.Errorf("pod %v does not exist in scheduler cache", key)
+	}
+
+	return podState.pod, 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 = schedulercache.NewNodeInfo()
+		cache.nodes[node.Name] = n
+	} else {
+		cache.removeNodeImageStates(n.Node())
+	}
+
+	cache.nodeTree.AddNode(node)
+	cache.addNodeImageStates(node, 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 = schedulercache.NewNodeInfo()
+		cache.nodes[newNode.Name] = n
+	} else {
+		cache.removeNodeImageStates(n.Node())
+	}
+
+	cache.nodeTree.UpdateNode(oldNode, newNode)
+	cache.addNodeImageStates(newNode, 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)
+	}
+
+	cache.nodeTree.RemoveNode(node)
+	cache.removeNodeImageStates(node)
+	return nil
+}
+
+// addNodeImageStates adds states of the images on given node to the given nodeInfo and update the imageStates in
+// scheduler cache. This function assumes the lock to scheduler cache has been acquired.
+func (cache *schedulerCache) addNodeImageStates(node *v1.Node, nodeInfo *schedulercache.NodeInfo) {
+	newSum := make(map[string]*schedulercache.ImageStateSummary)
+
+	for _, image := range node.Status.Images {
+		for _, name := range image.Names {
+			// update the entry in imageStates
+			state, ok := cache.imageStates[name]
+			if !ok {
+				state = &imageState{
+					size:  image.SizeBytes,
+					nodes: sets.NewString(node.Name),
+				}
+				cache.imageStates[name] = state
+			} else {
+				state.nodes.Insert(node.Name)
+			}
+			// create the imageStateSummary for this image
+			if _, ok := newSum[name]; !ok {
+				newSum[name] = cache.createImageStateSummary(state)
+			}
+		}
+	}
+	nodeInfo.SetImageStates(newSum)
+}
+
+// removeNodeImageStates removes the given node record from image entries having the node
+// in imageStates cache. After the removal, if any image becomes free, i.e., the image
+// is no longer available on any node, the image entry will be removed from imageStates.
+func (cache *schedulerCache) removeNodeImageStates(node *v1.Node) {
+	if node == nil {
+		return
+	}
+
+	for _, image := range node.Status.Images {
+		for _, name := range image.Names {
+			state, ok := cache.imageStates[name]
+			if ok {
+				state.nodes.Delete(node.Name)
+				if len(state.nodes) == 0 {
+					// Remove the unused image to make sure the length of
+					// imageStates represents the total number of different
+					// images on all nodes
+					delete(cache.imageStates, name)
+				}
+			}
+		}
+	}
+}
+
+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 {
+			klog.V(3).Infof("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) {
+			klog.Warningf("Pod %s/%s expired", ps.pod.Namespace, ps.pod.Name)
+			if err := cache.expirePod(key, ps); err != nil {
+				klog.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
+}
+
+func (cache *schedulerCache) NodeTree() *NodeTree {
+	return cache.nodeTree
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger/BUILD

@@ -0,0 +1,46 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "comparer.go",
+        "debugger.go",
+        "dumper.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger",
+    visibility = ["//pkg/scheduler:__subpackages__"],
+    deps = [
+        "//pkg/scheduler/cache:go_default_library",
+        "//pkg/scheduler/internal/cache:go_default_library",
+        "//pkg/scheduler/internal/queue:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/klog:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["comparer_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/scheduler/cache:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/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"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger/comparer.go

@@ -0,0 +1,135 @@
+/*
+Copyright 2018 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 debugger
+
+import (
+	"sort"
+	"strings"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/klog"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+	schedulerinternalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
+	internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
+)
+
+// CacheComparer is an implementation of the Scheduler's cache comparer.
+type CacheComparer struct {
+	NodeLister corelisters.NodeLister
+	PodLister  corelisters.PodLister
+	Cache      schedulerinternalcache.Cache
+	PodQueue   internalqueue.SchedulingQueue
+}
+
+// Compare compares the nodes and pods of NodeLister with Cache.Snapshot.
+func (c *CacheComparer) Compare() error {
+	klog.V(3).Info("cache comparer started")
+	defer klog.V(3).Info("cache comparer finished")
+
+	nodes, err := c.NodeLister.List(labels.Everything())
+	if err != nil {
+		return err
+	}
+
+	pods, err := c.PodLister.List(labels.Everything())
+	if err != nil {
+		return err
+	}
+
+	snapshot := c.Cache.Snapshot()
+
+	waitingPods := c.PodQueue.WaitingPods()
+
+	if missed, redundant := c.CompareNodes(nodes, snapshot.Nodes); len(missed)+len(redundant) != 0 {
+		klog.Warningf("cache mismatch: missed nodes: %s; redundant nodes: %s", missed, redundant)
+	}
+
+	if missed, redundant := c.ComparePods(pods, waitingPods, snapshot.Nodes); len(missed)+len(redundant) != 0 {
+		klog.Warningf("cache mismatch: missed pods: %s; redundant pods: %s", missed, redundant)
+	}
+
+	return nil
+}
+
+// CompareNodes compares actual nodes with cached nodes.
+func (c *CacheComparer) CompareNodes(nodes []*v1.Node, nodeinfos map[string]*schedulercache.NodeInfo) (missed, redundant []string) {
+	actual := []string{}
+	for _, node := range nodes {
+		actual = append(actual, node.Name)
+	}
+
+	cached := []string{}
+	for nodeName := range nodeinfos {
+		cached = append(cached, nodeName)
+	}
+
+	return compareStrings(actual, cached)
+}
+
+// ComparePods compares actual pods with cached pods.
+func (c *CacheComparer) ComparePods(pods, waitingPods []*v1.Pod, nodeinfos map[string]*schedulercache.NodeInfo) (missed, redundant []string) {
+	actual := []string{}
+	for _, pod := range pods {
+		actual = append(actual, string(pod.UID))
+	}
+
+	cached := []string{}
+	for _, nodeinfo := range nodeinfos {
+		for _, pod := range nodeinfo.Pods() {
+			cached = append(cached, string(pod.UID))
+		}
+	}
+	for _, pod := range waitingPods {
+		cached = append(cached, string(pod.UID))
+	}
+
+	return compareStrings(actual, cached)
+}
+
+func compareStrings(actual, cached []string) (missed, redundant []string) {
+	missed, redundant = []string{}, []string{}
+
+	sort.Strings(actual)
+	sort.Strings(cached)
+
+	compare := func(i, j int) int {
+		if i == len(actual) {
+			return 1
+		} else if j == len(cached) {
+			return -1
+		}
+		return strings.Compare(actual[i], cached[j])
+	}
+
+	for i, j := 0, 0; i < len(actual) || j < len(cached); {
+		switch compare(i, j) {
+		case 0:
+			i++
+			j++
+		case -1:
+			missed = append(missed, actual[i])
+			i++
+		case 1:
+			redundant = append(redundant, cached[j])
+			j++
+		}
+	}
+
+	return
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger/comparer_test.go

@@ -0,0 +1,192 @@
+/*
+Copyright 2018 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 debugger
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+)
+
+func TestCompareNodes(t *testing.T) {
+	tests := []struct {
+		name      string
+		actual    []string
+		cached    []string
+		missing   []string
+		redundant []string
+	}{
+		{
+			name:      "redundant cached value",
+			actual:    []string{"foo", "bar"},
+			cached:    []string{"bar", "foo", "foobar"},
+			missing:   []string{},
+			redundant: []string{"foobar"},
+		},
+		{
+			name:      "missing cached value",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"bar", "foo"},
+			missing:   []string{"foobar"},
+			redundant: []string{},
+		},
+		{
+			name:      "proper cache set",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"bar", "foobar", "foo"},
+			missing:   []string{},
+			redundant: []string{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			testCompareNodes(test.actual, test.cached, test.missing, test.redundant, t)
+		})
+	}
+}
+
+func testCompareNodes(actual, cached, missing, redundant []string, t *testing.T) {
+	compare := CacheComparer{}
+	nodes := []*v1.Node{}
+	for _, nodeName := range actual {
+		node := &v1.Node{}
+		node.Name = nodeName
+		nodes = append(nodes, node)
+	}
+
+	nodeInfo := make(map[string]*schedulercache.NodeInfo)
+	for _, nodeName := range cached {
+		nodeInfo[nodeName] = &schedulercache.NodeInfo{}
+	}
+
+	m, r := compare.CompareNodes(nodes, nodeInfo)
+
+	if !reflect.DeepEqual(m, missing) {
+		t.Errorf("missing expected to be %s; got %s", missing, m)
+	}
+
+	if !reflect.DeepEqual(r, redundant) {
+		t.Errorf("redundant expected to be %s; got %s", redundant, r)
+	}
+}
+
+func TestComparePods(t *testing.T) {
+	tests := []struct {
+		name      string
+		actual    []string
+		cached    []string
+		queued    []string
+		missing   []string
+		redundant []string
+	}{
+		{
+			name:      "redundant cached value",
+			actual:    []string{"foo", "bar"},
+			cached:    []string{"bar", "foo", "foobar"},
+			queued:    []string{},
+			missing:   []string{},
+			redundant: []string{"foobar"},
+		},
+		{
+			name:      "redundant and queued values",
+			actual:    []string{"foo", "bar"},
+			cached:    []string{"foo", "foobar"},
+			queued:    []string{"bar"},
+			missing:   []string{},
+			redundant: []string{"foobar"},
+		},
+		{
+			name:      "missing cached value",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"bar", "foo"},
+			queued:    []string{},
+			missing:   []string{"foobar"},
+			redundant: []string{},
+		},
+		{
+			name:      "missing and queued values",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"foo"},
+			queued:    []string{"bar"},
+			missing:   []string{"foobar"},
+			redundant: []string{},
+		},
+		{
+			name:      "correct cache set",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"bar", "foobar", "foo"},
+			queued:    []string{},
+			missing:   []string{},
+			redundant: []string{},
+		},
+		{
+			name:      "queued cache value",
+			actual:    []string{"foo", "bar", "foobar"},
+			cached:    []string{"foobar", "foo"},
+			queued:    []string{"bar"},
+			missing:   []string{},
+			redundant: []string{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			testComparePods(test.actual, test.cached, test.queued, test.missing, test.redundant, t)
+		})
+	}
+}
+
+func testComparePods(actual, cached, queued, missing, redundant []string, t *testing.T) {
+	compare := CacheComparer{}
+	pods := []*v1.Pod{}
+	for _, uid := range actual {
+		pod := &v1.Pod{}
+		pod.UID = types.UID(uid)
+		pods = append(pods, pod)
+	}
+
+	queuedPods := []*v1.Pod{}
+	for _, uid := range queued {
+		pod := &v1.Pod{}
+		pod.UID = types.UID(uid)
+		queuedPods = append(queuedPods, pod)
+	}
+
+	nodeInfo := make(map[string]*schedulercache.NodeInfo)
+	for _, uid := range cached {
+		pod := &v1.Pod{}
+		pod.UID = types.UID(uid)
+		pod.Namespace = "ns"
+		pod.Name = uid
+
+		nodeInfo[uid] = schedulercache.NewNodeInfo(pod)
+	}
+
+	m, r := compare.ComparePods(pods, queuedPods, nodeInfo)
+
+	if !reflect.DeepEqual(m, missing) {
+		t.Errorf("missing expected to be %s; got %s", missing, m)
+	}
+
+	if !reflect.DeepEqual(r, redundant) {
+		t.Errorf("redundant expected to be %s; got %s", redundant, r)
+	}
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger/debugger.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2018 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 debugger
+
+import (
+	corelisters "k8s.io/client-go/listers/core/v1"
+	internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
+	internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
+)
+
+// CacheDebugger provides ways to check and write cache information for debugging.
+type CacheDebugger struct {
+	Comparer CacheComparer
+	Dumper   CacheDumper
+}
+
+// New creates a CacheDebugger.
+func New(
+	nodeLister corelisters.NodeLister,
+	podLister corelisters.PodLister,
+	cache internalcache.Cache,
+	podQueue internalqueue.SchedulingQueue,
+) *CacheDebugger {
+	return &CacheDebugger{
+		Comparer: CacheComparer{
+			NodeLister: nodeLister,
+			PodLister:  podLister,
+			Cache:      cache,
+			PodQueue:   podQueue,
+		},
+		Dumper: CacheDumper{
+			cache:    cache,
+			podQueue: podQueue,
+		},
+	}
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/debugger/dumper.go

@@ -0,0 +1,78 @@
+/*
+Copyright 2018 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 debugger
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/klog"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/pkg/scheduler/cache"
+	internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
+	"k8s.io/kubernetes/pkg/scheduler/internal/queue"
+)
+
+// CacheDumper writes some information from the scheduler cache and the scheduling queue to the
+// scheduler logs for debugging purposes.
+type CacheDumper struct {
+	cache    internalcache.Cache
+	podQueue queue.SchedulingQueue
+}
+
+// DumpAll writes cached nodes and scheduling queue information to the scheduler logs.
+func (d *CacheDumper) DumpAll() {
+	d.dumpNodes()
+	d.dumpSchedulingQueue()
+}
+
+// dumpNodes writes NodeInfo to the scheduler logs.
+func (d *CacheDumper) dumpNodes() {
+	snapshot := d.cache.Snapshot()
+	klog.Info("Dump of cached NodeInfo")
+	for _, nodeInfo := range snapshot.Nodes {
+		klog.Info(printNodeInfo(nodeInfo))
+	}
+}
+
+// dumpSchedulingQueue writes pods in the scheduling queue to the scheduler logs.
+func (d *CacheDumper) dumpSchedulingQueue() {
+	waitingPods := d.podQueue.WaitingPods()
+	var podData strings.Builder
+	for _, p := range waitingPods {
+		podData.WriteString(printPod(p))
+	}
+	klog.Infof("Dump of scheduling queue:\n%s", podData.String())
+}
+
+// printNodeInfo writes parts of NodeInfo to a string.
+func printNodeInfo(n *cache.NodeInfo) string {
+	var nodeData strings.Builder
+	nodeData.WriteString(fmt.Sprintf("\nNode name: %+v\nRequested Resources: %+v\nAllocatable Resources:%+v\nNumber of Pods: %v\nPods:\n",
+		n.Node().Name, n.RequestedResource(), n.AllocatableResource(), len(n.Pods())))
+	// Dumping Pod Info
+	for _, p := range n.Pods() {
+		nodeData.WriteString(printPod(p))
+	}
+	return nodeData.String()
+}
+
+// printPod writes parts of a Pod object to a string.
+func printPod(p *v1.Pod) string {
+	return fmt.Sprintf("name: %v, namespace: %v, uid: %v, phase: %v, nominated node: %v\n", p.Name, p.Namespace, p.UID, p.Status.Phase, p.Status.NominatedNodeName)
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/fake/BUILD

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["fake_cache.go"],
+    importpath = "k8s.io/kubernetes/pkg/scheduler/internal/cache/fake",
+    visibility = ["//pkg/scheduler:__subpackages__"],
+    deps = [
+        "//pkg/scheduler/cache:go_default_library",
+        "//pkg/scheduler/internal/cache:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/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"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/fake/fake_cache.go

@@ -0,0 +1,96 @@
+/*
+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 fake
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+	schedulerinternalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
+)
+
+// Cache is used for testing
+type Cache struct {
+	AssumeFunc       func(*v1.Pod)
+	ForgetFunc       func(*v1.Pod)
+	IsAssumedPodFunc func(*v1.Pod) bool
+	GetPodFunc       func(*v1.Pod) *v1.Pod
+}
+
+// AssumePod is a fake method for testing.
+func (c *Cache) AssumePod(pod *v1.Pod) error {
+	c.AssumeFunc(pod)
+	return nil
+}
+
+// FinishBinding is a fake method for testing.
+func (c *Cache) FinishBinding(pod *v1.Pod) error { return nil }
+
+// ForgetPod is a fake method for testing.
+func (c *Cache) ForgetPod(pod *v1.Pod) error {
+	c.ForgetFunc(pod)
+	return nil
+}
+
+// AddPod is a fake method for testing.
+func (c *Cache) AddPod(pod *v1.Pod) error { return nil }
+
+// UpdatePod is a fake method for testing.
+func (c *Cache) UpdatePod(oldPod, newPod *v1.Pod) error { return nil }
+
+// RemovePod is a fake method for testing.
+func (c *Cache) RemovePod(pod *v1.Pod) error { return nil }
+
+// IsAssumedPod is a fake method for testing.
+func (c *Cache) IsAssumedPod(pod *v1.Pod) (bool, error) {
+	return c.IsAssumedPodFunc(pod), nil
+}
+
+// GetPod is a fake method for testing.
+func (c *Cache) GetPod(pod *v1.Pod) (*v1.Pod, error) {
+	return c.GetPodFunc(pod), nil
+}
+
+// AddNode is a fake method for testing.
+func (c *Cache) AddNode(node *v1.Node) error { return nil }
+
+// UpdateNode is a fake method for testing.
+func (c *Cache) UpdateNode(oldNode, newNode *v1.Node) error { return nil }
+
+// RemoveNode is a fake method for testing.
+func (c *Cache) RemoveNode(node *v1.Node) error { return nil }
+
+// UpdateNodeNameToInfoMap is a fake method for testing.
+func (c *Cache) UpdateNodeNameToInfoMap(infoMap map[string]*schedulercache.NodeInfo) error {
+	return nil
+}
+
+// List is a fake method for testing.
+func (c *Cache) List(s labels.Selector) ([]*v1.Pod, error) { return nil, nil }
+
+// FilteredList is a fake method for testing.
+func (c *Cache) FilteredList(filter schedulerinternalcache.PodFilter, selector labels.Selector) ([]*v1.Pod, error) {
+	return nil, nil
+}
+
+// Snapshot is a fake method for testing
+func (c *Cache) Snapshot() *schedulerinternalcache.Snapshot {
+	return &schedulerinternalcache.Snapshot{}
+}
+
+// NodeTree is a fake method for testing.
+func (c *Cache) NodeTree() *schedulerinternalcache.NodeTree { return nil }

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/interface.go

@@ -0,0 +1,122 @@
+/*
+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 cache
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+)
+
+// PodFilter is a function to filter a pod. If pod passed return true else return false.
+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
+
+	// GetPod returns the pod from the cache with the same namespace and the
+	// same name of the specified pod.
+	GetPod(pod *v1.Pod) (*v1.Pod, error)
+
+	// IsAssumedPod returns true if the pod is assumed and not expired.
+	IsAssumedPod(pod *v1.Pod) (bool, 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]*schedulercache.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)
+
+	// Snapshot takes a snapshot on current cache
+	Snapshot() *Snapshot
+
+	// NodeTree returns a node tree structure
+	NodeTree() *NodeTree
+}
+
+// Snapshot is a snapshot of cache state
+type Snapshot struct {
+	AssumedPods map[string]bool
+	Nodes       map[string]*schedulercache.NodeInfo
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/main_test.go

@@ -0,0 +1,29 @@
+/*
+Copyright 2018 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 cache
+
+import (
+	"testing"
+
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	utilfeaturetesting "k8s.io/apiserver/pkg/util/feature/testing"
+	_ "k8s.io/kubernetes/pkg/features"
+)
+
+func TestMain(m *testing.M) {
+	utilfeaturetesting.VerifyFeatureGatesUnchanged(utilfeature.DefaultFeatureGate, m.Run)
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/node_tree.go

@@ -0,0 +1,186 @@
+/*
+Copyright 2018 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 cache
+
+import (
+	"fmt"
+	"sync"
+
+	"k8s.io/api/core/v1"
+	utilnode "k8s.io/kubernetes/pkg/util/node"
+
+	"k8s.io/klog"
+)
+
+// NodeTree is a tree-like data structure that holds node names in each zone. Zone names are
+// keys to "NodeTree.tree" and values of "NodeTree.tree" are arrays of node names.
+type NodeTree struct {
+	tree      map[string]*nodeArray // a map from zone (region-zone) to an array of nodes in the zone.
+	zones     []string              // a list of all the zones in the tree (keys)
+	zoneIndex int
+	NumNodes  int
+	mu        sync.RWMutex
+}
+
+// nodeArray is a struct that has nodes that are in a zone.
+// We use a slice (as opposed to a set/map) to store the nodes because iterating over the nodes is
+// a lot more frequent than searching them by name.
+type nodeArray struct {
+	nodes     []string
+	lastIndex int
+}
+
+func (na *nodeArray) next() (nodeName string, exhausted bool) {
+	if len(na.nodes) == 0 {
+		klog.Error("The nodeArray is empty. It should have been deleted from NodeTree.")
+		return "", false
+	}
+	if na.lastIndex >= len(na.nodes) {
+		return "", true
+	}
+	nodeName = na.nodes[na.lastIndex]
+	na.lastIndex++
+	return nodeName, false
+}
+
+// newNodeTree creates a NodeTree from nodes.
+func newNodeTree(nodes []*v1.Node) *NodeTree {
+	nt := &NodeTree{
+		tree: make(map[string]*nodeArray),
+	}
+	for _, n := range nodes {
+		nt.AddNode(n)
+	}
+	return nt
+}
+
+// AddNode adds a node and its corresponding zone to the tree. If the zone already exists, the node
+// is added to the array of nodes in that zone.
+func (nt *NodeTree) AddNode(n *v1.Node) {
+	nt.mu.Lock()
+	defer nt.mu.Unlock()
+	nt.addNode(n)
+}
+
+func (nt *NodeTree) addNode(n *v1.Node) {
+	zone := utilnode.GetZoneKey(n)
+	if na, ok := nt.tree[zone]; ok {
+		for _, nodeName := range na.nodes {
+			if nodeName == n.Name {
+				klog.Warningf("node %v already exist in the NodeTree", n.Name)
+				return
+			}
+		}
+		na.nodes = append(na.nodes, n.Name)
+	} else {
+		nt.zones = append(nt.zones, zone)
+		nt.tree[zone] = &nodeArray{nodes: []string{n.Name}, lastIndex: 0}
+	}
+	klog.V(5).Infof("Added node %v in group %v to NodeTree", n.Name, zone)
+	nt.NumNodes++
+}
+
+// RemoveNode removes a node from the NodeTree.
+func (nt *NodeTree) RemoveNode(n *v1.Node) error {
+	nt.mu.Lock()
+	defer nt.mu.Unlock()
+	return nt.removeNode(n)
+}
+
+func (nt *NodeTree) removeNode(n *v1.Node) error {
+	zone := utilnode.GetZoneKey(n)
+	if na, ok := nt.tree[zone]; ok {
+		for i, nodeName := range na.nodes {
+			if nodeName == n.Name {
+				na.nodes = append(na.nodes[:i], na.nodes[i+1:]...)
+				if len(na.nodes) == 0 {
+					nt.removeZone(zone)
+				}
+				klog.V(5).Infof("Removed node %v in group %v from NodeTree", n.Name, zone)
+				nt.NumNodes--
+				return nil
+			}
+		}
+	}
+	klog.Errorf("Node %v in group %v was not found", n.Name, zone)
+	return fmt.Errorf("node %v in group %v was not found", n.Name, zone)
+}
+
+// removeZone removes a zone from tree.
+// This function must be called while writer locks are hold.
+func (nt *NodeTree) removeZone(zone string) {
+	delete(nt.tree, zone)
+	for i, z := range nt.zones {
+		if z == zone {
+			nt.zones = append(nt.zones[:i], nt.zones[i+1:]...)
+		}
+	}
+}
+
+// UpdateNode updates a node in the NodeTree.
+func (nt *NodeTree) UpdateNode(old, new *v1.Node) {
+	var oldZone string
+	if old != nil {
+		oldZone = utilnode.GetZoneKey(old)
+	}
+	newZone := utilnode.GetZoneKey(new)
+	// If the zone ID of the node has not changed, we don't need to do anything. Name of the node
+	// cannot be changed in an update.
+	if oldZone == newZone {
+		return
+	}
+	nt.mu.Lock()
+	defer nt.mu.Unlock()
+	nt.removeNode(old) // No error checking. We ignore whether the old node exists or not.
+	nt.addNode(new)
+}
+
+func (nt *NodeTree) resetExhausted() {
+	for _, na := range nt.tree {
+		na.lastIndex = 0
+	}
+	nt.zoneIndex = 0
+}
+
+// Next returns the name of the next node. NodeTree iterates over zones and in each zone iterates
+// over nodes in a round robin fashion.
+func (nt *NodeTree) Next() string {
+	nt.mu.Lock()
+	defer nt.mu.Unlock()
+	if len(nt.zones) == 0 {
+		return ""
+	}
+	numExhaustedZones := 0
+	for {
+		if nt.zoneIndex >= len(nt.zones) {
+			nt.zoneIndex = 0
+		}
+		zone := nt.zones[nt.zoneIndex]
+		nt.zoneIndex++
+		// We do not check the exhausted zones before calling next() on the zone. This ensures
+		// that if more nodes are added to a zone after it is exhausted, we iterate over the new nodes.
+		nodeName, exhausted := nt.tree[zone].next()
+		if exhausted {
+			numExhaustedZones++
+			if numExhaustedZones >= len(nt.zones) { // all zones are exhausted. we should reset.
+				nt.resetExhausted()
+			}
+		} else {
+			return nodeName
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/scheduler/internal/cache/node_tree_test.go

@@ -0,0 +1,448 @@
+/*
+Copyright 2018 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 cache
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
+)
+
+var allNodes = []*v1.Node{
+	// Node 0: a node without any region-zone label
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-0",
+		},
+	},
+	// Node 1: a node with region label only
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-1",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion: "region-1",
+			},
+		},
+	},
+	// Node 2: a node with zone label only
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-2",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	},
+	// Node 3: a node with proper region and zone labels
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-3",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-1",
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	},
+	// Node 4: a node with proper region and zone labels
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-4",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-1",
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	},
+	// Node 5: a node with proper region and zone labels in a different zone, same region as above
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-5",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-1",
+				kubeletapis.LabelZoneFailureDomain: "zone-3",
+			},
+		},
+	},
+	// Node 6: a node with proper region and zone labels in a new region and zone
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-6",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-2",
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	},
+	// Node 7: a node with proper region and zone labels in a region and zone as node-6
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-7",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-2",
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	},
+	// Node 8: a node with proper region and zone labels in a region and zone as node-6
+	{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "node-8",
+			Labels: map[string]string{
+				kubeletapis.LabelZoneRegion:        "region-2",
+				kubeletapis.LabelZoneFailureDomain: "zone-2",
+			},
+		},
+	}}
+
+func verifyNodeTree(t *testing.T, nt *NodeTree, expectedTree map[string]*nodeArray) {
+	expectedNumNodes := int(0)
+	for _, na := range expectedTree {
+		expectedNumNodes += len(na.nodes)
+	}
+	if nt.NumNodes != expectedNumNodes {
+		t.Errorf("unexpected NodeTree.numNodes. Expected: %v, Got: %v", expectedNumNodes, nt.NumNodes)
+	}
+	if !reflect.DeepEqual(nt.tree, expectedTree) {
+		t.Errorf("The node tree is not the same as expected. Expected: %v, Got: %v", expectedTree, nt.tree)
+	}
+	if len(nt.zones) != len(expectedTree) {
+		t.Errorf("Number of zones in NodeTree.zones is not expected. Expected: %v, Got: %v", len(expectedTree), len(nt.zones))
+	}
+	for _, z := range nt.zones {
+		if _, ok := expectedTree[z]; !ok {
+			t.Errorf("zone %v is not expected to exist in NodeTree.zones", z)
+		}
+	}
+}
+
+func TestNodeTree_AddNode(t *testing.T) {
+	tests := []struct {
+		name         string
+		nodesToAdd   []*v1.Node
+		expectedTree map[string]*nodeArray
+	}{
+		{
+			name:         "single node no labels",
+			nodesToAdd:   allNodes[:1],
+			expectedTree: map[string]*nodeArray{"": {[]string{"node-0"}, 0}},
+		},
+		{
+			name:       "mix of nodes with and without proper labels",
+			nodesToAdd: allNodes[:4],
+			expectedTree: map[string]*nodeArray{
+				"":                     {[]string{"node-0"}, 0},
+				"region-1:\x00:":       {[]string{"node-1"}, 0},
+				":\x00:zone-2":         {[]string{"node-2"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-3"}, 0},
+			},
+		},
+		{
+			name:       "mix of nodes with and without proper labels and some zones with multiple nodes",
+			nodesToAdd: allNodes[:7],
+			expectedTree: map[string]*nodeArray{
+				"":                     {[]string{"node-0"}, 0},
+				"region-1:\x00:":       {[]string{"node-1"}, 0},
+				":\x00:zone-2":         {[]string{"node-2"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-3", "node-4"}, 0},
+				"region-1:\x00:zone-3": {[]string{"node-5"}, 0},
+				"region-2:\x00:zone-2": {[]string{"node-6"}, 0},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			nt := newNodeTree(nil)
+			for _, n := range test.nodesToAdd {
+				nt.AddNode(n)
+			}
+			verifyNodeTree(t, nt, test.expectedTree)
+		})
+	}
+}
+
+func TestNodeTree_RemoveNode(t *testing.T) {
+	tests := []struct {
+		name          string
+		existingNodes []*v1.Node
+		nodesToRemove []*v1.Node
+		expectedTree  map[string]*nodeArray
+		expectError   bool
+	}{
+		{
+			name:          "remove a single node with no labels",
+			existingNodes: allNodes[:7],
+			nodesToRemove: allNodes[:1],
+			expectedTree: map[string]*nodeArray{
+				"region-1:\x00:":       {[]string{"node-1"}, 0},
+				":\x00:zone-2":         {[]string{"node-2"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-3", "node-4"}, 0},
+				"region-1:\x00:zone-3": {[]string{"node-5"}, 0},
+				"region-2:\x00:zone-2": {[]string{"node-6"}, 0},
+			},
+		},
+		{
+			name:          "remove a few nodes including one from a zone with multiple nodes",
+			existingNodes: allNodes[:7],
+			nodesToRemove: allNodes[1:4],
+			expectedTree: map[string]*nodeArray{
+				"":                     {[]string{"node-0"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-4"}, 0},
+				"region-1:\x00:zone-3": {[]string{"node-5"}, 0},
+				"region-2:\x00:zone-2": {[]string{"node-6"}, 0},
+			},
+		},
+		{
+			name:          "remove all nodes",
+			existingNodes: allNodes[:7],
+			nodesToRemove: allNodes[:7],
+			expectedTree:  map[string]*nodeArray{},
+		},
+		{
+			name:          "remove non-existing node",
+			existingNodes: nil,
+			nodesToRemove: allNodes[:5],
+			expectedTree:  map[string]*nodeArray{},
+			expectError:   true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			nt := newNodeTree(test.existingNodes)
+			for _, n := range test.nodesToRemove {
+				err := nt.RemoveNode(n)
+				if test.expectError == (err == nil) {
+					t.Errorf("unexpected returned error value: %v", err)
+				}
+			}
+			verifyNodeTree(t, nt, test.expectedTree)
+		})
+	}
+}
+
+func TestNodeTree_UpdateNode(t *testing.T) {
+	tests := []struct {
+		name          string
+		existingNodes []*v1.Node
+		nodeToUpdate  *v1.Node
+		expectedTree  map[string]*nodeArray
+	}{
+		{
+			name:          "update a node without label",
+			existingNodes: allNodes[:7],
+			nodeToUpdate: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "node-0",
+					Labels: map[string]string{
+						kubeletapis.LabelZoneRegion:        "region-1",
+						kubeletapis.LabelZoneFailureDomain: "zone-2",
+					},
+				},
+			},
+			expectedTree: map[string]*nodeArray{
+				"region-1:\x00:":       {[]string{"node-1"}, 0},
+				":\x00:zone-2":         {[]string{"node-2"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-3", "node-4", "node-0"}, 0},
+				"region-1:\x00:zone-3": {[]string{"node-5"}, 0},
+				"region-2:\x00:zone-2": {[]string{"node-6"}, 0},
+			},
+		},
+		{
+			name:          "update the only existing node",
+			existingNodes: allNodes[:1],
+			nodeToUpdate: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "node-0",
+					Labels: map[string]string{
+						kubeletapis.LabelZoneRegion:        "region-1",
+						kubeletapis.LabelZoneFailureDomain: "zone-2",
+					},
+				},
+			},
+			expectedTree: map[string]*nodeArray{
+				"region-1:\x00:zone-2": {[]string{"node-0"}, 0},
+			},
+		},
+		{
+			name:          "update non-existing node",
+			existingNodes: allNodes[:1],
+			nodeToUpdate: &v1.Node{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "node-new",
+					Labels: map[string]string{
+						kubeletapis.LabelZoneRegion:        "region-1",
+						kubeletapis.LabelZoneFailureDomain: "zone-2",
+					},
+				},
+			},
+			expectedTree: map[string]*nodeArray{
+				"":                     {[]string{"node-0"}, 0},
+				"region-1:\x00:zone-2": {[]string{"node-new"}, 0},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			nt := newNodeTree(test.existingNodes)
+			var oldNode *v1.Node
+			for _, n := range allNodes {
+				if n.Name == test.nodeToUpdate.Name {
+					oldNode = n
+					break
+				}
+			}
+			if oldNode == nil {
+				oldNode = &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "nonexisting-node"}}
+			}
+			nt.UpdateNode(oldNode, test.nodeToUpdate)
+			verifyNodeTree(t, nt, test.expectedTree)
+		})
+	}
+}
+
+func TestNodeTree_Next(t *testing.T) {
+	tests := []struct {
+		name           string
+		nodesToAdd     []*v1.Node
+		numRuns        int // number of times to run Next()
+		expectedOutput []string
+	}{
+		{
+			name:           "empty tree",
+			nodesToAdd:     nil,
+			numRuns:        2,
+			expectedOutput: []string{"", ""},
+		},
+		{
+			name:           "should go back to the first node after finishing a round",
+			nodesToAdd:     allNodes[:1],
+			numRuns:        2,
+			expectedOutput: []string{"node-0", "node-0"},
+		},
+		{
+			name:           "should go back to the first node after going over all nodes",
+			nodesToAdd:     allNodes[:4],
+			numRuns:        5,
+			expectedOutput: []string{"node-0", "node-1", "node-2", "node-3", "node-0"},
+		},
+		{
+			name:           "should go to all zones before going to the second nodes in the same zone",
+			nodesToAdd:     allNodes[:9],
+			numRuns:        11,
+			expectedOutput: []string{"node-0", "node-1", "node-2", "node-3", "node-5", "node-6", "node-4", "node-7", "node-8", "node-0", "node-1"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			nt := newNodeTree(test.nodesToAdd)
+
+			var output []string
+			for i := 0; i < test.numRuns; i++ {
+				output = append(output, nt.Next())
+			}
+			if !reflect.DeepEqual(output, test.expectedOutput) {
+				t.Errorf("unexpected output. Expected: %v, Got: %v", test.expectedOutput, output)
+			}
+		})
+	}
+}
+
+func TestNodeTreeMultiOperations(t *testing.T) {
+	tests := []struct {
+		name           string
+		nodesToAdd     []*v1.Node
+		nodesToRemove  []*v1.Node
+		operations     []string
+		expectedOutput []string
+	}{
+		{
+			name:           "add and remove all nodes between two Next operations",
+			nodesToAdd:     allNodes[2:9],
+			nodesToRemove:  allNodes[2:9],
+			operations:     []string{"add", "add", "next", "add", "remove", "remove", "remove", "next"},
+			expectedOutput: []string{"node-2", ""},
+		},
+		{
+			name:           "add and remove some nodes between two Next operations",
+			nodesToAdd:     allNodes[2:9],
+			nodesToRemove:  allNodes[2:9],
+			operations:     []string{"add", "add", "next", "add", "remove", "remove", "next"},
+			expectedOutput: []string{"node-2", "node-4"},
+		},
+		{
+			name:           "remove nodes already iterated on and add new nodes",
+			nodesToAdd:     allNodes[2:9],
+			nodesToRemove:  allNodes[2:9],
+			operations:     []string{"add", "add", "next", "next", "add", "remove", "remove", "next"},
+			expectedOutput: []string{"node-2", "node-3", "node-4"},
+		},
+		{
+			name:           "add more nodes to an exhausted zone",
+			nodesToAdd:     append(allNodes[4:9], allNodes[3]),
+			nodesToRemove:  nil,
+			operations:     []string{"add", "add", "add", "add", "add", "next", "next", "next", "next", "add", "next", "next", "next"},
+			expectedOutput: []string{"node-4", "node-5", "node-6", "node-7", "node-3", "node-8", "node-4"},
+		},
+		{
+			name:           "remove zone and add new to ensure exhausted is reset correctly",
+			nodesToAdd:     append(allNodes[3:5], allNodes[6:8]...),
+			nodesToRemove:  allNodes[3:5],
+			operations:     []string{"add", "add", "next", "next", "remove", "add", "add", "next", "next", "remove", "next", "next"},
+			expectedOutput: []string{"node-3", "node-4", "node-6", "node-7", "node-6", "node-7"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			nt := newNodeTree(nil)
+			addIndex := 0
+			removeIndex := 0
+			var output []string
+			for _, op := range test.operations {
+				switch op {
+				case "add":
+					if addIndex >= len(test.nodesToAdd) {
+						t.Error("more add operations than nodesToAdd")
+					} else {
+						nt.AddNode(test.nodesToAdd[addIndex])
+						addIndex++
+					}
+				case "remove":
+					if removeIndex >= len(test.nodesToRemove) {
+						t.Error("more remove operations than nodesToRemove")
+					} else {
+						nt.RemoveNode(test.nodesToRemove[removeIndex])
+						removeIndex++
+					}
+				case "next":
+					output = append(output, nt.Next())
+				default:
+					t.Errorf("unknow operation: %v", op)
+				}
+			}
+			if !reflect.DeepEqual(output, test.expectedOutput) {
+				t.Errorf("unexpected output. Expected: %v, Got: %v", test.expectedOutput, output)
+			}
+		})
+	}
+}