github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
k3s/pkg/scheduler/core/generic_scheduler_test.go

1645 lines
82 KiB
Go
Raw Normal View History

Add a generic scheduler.
2014-09-24 16:32:36 +00:00
/*
Remove "All rights reserved" from all the headers.
2016-06-03 00:25:58 +00:00
Copyright 2014 The Kubernetes Authors.
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
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.
*/
'core' package to prevent dependency creep and isolate core functionality from daemon. Add core build file
2017-01-31 16:03:46 +00:00
package core
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
import (
"fmt"
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
"math"
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
"reflect"
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
"strconv"
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
"strings"
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
"testing"
Remove nodeName from predicate signature.
2016-04-28 14:51:17 +00:00
"time"
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
use apps/v1 version for scheduler
2018-07-26 07:38:26 +00:00
apps "k8s.io/api/apps/v1"
run hack/update-all
2017-06-22 18:24:23 +00:00
"k8s.io/api/core/v1"
pkg/api/resource: move to apimachinery
2017-01-25 13:13:07 +00:00
"k8s.io/apimachinery/pkg/api/resource"
refactor: use metav1.ObjectMeta in other types
2017-01-17 03:38:19 +00:00
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
"k8s.io/apimachinery/pkg/types"
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
"k8s.io/apimachinery/pkg/util/errors"
start the apimachinery repo
2017-01-11 14:09:48 +00:00
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/wait"
Move scheduler code out of plugin directory. This moves plugin/pkg/scheduler to pkg/scheduler and plugin/cmd/kube-scheduler to cmd/kube-scheduler. Bulk of the work was done with gomvpkg, except for kube-scheduler main package.
2018-01-04 02:12:18 +00:00
"k8s.io/kubernetes/pkg/scheduler/algorithm"
algorithmpredicates "k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
Move scheduler code out of plugin directory. This moves plugin/pkg/scheduler to pkg/scheduler and plugin/cmd/kube-scheduler to cmd/kube-scheduler. Bulk of the work was done with gomvpkg, except for kube-scheduler main package.
2018-01-04 02:12:18 +00:00
priorityutil "k8s.io/kubernetes/pkg/scheduler/algorithm/priorities/util"
schedulerapi "k8s.io/kubernetes/pkg/scheduler/api"
add scheduling framework configuration update bazel build fix get plugin config method initialize only needed plugins fix unit test fix import duplicate package update bazel add docstrings add weight field to plugin add plugin to v1alpha1 add plugins at appropriate extension points remove todo statement fix import package file path set plugin json schema add plugin unit test to option initial plugin in test integration initialize only needed plugins update bazel rename func change plugins needed logic remove v1 alias change the comment fix alias shorter remove blank line change docstrings fix map bool to struct add some docstrings add unreserve plugin fix docstrings move variable inside the for loop make if else statement cleaner remove plugin config from reserve plugin unit test add plugin config and reduce unnecessary options for unit test update bazel fix race condition fix permit plugin integration change plugins to be pointer change weight to int32 fix package alias initial queue sort plugin rename unreserve plugin redesign plugin struct update docstrings check queue sort plugin amount fix error message fix condition change plugin struct add disabled plugin for unit test fix docstrings handle nil plugin set
2019-05-04 10:29:30 +00:00
schedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
Update scheduler framework plugins to align with the latest changes to the framework design
2019-03-21 00:07:25 +00:00
framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
shorten scheduler package alias for better readability - schedulerinternalcache -> internalcache
2019-03-22 01:12:33 +00:00
internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
move SchedulingQueue to pkg/scheduler/internal/queue
2018-09-21 23:18:48 +00:00
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo"
Move scheduler code out of plugin directory. This moves plugin/pkg/scheduler to pkg/scheduler and plugin/cmd/kube-scheduler to cmd/kube-scheduler. Bulk of the work was done with gomvpkg, except for kube-scheduler main package.
2018-01-04 02:12:18 +00:00
schedulertesting "k8s.io/kubernetes/pkg/scheduler/testing"
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
)
implementing predicates ordering
2017-12-14 00:57:23 +00:00
var (
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
errPrioritize = fmt.Errorf("priority map encounters an error")
order = []string{"false", "true", "matches", "nopods", algorithmpredicates.MatchInterPodAffinityPred}
implementing predicates ordering
2017-12-14 00:57:23 +00:00
)
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func falsePredicate(pod *v1.Pod, meta algorithmpredicates.PredicateMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []algorithmpredicates.PredicateFailureReason, error) {
return false, []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate}, nil
Refactor schedulers, remove schedulers, use generic scheduler.
2014-09-25 18:56:57 +00:00
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func truePredicate(pod *v1.Pod, meta algorithmpredicates.PredicateMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []algorithmpredicates.PredicateFailureReason, error) {
Create PredicateFailureReason, modify scheduler predicate interface.
2016-08-09 12:01:46 +00:00
return true, nil, nil
Refactor schedulers, remove schedulers, use generic scheduler.
2014-09-25 18:56:57 +00:00
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func matchesPredicate(pod *v1.Pod, meta algorithmpredicates.PredicateMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []algorithmpredicates.PredicateFailureReason, error) {
Remove nodeName from predicate signature.
2016-04-28 14:51:17 +00:00
node := nodeInfo.Node()
if node == nil {
Create PredicateFailureReason, modify scheduler predicate interface.
2016-08-09 12:01:46 +00:00
return false, nil, fmt.Errorf("node not found")
Remove nodeName from predicate signature.
2016-04-28 14:51:17 +00:00
}
if pod.Name == node.Name {
Create PredicateFailureReason, modify scheduler predicate interface.
2016-08-09 12:01:46 +00:00
return true, nil, nil
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
return false, []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate}, nil
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func hasNoPodsPredicate(pod *v1.Pod, meta algorithmpredicates.PredicateMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []algorithmpredicates.PredicateFailureReason, error) {
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
if len(nodeInfo.Pods()) == 0 {
Create PredicateFailureReason, modify scheduler predicate interface.
2016-08-09 12:01:46 +00:00
return true, nil, nil
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
return false, []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate}, nil
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
func numericPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
Scheduler extension
2015-09-04 06:50:14 +00:00
result := []schedulerapi.HostPriority{}
Change storeToNodeConditionLister to return []*api.Node instead of api.NodeList for performance
2016-07-11 14:55:10 +00:00
for _, node := range nodes {
Replace "minion" with "node" in bunch of places.
2015-09-10 08:40:22 +00:00
score, err := strconv.Atoi(node.Name)
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
if err != nil {
return nil, err
}
Scheduler extension
2015-09-04 06:50:14 +00:00
result = append(result, schedulerapi.HostPriority{
Replace "minion" with "node" in bunch of places.
2015-09-10 08:40:22 +00:00
Host: node.Name,
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
Score: score,
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
})
}
return result, nil
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
func reverseNumericPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) {
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
var maxScore float64
minScore := math.MaxFloat64
Scheduler extension
2015-09-04 06:50:14 +00:00
reverseResult := []schedulerapi.HostPriority{}
Use []*api.Node instead of NodeLister in priority functions.
2016-07-19 12:35:43 +00:00
result, err := numericPriority(pod, nodeNameToInfo, nodes)
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
if err != nil {
return nil, err
}
for _, hostPriority := range result {
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
maxScore = math.Max(maxScore, float64(hostPriority.Score))
minScore = math.Min(minScore, float64(hostPriority.Score))
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
}
for _, hostPriority := range result {
Scheduler extension
2015-09-04 06:50:14 +00:00
reverseResult = append(reverseResult, schedulerapi.HostPriority{
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
Host: hostPriority.Host,
Score: int(maxScore + minScore - float64(hostPriority.Score)),
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
})
}
return reverseResult, nil
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
func trueMapPriority(pod *v1.Pod, meta interface{}, nodeInfo *schedulernodeinfo.NodeInfo) (schedulerapi.HostPriority, error) {
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
return schedulerapi.HostPriority{
Host: nodeInfo.Node().Name,
Score: 1,
}, nil
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
func falseMapPriority(pod *v1.Pod, meta interface{}, nodeInfo *schedulernodeinfo.NodeInfo) (schedulerapi.HostPriority, error) {
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
return schedulerapi.HostPriority{}, errPrioritize
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
func getNodeReducePriority(pod *v1.Pod, meta interface{}, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo, result schedulerapi.HostPriorityList) error {
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
for _, host := range result {
if host.Host == "" {
return fmt.Errorf("unexpected empty host name")
}
}
return nil
}
Update scheduler framework plugins to align with the latest changes to the framework design
2019-03-21 00:07:25 +00:00
// EmptyPluginRegistry is a test plugin set used by the default scheduler.
var EmptyPluginRegistry = framework.Registry{}
add scheduling framework configuration update bazel build fix get plugin config method initialize only needed plugins fix unit test fix import duplicate package update bazel add docstrings add weight field to plugin add plugin to v1alpha1 add plugins at appropriate extension points remove todo statement fix import package file path set plugin json schema add plugin unit test to option initial plugin in test integration initialize only needed plugins update bazel rename func change plugins needed logic remove v1 alias change the comment fix alias shorter remove blank line change docstrings fix map bool to struct add some docstrings add unreserve plugin fix docstrings move variable inside the for loop make if else statement cleaner remove plugin config from reserve plugin unit test add plugin config and reduce unnecessary options for unit test update bazel fix race condition fix permit plugin integration change plugins to be pointer change weight to int32 fix package alias initial queue sort plugin rename unreserve plugin redesign plugin struct update docstrings check queue sort plugin amount fix error message fix condition change plugin struct add disabled plugin for unit test fix docstrings handle nil plugin set
2019-05-04 10:29:30 +00:00
var emptyFramework, _ = framework.NewFramework(EmptyPluginRegistry, nil, []schedulerconfig.PluginConfig{})
Add plugin invocation for 'reserve' and 'prebind' plugins to the scheduler.
2018-11-09 02:08:38 +00:00
plugin/scheduler
2016-11-18 20:52:35 +00:00
func makeNodeList(nodeNames []string) []*v1.Node {
result := make([]*v1.Node, 0, len(nodeNames))
Change storeToNodeConditionLister to return []*api.Node instead of api.NodeList for performance
2016-07-11 14:55:10 +00:00
for _, nodeName := range nodeNames {
refactor: use metav1.ObjectMeta in other types
2017-01-17 03:38:19 +00:00
result = append(result, &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: nodeName}})
Add a least-requested priority function
2014-10-06 22:58:18 +00:00
}
return result
}
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
func TestSelectHost(t *testing.T) {
scheduler: remove unused random generator
2016-05-21 18:36:53 +00:00
scheduler := genericScheduler{}
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
tests := []struct {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name string
Scheduler extension
2015-09-04 06:50:14 +00:00
list schedulerapi.HostPriorityList
Move util.StringSet into its own package A lot of packages use StringSet, but they don't use anything else from the util package. Moving StringSet into another package will shrink their dependency trees significantly.
2015-09-09 17:45:01 +00:00
possibleHosts sets.String
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
expectsErr bool
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
}{
{
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "unique properly ordered scores",
Scheduler extension
2015-09-04 06:50:14 +00:00
list: []schedulerapi.HostPriority{
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
{Host: "machine1.1", Score: 1},
{Host: "machine2.1", Score: 2},
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
Move util.StringSet into its own package A lot of packages use StringSet, but they don't use anything else from the util package. Moving StringSet into another package will shrink their dependency trees significantly.
2015-09-09 17:45:01 +00:00
possibleHosts: sets.NewString("machine2.1"),
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
expectsErr: false,
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
{
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "equal scores",
Scheduler extension
2015-09-04 06:50:14 +00:00
list: []schedulerapi.HostPriority{
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
{Host: "machine1.1", Score: 1},
{Host: "machine1.2", Score: 2},
{Host: "machine1.3", Score: 2},
{Host: "machine2.1", Score: 2},
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
Move util.StringSet into its own package A lot of packages use StringSet, but they don't use anything else from the util package. Moving StringSet into another package will shrink their dependency trees significantly.
2015-09-09 17:45:01 +00:00
possibleHosts: sets.NewString("machine1.2", "machine1.3", "machine2.1"),
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
expectsErr: false,
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
{
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "out of order scores",
Scheduler extension
2015-09-04 06:50:14 +00:00
list: []schedulerapi.HostPriority{
Move pkg/scheduler to plugin/pkg/scheduler As the TODO in plugin/pkg/scheduler/scheduler.go described: move everything from pkg/scheduler into this package. Remove references from registry.
2015-05-08 11:01:09 +00:00
{Host: "machine1.1", Score: 3},
{Host: "machine1.2", Score: 3},
{Host: "machine2.1", Score: 2},
{Host: "machine3.1", Score: 1},
{Host: "machine1.3", Score: 3},
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
Move util.StringSet into its own package A lot of packages use StringSet, but they don't use anything else from the util package. Moving StringSet into another package will shrink their dependency trees significantly.
2015-09-09 17:45:01 +00:00
possibleHosts: sets.NewString("machine1.1", "machine1.2", "machine1.3"),
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
expectsErr: false,
},
{
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "empty priority list",
Scheduler extension
2015-09-04 06:50:14 +00:00
list: []schedulerapi.HostPriority{},
Move util.StringSet into its own package A lot of packages use StringSet, but they don't use anything else from the util package. Moving StringSet into another package will shrink their dependency trees significantly.
2015-09-09 17:45:01 +00:00
possibleHosts: sets.NewString(),
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
expectsErr: true,
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
},
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
// increase the randomness
for i := 0; i < 10; i++ {
got, err := scheduler.selectHost(test.list)
if test.expectsErr {
if err == nil {
t.Error("Unexpected non-error")
}
} else {
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if !test.possibleHosts.Has(got) {
t.Errorf("got %s is not in the possible map %v", got, test.possibleHosts)
}
Add check for empty priority list and refactor tests.
2014-11-07 05:38:41 +00:00
}
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
})
Add a test for selectHost of generic_scheduler
2014-11-06 05:48:42 +00:00
}
}
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
func TestGenericScheduler(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
tests := []struct {
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
name string
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates map[string]algorithmpredicates.FitPredicate
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers []priorities.PriorityConfig
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
alwaysCheckAllPredicates bool
nodes []string
pvcs []*v1.PersistentVolumeClaim
pod *v1.Pod
pods []*v1.Pod
expectedHosts sets.String
expectsErr bool
wErr error
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
}{
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"false": falsePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Scheduler changes to allow multiple priority functions
2014-11-20 22:42:31 +00:00
nodes: []string{"machine1", "machine2"},
expectsErr: true,
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
name: "test 1",
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
wErr: &FitError{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
Pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
clarify pridicates message when no nodes available fix space address comment
2017-10-06 13:58:59 +00:00
NumAllNodes: 2,
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
FailedPredicates: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
}},
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "ignore", UID: types.UID("ignore")}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
expectedHosts: sets.NewString("machine1", "machine2"),
name: "test 2",
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
wErr: nil,
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
{
Refactor the code to make it more readable.
2014-09-24 21:18:31 +00:00
// Fits on a machine where the pod ID matches the machine name
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": matchesPredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine2", UID: types.UID("machine2")}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
expectedHosts: sets.NewString("machine2"),
name: "test 3",
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
wErr: nil,
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Function: numericPriority, Weight: 1}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
nodes: []string{"3", "2", "1"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "ignore", UID: types.UID("ignore")}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
expectedHosts: sets.NewString("3"),
name: "test 4",
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
wErr: nil,
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": matchesPredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Function: numericPriority, Weight: 1}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
nodes: []string{"3", "2", "1"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
expectedHosts: sets.NewString("2"),
name: "test 5",
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
wErr: nil,
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
},
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Function: numericPriority, Weight: 1}, {Function: reverseNumericPriority, Weight: 2}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
nodes: []string{"3", "2", "1"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
Minor selectHost optimization in scheduler Instead of sorting hosts by score, find max score and choose one of the hosts with max score directly. Saves a little time on sorting and avoids extra copying of HostPriorityList entries. Test had to be updated as one of the test cases relied on having a stable order from pre-sorting.
2016-01-21 02:39:59 +00:00
expectedHosts: sets.NewString("1"),
name: "test 6",
move predicates into library (address #12744) DONE: 1. refactor all predicates: predicates return fitOrNot(bool) and error(Error) in which the latter is of type PredicateFailureError or InsufficientResourceError. (For violation of either MaxEBSVolumeCount or MaxGCEPDVolumeCount, returns one same error type as ErrMaxVolumeCountExceeded) 2. GeneralPredicates() is a predicate function, which includes serveral other predicate functions (PodFitsResource, PodFitsHost, PodFitsHostPort). It is registered as one of the predicates in DefaultAlgorithmProvider, and is also called in canAdmitPod() in Kubelet and should be called by other components (like rescheduler, etc) if necessary. See discussion in issue #12744 3. remove podNumber check from GeneralPredicates 4. HostName is now verified in Kubelet's canAdminPod(). add TestHostNameConflicts in kubelet_test.go 5. add getNodeAnyWay() method in Kubelet to get node information in standaloneMode TODO: 1. determine which predicates should be included in GeneralPredicates() 2. separate GeneralPredicates() into: a. GeneralPredicatesEvictPod() and b. GeneralPredicatesNotEvictPod() 3. DaemonSet should use GeneralPredicates()
2016-01-06 01:10:59 +00:00
wErr: nil,
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate, "false": falsePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Function: numericPriority, Weight: 1}},
Scheduler changes to allow multiple priority functions
2014-11-20 22:42:31 +00:00
nodes: []string{"3", "2", "1"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
Scheduler changes to allow multiple priority functions
2014-11-20 22:42:31 +00:00
expectsErr: true,
Combining scheduler priority functions using weighted averages
2014-11-26 02:10:25 +00:00
name: "test 7",
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
wErr: &FitError{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
Pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
clarify pridicates message when no nodes available fix space address comment
2017-10-06 13:58:59 +00:00
NumAllNodes: 3,
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
FailedPredicates: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
"2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
"1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
},
},
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
},
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
"nopods": hasNoPodsPredicate,
"matches": matchesPredicate,
},
plugin/scheduler
2016-11-18 20:52:35 +00:00
pods: []*v1.Pod{
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")},
plugin/scheduler
2016-11-18 20:52:35 +00:00
Spec: v1.PodSpec{
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
NodeName: "2",
},
plugin/scheduler
2016-11-18 20:52:35 +00:00
Status: v1.PodStatus{
Phase: v1.PodRunning,
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
},
},
},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Function: numericPriority, Weight: 1}},
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
nodes: []string{"1", "2"},
expectsErr: true,
name: "test 8",
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
wErr: &FitError{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
Pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
clarify pridicates message when no nodes available fix space address comment
2017-10-06 13:58:59 +00:00
NumAllNodes: 2,
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
FailedPredicates: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
"2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate},
Fix generic scheduler test
2016-07-20 12:46:50 +00:00
},
},
Fix the scheduler to ignore terminated pods.
2015-06-10 21:35:59 +00:00
},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
{
// Pod with existing PVC
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
nodes: []string{"machine1", "machine2"},
pvcs: []*v1.PersistentVolumeClaim{{ObjectMeta: metav1.ObjectMeta{Name: "existingPVC"}}},
pod: &v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
ObjectMeta: metav1.ObjectMeta{Name: "ignore", UID: types.UID("ignore")},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
Spec: v1.PodSpec{
Volumes: []v1.Volume{
{
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: "existingPVC",
},
},
},
},
},
},
expectedHosts: sets.NewString("machine1", "machine2"),
name: "existing PVC",
wErr: nil,
},
{
// Pod with non existing PVC
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
nodes: []string{"machine1", "machine2"},
pod: &v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
ObjectMeta: metav1.ObjectMeta{Name: "ignore", UID: types.UID("ignore")},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
Spec: v1.PodSpec{
Volumes: []v1.Volume{
{
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: "unknownPVC",
},
},
},
},
},
},
name: "unknown PVC",
expectsErr: true,
wErr: fmt.Errorf("persistentvolumeclaim \"unknownPVC\" not found"),
},
{
// Pod with deleting PVC
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
nodes: []string{"machine1", "machine2"},
pvcs: []*v1.PersistentVolumeClaim{{ObjectMeta: metav1.ObjectMeta{Name: "existingPVC", DeletionTimestamp: &metav1.Time{}}}},
pod: &v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
ObjectMeta: metav1.ObjectMeta{Name: "ignore", UID: types.UID("ignore")},
Skip pods that refer to PVCs that are being deleted Scheduler should ignore pods that refer to PVCs that either do not exist or are being deleted.
2017-11-23 09:01:23 +00:00
Spec: v1.PodSpec{
Volumes: []v1.Volume{
{
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: "existingPVC",
},
},
},
},
},
},
name: "deleted PVC",
expectsErr: true,
wErr: fmt.Errorf("persistentvolumeclaim \"existingPVC\" is being deleted"),
},
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
{
// alwaysCheckAllPredicates is true
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate, "matches": matchesPredicate, "false": falsePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}},
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
alwaysCheckAllPredicates: true,
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
nodes: []string{"1"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
name: "test alwaysCheckAllPredicates is true",
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
wErr: &FitError{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
Pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
NumAllNodes: 1,
FailedPredicates: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrFakePredicate, algorithmpredicates.ErrFakePredicate},
-Add scheduler optimization options, short circuit all predicates if one predicate fails
2017-12-21 15:03:46 +00:00
},
},
},
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"true": truePredicate},
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers: []priorities.PriorityConfig{{Map: falseMapPriority, Weight: 1}, {Map: trueMapPriority, Reduce: getNodeReducePriority, Weight: 2}},
fix scheduler crash when Prioritize Map function failed
2018-09-26 12:16:05 +00:00
nodes: []string{"2", "1"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
name: "test error with priority map",
wErr: errors.NewAggregate([]error{errPrioritize, errPrioritize}),
},
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
shorten scheduler package alias for better readability - schedulerinternalcache -> internalcache
2019-03-22 01:12:33 +00:00
cache := internalcache.New(time.Duration(0), wait.NeverStop)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
for _, pod := range test.pods {
cache.AddPod(pod)
}
for _, name := range test.nodes {
cache.AddNode(&v1.Node{ObjectMeta: metav1.ObjectMeta{Name: name}})
}
pvcs := []*v1.PersistentVolumeClaim{}
pvcs = append(pvcs, test.pvcs...)
pvcLister := schedulertesting.FakePersistentVolumeClaimLister(pvcs)
scheduler := NewGenericScheduler(
cache,
feat: implement "queue-sort" extension point for scheduling framework
2019-05-07 01:03:00 +00:00
internalqueue.NewSchedulingQueue(nil, nil),
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
test.predicates,
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
algorithmpredicates.EmptyPredicateMetadataProducer,
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
test.prioritizers,
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
priorities.EmptyPriorityMetadataProducer,
add scheduling framework configuration update bazel build fix get plugin config method initialize only needed plugins fix unit test fix import duplicate package update bazel add docstrings add weight field to plugin add plugin to v1alpha1 add plugins at appropriate extension points remove todo statement fix import package file path set plugin json schema add plugin unit test to option initial plugin in test integration initialize only needed plugins update bazel rename func change plugins needed logic remove v1 alias change the comment fix alias shorter remove blank line change docstrings fix map bool to struct add some docstrings add unreserve plugin fix docstrings move variable inside the for loop make if else statement cleaner remove plugin config from reserve plugin unit test add plugin config and reduce unnecessary options for unit test update bazel fix race condition fix permit plugin integration change plugins to be pointer change weight to int32 fix package alias initial queue sort plugin rename unreserve plugin redesign plugin struct update docstrings check queue sort plugin amount fix error message fix condition change plugin struct add disabled plugin for unit test fix docstrings handle nil plugin set
2019-05-04 10:29:30 +00:00
emptyFramework,
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
[]algorithm.SchedulerExtender{},
nil,
pvcLister,
Remove PDB and its event handlers from the scheduler cache
2018-09-19 00:05:48 +00:00
schedulertesting.FakePDBLister{},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
test.alwaysCheckAllPredicates,
Add a scheduler config argument to set the percentage of nodes to score
2018-07-28 00:17:09 +00:00
false,
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
schedulerapi.DefaultPercentageOfNodesToScore,
false)
[scheduler] Modify the scheduling result struct and improve logging for successful binding
2018-12-07 03:40:45 +00:00
result, err := scheduler.Schedule(test.pod, schedulertesting.FakeNodeLister(makeNodeList(test.nodes)))
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
if !reflect.DeepEqual(err, test.wErr) {
t.Errorf("Unexpected error: %v, expected: %v", err, test.wErr)
}
[scheduler] Modify the scheduling result struct and improve logging for successful binding
2018-12-07 03:40:45 +00:00
if test.expectedHosts != nil && !test.expectedHosts.Has(result.SuggestedHost) {
t.Errorf("Expected: %s, got: %s", test.expectedHosts, result.SuggestedHost)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
}
})
Add a generic scheduler.
2014-09-24 16:32:36 +00:00
}
}
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
// makeScheduler makes a simple genericScheduler for testing.
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func makeScheduler(predicates map[string]algorithmpredicates.FitPredicate, nodes []*v1.Node) *genericScheduler {
shorten scheduler package alias for better readability - schedulerinternalcache -> internalcache
2019-03-22 01:12:33 +00:00
cache := internalcache.New(time.Duration(0), wait.NeverStop)
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
for _, n := range nodes {
cache.AddNode(n)
Don't recreate the same map 3 times
2015-12-10 19:30:30 +00:00
}
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
prioritizers := []priorities.PriorityConfig{{Map: EqualPriorityMap, Weight: 1}}
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
s := NewGenericScheduler(
cache,
feat: implement "queue-sort" extension point for scheduling framework
2019-05-07 01:03:00 +00:00
internalqueue.NewSchedulingQueue(nil, nil),
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
predicates,
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
algorithmpredicates.EmptyPredicateMetadataProducer,
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
prioritizers,
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
priorities.EmptyPriorityMetadataProducer,
add scheduling framework configuration update bazel build fix get plugin config method initialize only needed plugins fix unit test fix import duplicate package update bazel add docstrings add weight field to plugin add plugin to v1alpha1 add plugins at appropriate extension points remove todo statement fix import package file path set plugin json schema add plugin unit test to option initial plugin in test integration initialize only needed plugins update bazel rename func change plugins needed logic remove v1 alias change the comment fix alias shorter remove blank line change docstrings fix map bool to struct add some docstrings add unreserve plugin fix docstrings move variable inside the for loop make if else statement cleaner remove plugin config from reserve plugin unit test add plugin config and reduce unnecessary options for unit test update bazel fix race condition fix permit plugin integration change plugins to be pointer change weight to int32 fix package alias initial queue sort plugin rename unreserve plugin redesign plugin struct update docstrings check queue sort plugin amount fix error message fix condition change plugin struct add disabled plugin for unit test fix docstrings handle nil plugin set
2019-05-04 10:29:30 +00:00
emptyFramework,
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
nil, nil, nil, nil, false, false,
schedulerapi.DefaultPercentageOfNodesToScore, false)
Update scheduler framework plugins to align with the latest changes to the framework design
2019-03-21 00:07:25 +00:00
cache.UpdateNodeInfoSnapshot(s.(*genericScheduler).nodeInfoSnapshot)
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
return s.(*genericScheduler)
}
func TestFindFitAllError(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates := map[string]algorithmpredicates.FitPredicate{"true": truePredicate, "matches": matchesPredicate}
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
nodes := makeNodeList([]string{"3", "2", "1"})
scheduler := makeScheduler(predicates, nodes)
_, predicateMap, err := scheduler.findNodesThatFit(&v1.Pod{}, nodes)
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
if err != nil {
Fixing a lot of string formatting issues with regards to: * Improper format specifier (e.g. %s for bools or %s for ints) * More or less parameters than format specifiers * Not calling a formatting function when it should have (e.g. Error() instead of Errorf())
2015-03-31 22:32:02 +00:00
t.Errorf("unexpected error: %v", err)
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
}
if len(predicateMap) != len(nodes) {
t.Errorf("unexpected failed predicate map: %v", predicateMap)
}
for _, node := range nodes {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(node.Name, func(t *testing.T) {
failures, found := predicateMap[node.Name]
if !found {
t.Errorf("failed to find node in %v", predicateMap)
}
if len(failures) != 1 || failures[0] != algorithmpredicates.ErrFakePredicate {
t.Errorf("unexpected failures: %v", failures)
}
})
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
}
}
func TestFindFitSomeError(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates := map[string]algorithmpredicates.FitPredicate{"true": truePredicate, "matches": matchesPredicate}
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
nodes := makeNodeList([]string{"3", "2", "1"})
scheduler := makeScheduler(predicates, nodes)
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "1", UID: types.UID("1")}}
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
_, predicateMap, err := scheduler.findNodesThatFit(pod, nodes)
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
Create PredicateFailureReason, modify scheduler predicate interface.
2016-08-09 12:01:46 +00:00
if err != nil {
Fixing a lot of string formatting issues with regards to: * Improper format specifier (e.g. %s for bools or %s for ints) * More or less parameters than format specifiers * Not calling a formatting function when it should have (e.g. Error() instead of Errorf())
2015-03-31 22:32:02 +00:00
t.Errorf("unexpected error: %v", err)
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
}
if len(predicateMap) != (len(nodes) - 1) {
t.Errorf("unexpected failed predicate map: %v", predicateMap)
}
for _, node := range nodes {
Check for old NodeInfo when updating equiv. cache. Because the scheduler takes a snapshot of cache data at the start of each scheduling cycle, updates to the equivalence cache should be skipped if there was a cache update during the cycle. If the current NodeInfo becomes stale while we evaluate predicates, we will not write any results into the equivalence cache. We will still use the results for the current scheduling cycle, though.
2018-04-23 21:24:00 +00:00
if node.Name == pod.Name {
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
continue
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(node.Name, func(t *testing.T) {
failures, found := predicateMap[node.Name]
if !found {
t.Errorf("failed to find node in %v", predicateMap)
}
if len(failures) != 1 || failures[0] != algorithmpredicates.ErrFakePredicate {
t.Errorf("unexpected failures: %v", failures)
}
})
Log a better error with useful info on scheduling failures.
2015-02-24 04:36:22 +00:00
}
}
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
plugin/scheduler
2016-11-18 20:52:35 +00:00
func makeNode(node string, milliCPU, memory int64) *v1.Node {
return &v1.Node{
refactor: use metav1.ObjectMeta in other types
2017-01-17 03:38:19 +00:00
ObjectMeta: metav1.ObjectMeta{Name: node},
plugin/scheduler
2016-11-18 20:52:35 +00:00
Status: v1.NodeStatus{
Capacity: v1.ResourceList{
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceCPU: *resource.NewMilliQuantity(milliCPU, resource.DecimalSI),
v1.ResourceMemory: *resource.NewQuantity(memory, resource.BinarySI),
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
"pods": *resource.NewQuantity(100, resource.DecimalSI),
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
},
plugin/scheduler
2016-11-18 20:52:35 +00:00
Allocatable: v1.ResourceList{
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceCPU: *resource.NewMilliQuantity(milliCPU, resource.DecimalSI),
v1.ResourceMemory: *resource.NewQuantity(memory, resource.BinarySI),
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
"pods": *resource.NewQuantity(100, resource.DecimalSI),
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
},
},
}
}
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
func TestHumanReadableFitError(t *testing.T) {
follow our go code style: error->err
2017-06-13 07:32:30 +00:00
err := &FitError{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
Pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "2", UID: types.UID("2")}},
clarify pridicates message when no nodes available fix space address comment
2017-10-06 13:58:59 +00:00
NumAllNodes: 3,
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
FailedPredicates: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderMemoryPressure},
"2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderDiskPressure},
"3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderDiskPressure},
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
},
}
clarify pridicates message when no nodes available fix space address comment
2017-10-06 13:58:59 +00:00
if strings.Contains(err.Error(), "0/3 nodes are available") {
Make predicate errors more human readable
2018-01-30 01:04:58 +00:00
if strings.Contains(err.Error(), "2 node(s) had disk pressure") && strings.Contains(err.Error(), "1 node(s) had memory pressure") {
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
return
}
}
follow our go code style: error->err
2017-06-13 07:32:30 +00:00
t.Errorf("Error message doesn't have all the information content: [" + err.Error() + "]")
Update FitError as a message component into the PodConditionUpdater.
2017-01-05 21:23:23 +00:00
}
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
// The point of this test is to show that you:
// - get the same priority for a zero-request pod as for a pod with the defaults requests,
// both when the zero-request pod is already on the machine and when the zero-request pod
// is the one being scheduled.
// - don't get the same score no matter what we schedule.
func TestZeroRequest(t *testing.T) {
// A pod with no resources. We expect spreading to count it as having the default resources.
plugin/scheduler
2016-11-18 20:52:35 +00:00
noResources := v1.PodSpec{
Containers: []v1.Container{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{},
},
}
noResources1 := noResources
noResources1.NodeName = "machine1"
// A pod with the same resources as a 0-request pod gets by default as its resources (for spreading).
plugin/scheduler
2016-11-18 20:52:35 +00:00
small := v1.PodSpec{
Containers: []v1.Container{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{
plugin/scheduler
2016-11-18 20:52:35 +00:00
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceCPU: resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest, 10) + "m"),
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceMemory: resource.MustParse(
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
strconv.FormatInt(priorityutil.DefaultMemoryRequest, 10)),
},
},
},
},
}
small2 := small
small2.NodeName = "machine2"
// A larger pod.
plugin/scheduler
2016-11-18 20:52:35 +00:00
large := v1.PodSpec{
Containers: []v1.Container{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{
plugin/scheduler
2016-11-18 20:52:35 +00:00
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceCPU: resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest*3, 10) + "m"),
Replace hard-code "cpu" and "memory" to consts
2017-08-15 07:56:18 +00:00
v1.ResourceMemory: resource.MustParse(
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
strconv.FormatInt(priorityutil.DefaultMemoryRequest*3, 10)),
},
},
},
},
}
large1 := large
large1.NodeName = "machine1"
large2 := large
large2.NodeName = "machine2"
tests := []struct {
Improve unit test TestZeroRequest
2018-07-21 15:51:33 +00:00
pod *v1.Pod
pods []*v1.Pod
nodes []*v1.Node
name string
expectedScore int
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
}{
// The point of these next two tests is to show you get the same priority for a zero-request pod
// as for a pod with the defaults requests, both when the zero-request pod is already on the machine
// and when the zero-request pod is the one being scheduled.
{
plugin/scheduler
2016-11-18 20:52:35 +00:00
pod: &v1.Pod{Spec: noResources},
nodes: []*v1.Node{makeNode("machine1", 1000, priorityutil.DefaultMemoryRequest*10), makeNode("machine2", 1000, priorityutil.DefaultMemoryRequest*10)},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "test priority of zero-request pod with machine with zero-request pod",
plugin/scheduler
2016-11-18 20:52:35 +00:00
pods: []*v1.Pod{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{Spec: large1}, {Spec: noResources1},
{Spec: large2}, {Spec: small2},
},
Improve unit test TestZeroRequest
2018-07-21 15:51:33 +00:00
expectedScore: 25,
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
},
{
plugin/scheduler
2016-11-18 20:52:35 +00:00
pod: &v1.Pod{Spec: small},
nodes: []*v1.Node{makeNode("machine1", 1000, priorityutil.DefaultMemoryRequest*10), makeNode("machine2", 1000, priorityutil.DefaultMemoryRequest*10)},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "test priority of nonzero-request pod with machine with zero-request pod",
plugin/scheduler
2016-11-18 20:52:35 +00:00
pods: []*v1.Pod{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{Spec: large1}, {Spec: noResources1},
{Spec: large2}, {Spec: small2},
},
Improve unit test TestZeroRequest
2018-07-21 15:51:33 +00:00
expectedScore: 25,
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
},
// The point of this test is to verify that we're not just getting the same score no matter what we schedule.
{
plugin/scheduler
2016-11-18 20:52:35 +00:00
pod: &v1.Pod{Spec: large},
nodes: []*v1.Node{makeNode("machine1", 1000, priorityutil.DefaultMemoryRequest*10), makeNode("machine2", 1000, priorityutil.DefaultMemoryRequest*10)},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
name: "test priority of larger pod with machine with zero-request pod",
plugin/scheduler
2016-11-18 20:52:35 +00:00
pods: []*v1.Pod{
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
{Spec: large1}, {Spec: noResources1},
{Spec: large2}, {Spec: small2},
},
Improve unit test TestZeroRequest
2018-07-21 15:51:33 +00:00
expectedScore: 23,
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
},
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
// This should match the configuration in defaultPriorities() in
// pkg/scheduler/algorithmprovider/defaults/defaults.go if you want
// to test what's actually in production.
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
priorityConfigs := []priorities.PriorityConfig{
{Map: priorities.LeastRequestedPriorityMap, Weight: 1},
{Map: priorities.BalancedResourceAllocationMap, Weight: 1},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
}
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
selectorSpreadPriorityMap, selectorSpreadPriorityReduce := priorities.NewSelectorSpreadPriority(
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
schedulertesting.FakeServiceLister([]*v1.Service{}),
schedulertesting.FakeControllerLister([]*v1.ReplicationController{}),
use apps/v1 version for scheduler
2018-07-26 07:38:26 +00:00
schedulertesting.FakeReplicaSetLister([]*apps.ReplicaSet{}),
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
schedulertesting.FakeStatefulSetLister([]*apps.StatefulSet{}))
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
pc := priorities.PriorityConfig{Map: selectorSpreadPriorityMap, Reduce: selectorSpreadPriorityReduce, Weight: 1}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
priorityConfigs = append(priorityConfigs, pc)
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
nodeNameToInfo := schedulernodeinfo.CreateNodeNameToInfoMap(test.pods, test.nodes)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
metaDataProducer := priorities.NewPriorityMetadataFactory(
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
schedulertesting.FakeServiceLister([]*v1.Service{}),
schedulertesting.FakeControllerLister([]*v1.ReplicationController{}),
use apps/v1 version for scheduler
2018-07-26 07:38:26 +00:00
schedulertesting.FakeReplicaSetLister([]*apps.ReplicaSet{}),
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
schedulertesting.FakeStatefulSetLister([]*apps.StatefulSet{}))
Fix Typo: mataData -> metaData; masquared -> masquerade
2018-11-02 04:08:49 +00:00
metaData := metaDataProducer(test.pod, nodeNameToInfo)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
list, err := PrioritizeNodes(
Fix Typo: mataData -> metaData; masquared -> masquerade
2018-11-02 04:08:49 +00:00
test.pod, nodeNameToInfo, metaData, priorityConfigs,
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
schedulertesting.FakeNodeLister(test.nodes), []algorithm.SchedulerExtender{})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
for _, hp := range list {
Improve unit test TestZeroRequest
2018-07-21 15:51:33 +00:00
if hp.Score != test.expectedScore {
t.Errorf("expected %d for all priorities, got list %#v", test.expectedScore, list)
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
}
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
})
MapReduce-like scheduler priority functions
2016-08-26 14:08:40 +00:00
}
}
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
Add preemption in scheduler extender Add verb and preemption for scheduler extender Update bazel Use simple preemption in extender Use node name instead of v1.Node Fix support method Fix preemption dup Remove uneeded logics Remove nodeInfo from param to extender Update bazel for scheduler types Mock extender cache with nodeInfo Add nodeInfo as extender cache Choose node name or node based on cache flag Always return meta victims in result
2017-11-17 02:21:03 +00:00
func printNodeToVictims(nodeToVictims map[*v1.Node]*schedulerapi.Victims) string {
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
var output string
Add PDB support during pod preemption
2017-11-21 21:29:16 +00:00
for node, victims := range nodeToVictims {
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
output += node.Name + ": ["
Add preemption in scheduler extender Add verb and preemption for scheduler extender Update bazel Use simple preemption in extender Use node name instead of v1.Node Fix support method Fix preemption dup Remove uneeded logics Remove nodeInfo from param to extender Update bazel for scheduler types Mock extender cache with nodeInfo Add nodeInfo as extender cache Choose node name or node based on cache flag Always return meta victims in result
2017-11-17 02:21:03 +00:00
for _, pod := range victims.Pods {
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
output += pod.Name + ", "
}
output += "]"
}
return output
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
func checkPreemptionVictims(expected map[string]map[string]bool, nodeToPods map[*v1.Node]*schedulerapi.Victims) error {
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
if len(expected) == len(nodeToPods) {
Add PDB support during pod preemption
2017-11-21 21:29:16 +00:00
for k, victims := range nodeToPods {
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
if expPods, ok := expected[k.Name]; ok {
Add preemption in scheduler extender Add verb and preemption for scheduler extender Update bazel Use simple preemption in extender Use node name instead of v1.Node Fix support method Fix preemption dup Remove uneeded logics Remove nodeInfo from param to extender Update bazel for scheduler types Mock extender cache with nodeInfo Add nodeInfo as extender cache Choose node name or node based on cache flag Always return meta victims in result
2017-11-17 02:21:03 +00:00
if len(victims.Pods) != len(expPods) {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
return fmt.Errorf("unexpected number of pods. expected: %v, got: %v", expected, printNodeToVictims(nodeToPods))
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
prevPriority := int32(math.MaxInt32)
Add preemption in scheduler extender Add verb and preemption for scheduler extender Update bazel Use simple preemption in extender Use node name instead of v1.Node Fix support method Fix preemption dup Remove uneeded logics Remove nodeInfo from param to extender Update bazel for scheduler types Mock extender cache with nodeInfo Add nodeInfo as extender cache Choose node name or node based on cache flag Always return meta victims in result
2017-11-17 02:21:03 +00:00
for _, p := range victims.Pods {
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
// Check that pods are sorted by their priority.
if *p.Spec.Priority > prevPriority {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
return fmt.Errorf("pod %v of node %v was not sorted by priority", p.Name, k)
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
prevPriority = *p.Spec.Priority
if _, ok := expPods[p.Name]; !ok {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
return fmt.Errorf("pod %v was not expected. Expected: %v", p.Name, expPods)
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
}
} else {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
return fmt.Errorf("unexpected machines. expected: %v, got: %v", expected, printNodeToVictims(nodeToPods))
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
}
} else {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
return fmt.Errorf("unexpected number of machines. expected: %v, got: %v", expected, printNodeToVictims(nodeToPods))
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
return nil
}
type FakeNodeInfo v1.Node
func (n FakeNodeInfo) GetNodeInfo(nodeName string) (*v1.Node, error) {
node := v1.Node(n)
return &node, nil
}
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
func PredicateMetadata(p *v1.Pod, nodeInfo map[string]*schedulernodeinfo.NodeInfo) algorithmpredicates.PredicateMetadata {
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
return algorithmpredicates.NewPredicateMetadataFactory(schedulertesting.FakePodLister{p})(p, nodeInfo)
}
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
var smallContainers = []v1.Container{
{
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
"cpu": resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest, 10) + "m"),
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
"memory": resource.MustParse(
strconv.FormatInt(priorityutil.DefaultMemoryRequest, 10)),
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
}
var mediumContainers = []v1.Container{
{
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
"cpu": resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest*2, 10) + "m"),
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
"memory": resource.MustParse(
strconv.FormatInt(priorityutil.DefaultMemoryRequest*2, 10)),
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
}
var largeContainers = []v1.Container{
{
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
"cpu": resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest*3, 10) + "m"),
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
"memory": resource.MustParse(
strconv.FormatInt(priorityutil.DefaultMemoryRequest*3, 10)),
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
}
var veryLargeContainers = []v1.Container{
{
Resources: v1.ResourceRequirements{
Requests: v1.ResourceList{
"cpu": resource.MustParse(
Fix golint errors in `pkg/scheduler` based on golint check
2018-02-08 06:42:19 +00:00
strconv.FormatInt(priorityutil.DefaultMilliCPURequest*5, 10) + "m"),
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
"memory": resource.MustParse(
strconv.FormatInt(priorityutil.DefaultMemoryRequest*5, 10)),
},
},
},
}
var negPriority, lowPriority, midPriority, highPriority, veryHighPriority = int32(-100), int32(0), int32(100), int32(1000), int32(10000)
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
var startTime = metav1.Date(2019, 1, 1, 1, 1, 1, 0, time.UTC)
var startTime20190102 = metav1.Date(2019, 1, 2, 1, 1, 1, 0, time.UTC)
var startTime20190103 = metav1.Date(2019, 1, 3, 1, 1, 1, 0, time.UTC)
var startTime20190104 = metav1.Date(2019, 1, 4, 1, 1, 1, 0, time.UTC)
var startTime20190105 = metav1.Date(2019, 1, 5, 1, 1, 1, 0, time.UTC)
var startTime20190106 = metav1.Date(2019, 1, 6, 1, 1, 1, 0, time.UTC)
var startTime20190107 = metav1.Date(2019, 1, 7, 1, 1, 1, 0, time.UTC)
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
// TestSelectNodesForPreemption tests selectNodesForPreemption. This test assumes
// that podsFitsOnNode works correctly and is tested separately.
func TestSelectNodesForPreemption(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
tests := []struct {
name string
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates map[string]algorithmpredicates.FitPredicate
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes []string
pod *v1.Pod
pods []*v1.Pod
expected map[string]map[string]bool // Map from node name to a list of pods names which should be preempted.
addAffinityPredicate bool
}{
{
name: "a pod that does not fit on any machine",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": falsePredicate},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "new", UID: types.UID("new")}, Spec: v1.PodSpec{Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine2"}}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
expected: map[string]map[string]bool{},
},
{
name: "a pod that fits with no preemption",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": truePredicate},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "new", UID: types.UID("new")}, Spec: v1.PodSpec{Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine2"}}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
expected: map[string]map[string]bool{"machine1": {}, "machine2": {}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
{
name: "a pod that fits on one machine with no preemption",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": matchesPredicate},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Priority: &midPriority, NodeName: "machine2"}}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
expected: map[string]map[string]bool{"machine1": {}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
{
name: "a pod that fits on both machines when lower priority pods are preempted",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
expected: map[string]map[string]bool{"machine1": {"a": true}, "machine2": {"b": true}},
},
{
name: "a pod that would fit on the machines, but other pods running are higher priority",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &lowPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
expected: map[string]map[string]bool{},
},
{
name: "medium priority pod is preempted, but lower priority one stays as it is small",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "c", UID: types.UID("c")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
expected: map[string]map[string]bool{"machine1": {"b": true}, "machine2": {"c": true}},
},
{
name: "mixed priority pods are preempted",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "c", UID: types.UID("c")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "d", UID: types.UID("d")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &highPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "e", UID: types.UID("e")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
expected: map[string]map[string]bool{"machine1": {"b": true, "c": true}},
},
Pick pods for preemption based on StartTime of pods when priorities are equal
2019-03-20 13:11:26 +00:00
{
name: "mixed priority pods are preempted, pick later StartTime one when priorities are equal",
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
nodes: []string{"machine1", "machine2"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190107}},
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190106}},
{ObjectMeta: metav1.ObjectMeta{Name: "c", UID: types.UID("c")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190105}},
{ObjectMeta: metav1.ObjectMeta{Name: "d", UID: types.UID("d")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &highPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190104}},
{ObjectMeta: metav1.ObjectMeta{Name: "e", UID: types.UID("e")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190103}}},
expected: map[string]map[string]bool{"machine1": {"a": true, "c": true}},
},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
{
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
name: "pod with anti-affinity is preempted",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
nodes: []string{"machine1", "machine2"},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{
Name: "machine1",
Labels: map[string]string{"pod": "preemptor"}}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &highPriority}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
pods: []*v1.Pod{
add pod UID
2018-07-23 01:28:03 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "a", UID: types.UID("a"), Labels: map[string]string{"service": "securityscan"}}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1", Affinity: &v1.Affinity{
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
PodAntiAffinity: &v1.PodAntiAffinity{
RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
{
LabelSelector: &metav1.LabelSelector{
MatchExpressions: []metav1.LabelSelectorRequirement{
{
Key: "pod",
Operator: metav1.LabelSelectorOpIn,
Values: []string{"preemptor", "value2"},
},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
TopologyKey: "hostname",
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
},
},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}}}},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "b", UID: types.UID("b")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "d", UID: types.UID("d")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &highPriority, NodeName: "machine1"}},
{ObjectMeta: metav1.ObjectMeta{Name: "e", UID: types.UID("e")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
expected: map[string]map[string]bool{"machine1": {"a": true}, "machine2": {}},
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
addAffinityPredicate: true,
},
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
nodes := []*v1.Node{}
for _, n := range test.nodes {
node := makeNode(n, 1000*5, priorityutil.DefaultMemoryRequest*5)
node.ObjectMeta.Labels = map[string]string{"hostname": node.Name}
nodes = append(nodes, node)
}
if test.addAffinityPredicate {
test.predicates[algorithmpredicates.MatchInterPodAffinityPred] = algorithmpredicates.NewPodAffinityPredicate(FakeNodeInfo(*nodes[0]), schedulertesting.FakePodLister(test.pods))
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
nodeNameToInfo := schedulernodeinfo.CreateNodeNameToInfoMap(test.pods, nodes)
fix a scheduler panic due to internal cache inconsistency
2018-11-16 20:07:28 +00:00
// newnode simulate a case that a new node is added to the cluster, but nodeNameToInfo
// doesn't have it yet.
newnode := makeNode("newnode", 1000*5, priorityutil.DefaultMemoryRequest*5)
newnode.ObjectMeta.Labels = map[string]string{"hostname": "newnode"}
nodes = append(nodes, newnode)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
nodeToPods, err := selectNodesForPreemption(test.pod, nodeNameToInfo, nodes, test.predicates, PredicateMetadata, nil, nil)
if err != nil {
t.Error(err)
}
if err := checkPreemptionVictims(test.expected, nodeToPods); err != nil {
t.Error(err)
}
})
Add preemption victim selector logic to scheduler
2017-08-03 01:20:45 +00:00
}
}
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
// TestPickOneNodeForPreemption tests pickOneNodeForPreemption.
func TestPickOneNodeForPreemption(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
tests := []struct {
name string
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates map[string]algorithmpredicates.FitPredicate
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes []string
pod *v1.Pod
pods []*v1.Pod
expected []string // any of the items is valid
}{
{
name: "No node needs preemption",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
expected: []string{"machine1"},
},
{
name: "a pod that fits on both machines when lower priority pods are preempted",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
expected: []string{"machine1", "machine2"},
},
{
name: "a pod that fits on a machine with no preemption",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
expected: []string{"machine3"},
},
{
name: "machine with min highest priority pod is picked",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
expected: []string{"machine3"},
},
{
name: "when highest priorities are the same, minimum sum of priorities is picked",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
expected: []string{"machine2"},
},
{
name: "when highest priority and sum are the same, minimum number of pods is picked",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.3", UID: types.UID("m1.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.4", UID: types.UID("m1.4")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &negPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.3", UID: types.UID("m3.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
expected: []string{"machine2"},
},
{
// pickOneNodeForPreemption adjusts pod priorities when finding the sum of the victims. This
// test ensures that the logic works correctly.
name: "sum of adjusted priorities is considered",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.3", UID: types.UID("m1.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &negPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.3", UID: types.UID("m3.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
expected: []string{"machine2"},
},
{
name: "non-overlapping lowest high priority, sum priorities, and number of pods",
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
nodes: []string{"machine1", "machine2", "machine3", "machine4"},
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &veryHighPriority}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
pods: []*v1.Pod{
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.3", UID: types.UID("m1.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.3", UID: types.UID("m3.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.4", UID: types.UID("m3.4")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m4.1", UID: types.UID("m4.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine4"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m4.2", UID: types.UID("m4.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine4"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m4.3", UID: types.UID("m4.3")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine4"}, Status: v1.PodStatus{StartTime: &startTime}},
{ObjectMeta: metav1.ObjectMeta{Name: "m4.4", UID: types.UID("m4.4")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &negPriority, NodeName: "machine4"}, Status: v1.PodStatus{StartTime: &startTime}},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
},
expected: []string{"machine1"},
},
Pick node for preemption based on start time of pods
2019-03-12 04:30:15 +00:00
{
name: "same priority, same number of victims, different start time for each machine's pod",
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
nodes: []string{"machine1", "machine2", "machine3"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190103}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190103}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190104}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190104}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190102}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190102}},
},
expected: []string{"machine2"},
},
{
name: "same priority, same number of victims, different start time for all pods",
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
nodes: []string{"machine1", "machine2", "machine3"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190105}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190103}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190106}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190102}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190104}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190107}},
},
expected: []string{"machine3"},
},
{
name: "different priority, same number of victims, different start time for all pods",
predicates: map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
nodes: []string{"machine1", "machine2", "machine3"},
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "machine1", UID: types.UID("machine1")}, Spec: v1.PodSpec{Containers: veryLargeContainers, Priority: &highPriority}},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190105}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{StartTime: &startTime20190103}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190107}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.2", UID: types.UID("m2.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine2"}, Status: v1.PodStatus{StartTime: &startTime20190102}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &lowPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190104}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.2", UID: types.UID("m3.2")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{StartTime: &startTime20190106}},
},
expected: []string{"machine2"},
},
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
nodes := []*v1.Node{}
for _, n := range test.nodes {
nodes = append(nodes, makeNode(n, priorityutil.DefaultMilliCPURequest*5, priorityutil.DefaultMemoryRequest*5))
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
nodeNameToInfo := schedulernodeinfo.CreateNodeNameToInfoMap(test.pods, nodes)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
candidateNodes, _ := selectNodesForPreemption(test.pod, nodeNameToInfo, nodes, test.predicates, PredicateMetadata, nil, nil)
node := pickOneNodeForPreemption(candidateNodes)
found := false
for _, nodeName := range test.expected {
if node.Name == nodeName {
found = true
break
}
}
if !found {
t.Errorf("unexpected node: %v", node)
}
})
Add the logic to pick one node for preemption
2017-08-09 18:36:35 +00:00
}
}
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
func TestNodesWherePreemptionMightHelp(t *testing.T) {
// Prepare 4 node names.
nodeNames := []string{}
for i := 1; i < 5; i++ {
nodeNames = append(nodeNames, fmt.Sprintf("machine%d", i))
}
tests := []struct {
name string
failedPredMap FailedPredicateMap
expected map[string]bool // set of expected node names. Value is ignored.
}{
{
name: "No node should be attempted",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeSelectorNotMatch},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodNotMatchHostName},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrTaintsTolerationsNotMatch},
"machine4": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeLabelPresenceViolated},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expected: map[string]bool{},
},
{
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
name: "ErrPodAffinityNotMatch should be tried as it indicates that the pod is unschedulable due to inter-pod affinity or anti-affinity",
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodAffinityNotMatch},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodNotMatchHostName},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnschedulable},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expected: map[string]bool{"machine1": true, "machine4": true},
},
{
name: "pod with both pod affinity and anti-affinity should be tried",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodAffinityNotMatch},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodNotMatchHostName},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expected: map[string]bool{"machine1": true, "machine3": true, "machine4": true},
},
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
{
name: "ErrPodAffinityRulesNotMatch should not be tried as it indicates that the pod is unschedulable due to inter-pod affinity, but ErrPodAffinityNotMatch should be tried as it indicates that the pod is unschedulable due to inter-pod affinity or anti-affinity",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodAffinityRulesNotMatch},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodAffinityNotMatch},
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
},
expected: map[string]bool{"machine2": true, "machine3": true, "machine4": true},
},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
{
name: "Mix of failed predicates works fine",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeSelectorNotMatch, algorithmpredicates.ErrNodeUnderDiskPressure, algorithmpredicates.NewInsufficientResourceError(v1.ResourceMemory, 1000, 500, 300)},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrPodNotMatchHostName, algorithmpredicates.ErrDiskConflict},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.NewInsufficientResourceError(v1.ResourceMemory, 1000, 600, 400)},
"machine4": []algorithmpredicates.PredicateFailureReason{},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expected: map[string]bool{"machine3": true, "machine4": true},
},
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
{
name: "Node condition errors should be considered unresolvable",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderDiskPressure},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderPIDPressure},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnderMemoryPressure},
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
},
cleanup logic related with OutOfDisk - cleanup OOD logic in scheduling and node controller - update comments and testcases
2018-12-13 08:31:46 +00:00
expected: map[string]bool{"machine4": true},
Add tests to cover newly added unresolvable failures
2018-06-11 23:39:39 +00:00
},
Complement unit test case TestNodesWherePreemptionMightHelp for scheduler/core
2018-08-23 10:54:23 +00:00
{
name: "Node condition errors and ErrNodeUnknownCondition should be considered unresolvable",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeNotReady},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeNetworkUnavailable},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrNodeUnknownCondition},
Complement unit test case TestNodesWherePreemptionMightHelp for scheduler/core
2018-08-23 10:54:23 +00:00
},
expected: map[string]bool{"machine4": true},
},
{
name: "ErrVolume... errors should not be tried as it indicates that the pod is unschedulable due to no matching volumes for pod on node",
failedPredMap: FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrVolumeZoneConflict},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrVolumeNodeConflict},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrVolumeBindConflict},
Complement unit test case TestNodesWherePreemptionMightHelp for scheduler/core
2018-08-23 10:54:23 +00:00
},
expected: map[string]bool{"machine4": true},
},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
nodes := nodesWherePreemptionMightHelp(makeNodeList(nodeNames), test.failedPredMap)
if len(test.expected) != len(nodes) {
t.Errorf("number of nodes is not the same as expected. exptectd: %d, got: %d. Nodes: %v", len(test.expected), len(nodes), nodes)
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
for _, node := range nodes {
if _, found := test.expected[node.Name]; !found {
t.Errorf("node %v is not expected.", node.Name)
}
}
})
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
}
func TestPreempt(t *testing.T) {
prevent `predicatesOrdering` from escaping from UT - sets `predicatesOrdering` back to original value in UT
2019-05-09 01:03:58 +00:00
defer algorithmpredicates.SetPredicatesOrderingDuringTest(order)()
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
failedPredMap := FailedPredicateMap{
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
"machine1": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.NewInsufficientResourceError(v1.ResourceMemory, 1000, 500, 300)},
"machine2": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.ErrDiskConflict},
"machine3": []algorithmpredicates.PredicateFailureReason{algorithmpredicates.NewInsufficientResourceError(v1.ResourceMemory, 1000, 600, 400)},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
// Prepare 3 node names.
nodeNames := []string{}
for i := 1; i < 4; i++ {
nodeNames = append(nodeNames, fmt.Sprintf("machine%d", i))
}
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
var (
preemptLowerPriority = v1.PreemptLowerPriority
preemptNever = v1.PreemptNever
)
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
tests := []struct {
name string
pod *v1.Pod
pods []*v1.Pod
extenders []*FakeExtender
expectedNode string
expectedPods []string // list of preempted pods
}{
{
name: "basic preemption logic",
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expectedNode: "machine1",
expectedPods: []string{"m1.1", "m1.2"},
},
{
name: "One node doesn't need any preemption",
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
expectedNode: "machine3",
expectedPods: []string{},
},
{
name: "Scheduler extenders allow only machine1, otherwise machine3 would have been chosen",
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
extenders: []*FakeExtender{
{
predicates: []fitPredicate{truePredicateExtender},
},
{
predicates: []fitPredicate{machine1PredicateExtender},
},
},
expectedNode: "machine1",
expectedPods: []string{"m1.1", "m1.2"},
},
{
name: "Scheduler extenders do not allow any preemption",
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
pods: []*v1.Pod{
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
Use pod UID as cache key instead of namespace/name UID uniquely identifies pods across lifecycles, while namespace/name could be 2 different pods across lifecycles. This could result in tricky scheduler bugs. Fixes #60966
2018-03-12 22:41:25 +00:00
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
},
extenders: []*FakeExtender{
{
predicates: []fitPredicate{falsePredicateExtender},
},
},
expectedNode: "",
expectedPods: []string{},
},
Add test to verify preempt ignore
2018-03-30 21:01:09 +00:00
{
name: "One scheduler extender allows only machine1, the other returns error but ignorable. Only machine1 would be chosen",
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Add test to verify preempt ignore
2018-03-30 21:01:09 +00:00
},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
},
extenders: []*FakeExtender{
{
predicates: []fitPredicate{errorPredicateExtender},
ignorable: true,
},
{
predicates: []fitPredicate{machine1PredicateExtender},
},
},
expectedNode: "machine1",
expectedPods: []string{"m1.1", "m1.2"},
},
Extender preemption should respect IsInterested() Co-authored-by: Harry Zhang <resouer@gmail.com> Co-authored-by: Chun Chen <ramichen@tencent.com>
2018-07-17 12:09:45 +00:00
{
name: "One scheduler extender allows only machine1, but it is not interested in given pod, otherwise machine1 would have been chosen",
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptLowerPriority},
Extender preemption should respect IsInterested() Co-authored-by: Harry Zhang <resouer@gmail.com> Co-authored-by: Chun Chen <ramichen@tencent.com>
2018-07-17 12:09:45 +00:00
},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &midPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &midPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
},
extenders: []*FakeExtender{
{
predicates: []fitPredicate{machine1PredicateExtender},
unInterested: true,
},
{
predicates: []fitPredicate{truePredicateExtender},
},
},
expectedNode: "machine3",
expectedPods: []string{},
},
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
{
name: "no preempting in pod",
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: &preemptNever},
},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
},
expectedNode: "",
expectedPods: nil,
},
{
name: "PreemptionPolicy is nil",
pod: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod1", UID: types.UID("pod1")}, Spec: v1.PodSpec{
Containers: veryLargeContainers,
Priority: &highPriority,
PreemptionPolicy: nil},
},
pods: []*v1.Pod{
{ObjectMeta: metav1.ObjectMeta{Name: "m1.1", UID: types.UID("m1.1")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m1.2", UID: types.UID("m1.2")}, Spec: v1.PodSpec{Containers: smallContainers, Priority: &lowPriority, NodeName: "machine1"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m2.1", UID: types.UID("m2.1")}, Spec: v1.PodSpec{Containers: largeContainers, Priority: &highPriority, NodeName: "machine2"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
{ObjectMeta: metav1.ObjectMeta{Name: "m3.1", UID: types.UID("m3.1")}, Spec: v1.PodSpec{Containers: mediumContainers, Priority: &midPriority, NodeName: "machine3"}, Status: v1.PodStatus{Phase: v1.PodRunning}},
},
expectedNode: "machine1",
expectedPods: []string{"m1.1", "m1.2"},
},
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
for _, test := range tests {
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
t.Run(test.name, func(t *testing.T) {
Fix and improve preemption test to work with the new logic
2019-01-14 22:27:16 +00:00
t.Logf("===== Running test %v", t.Name())
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
stop := make(chan struct{})
shorten scheduler package alias for better readability - schedulerinternalcache -> internalcache
2019-03-22 01:12:33 +00:00
cache := internalcache.New(time.Duration(0), stop)
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
for _, pod := range test.pods {
cache.AddPod(pod)
}
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
cachedNodeInfoMap := map[string]*schedulernodeinfo.NodeInfo{}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
for _, name := range nodeNames {
node := makeNode(name, 1000*5, priorityutil.DefaultMemoryRequest*5)
cache.AddNode(node)
// Set nodeInfo to extenders to mock extenders' cache for preemption.
[scheduler cleanup phase 2]: Rename to Signed-off-by: yuexiao-wang <wang.yuexiao@zte.com.cn>
2018-12-08 02:36:11 +00:00
cachedNodeInfo := schedulernodeinfo.NewNodeInfo()
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
cachedNodeInfo.SetNode(node)
cachedNodeInfoMap[name] = cachedNodeInfo
}
extenders := []algorithm.SchedulerExtender{}
for _, extender := range test.extenders {
// Set nodeInfoMap as extenders cached node information.
extender.cachedNodeNameToInfo = cachedNodeInfoMap
extenders = append(extenders, extender)
}
scheduler := NewGenericScheduler(
cache,
feat: implement "queue-sort" extension point for scheduling framework
2019-05-07 01:03:00 +00:00
internalqueue.NewSchedulingQueue(nil, nil),
Move predicate types from algorithm to predicates
2018-12-19 12:30:54 +00:00
map[string]algorithmpredicates.FitPredicate{"matches": algorithmpredicates.PodFitsResources},
algorithmpredicates.EmptyPredicateMetadataProducer,
refactor(scheduler): Move priority types to priorities package This moves the priority types from the algorithm package to priorities package. Idea is to move the type to the packages where it is implemented. This will ease the future refactor process.
2019-01-08 21:09:11 +00:00
[]priorities.PriorityConfig{{Function: numericPriority, Weight: 1}},
priorities.EmptyPriorityMetadataProducer,
add scheduling framework configuration update bazel build fix get plugin config method initialize only needed plugins fix unit test fix import duplicate package update bazel add docstrings add weight field to plugin add plugin to v1alpha1 add plugins at appropriate extension points remove todo statement fix import package file path set plugin json schema add plugin unit test to option initial plugin in test integration initialize only needed plugins update bazel rename func change plugins needed logic remove v1 alias change the comment fix alias shorter remove blank line change docstrings fix map bool to struct add some docstrings add unreserve plugin fix docstrings move variable inside the for loop make if else statement cleaner remove plugin config from reserve plugin unit test add plugin config and reduce unnecessary options for unit test update bazel fix race condition fix permit plugin integration change plugins to be pointer change weight to int32 fix package alias initial queue sort plugin rename unreserve plugin redesign plugin struct update docstrings check queue sort plugin amount fix error message fix condition change plugin struct add disabled plugin for unit test fix docstrings handle nil plugin set
2019-05-04 10:29:30 +00:00
emptyFramework,
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
extenders,
nil,
schedulertesting.FakePersistentVolumeClaimLister{},
Remove PDB and its event handlers from the scheduler cache
2018-09-19 00:05:48 +00:00
schedulertesting.FakePDBLister{},
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
false,
Add a scheduler config argument to set the percentage of nodes to score
2018-07-28 00:17:09 +00:00
false,
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
schedulerapi.DefaultPercentageOfNodesToScore,
true)
Fix and improve preemption test to work with the new logic
2019-01-14 22:27:16 +00:00
scheduler.(*genericScheduler).snapshot()
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
// Call Preempt and check the expected results.
node, victims, _, err := scheduler.Preempt(test.pod, schedulertesting.FakeNodeLister(makeNodeList(nodeNames)), error(&FitError{Pod: test.pod, FailedPredicates: failedPredMap}))
if err != nil {
t.Errorf("unexpected error in preemption: %v", err)
}
Fix and improve preemption test to work with the new logic
2019-01-14 22:27:16 +00:00
if node != nil && node.Name != test.expectedNode {
Extender preemption should respect IsInterested() Co-authored-by: Harry Zhang <resouer@gmail.com> Co-authored-by: Chun Chen <ramichen@tencent.com>
2018-07-17 12:09:45 +00:00
t.Errorf("expected node: %v, got: %v", test.expectedNode, node.GetName())
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
}
Fix and improve preemption test to work with the new logic
2019-01-14 22:27:16 +00:00
if node == nil && len(test.expectedNode) != 0 {
t.Errorf("expected node: %v, got: nothing", test.expectedNode)
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
if len(victims) != len(test.expectedPods) {
t.Errorf("expected %v pods, got %v.", len(test.expectedPods), len(victims))
}
for _, victim := range victims {
found := false
for _, expPod := range test.expectedPods {
if expPod == victim.Name {
found = true
break
}
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
if !found {
t.Errorf("pod %v is not expected to be a victim.", victim.Name)
}
// Mark the victims for deletion and record the preemptor's nominated node name.
now := metav1.Now()
victim.DeletionTimestamp = &now
test.pod.Status.NominatedNodeName = node.Name
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
// Call preempt again and make sure it doesn't preempt any more pods.
node, victims, _, err = scheduler.Preempt(test.pod, schedulertesting.FakeNodeLister(makeNodeList(nodeNames)), error(&FitError{Pod: test.pod, FailedPredicates: failedPredMap}))
if err != nil {
t.Errorf("unexpected error in preemption: %v", err)
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
use subtest for table units remove duplicate testname from error msg remove subtest for test setup loop do not break on test failure https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203571355 remove duplicate test.name in output https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574001 https://github.com/kubernetes/kubernetes/pull/63665#discussion_r203574012
2018-06-01 14:16:50 +00:00
if node != nil && len(victims) > 0 {
t.Errorf("didn't expect any more preemption. Node %v is selected for preemption.", node)
}
close(stop)
})
Add pod eviction logic for scheduler preemption Add Preempt to scheduler interface Add preemption to the scheduling workflow Minor changes to the scheduler integration test library
2017-08-10 01:15:40 +00:00
}
}
Set percentage of nodes scored in each cycle dynamically based on the cluster size
2018-12-18 03:17:40 +00:00
func TestNumFeasibleNodesToFind(t *testing.T) {
tests := []struct {
name string
percentageOfNodesToScore int32
numAllNodes int32
wantNumNodes int32
}{
{
name: "not set percentageOfNodesToScore and nodes number not more than 50",
numAllNodes: 10,
wantNumNodes: 10,
},
{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
name: "set percentageOfNodesToScore and nodes number not more than 50",
Set percentage of nodes scored in each cycle dynamically based on the cluster size
2018-12-18 03:17:40 +00:00
percentageOfNodesToScore: 40,
numAllNodes: 10,
wantNumNodes: 10,
},
{
name: "not set percentageOfNodesToScore and nodes number more than 50",
numAllNodes: 1000,
wantNumNodes: 420,
},
{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
name: "set percentageOfNodesToScore and nodes number more than 50",
Set percentage of nodes scored in each cycle dynamically based on the cluster size
2018-12-18 03:17:40 +00:00
percentageOfNodesToScore: 40,
numAllNodes: 1000,
wantNumNodes: 400,
},
{
name: "not set percentageOfNodesToScore and nodes number more than 50*125",
numAllNodes: 6000,
wantNumNodes: 300,
},
{
change preempting to PreemptionPolicy
2019-05-30 22:28:21 +00:00
name: "set percentageOfNodesToScore and nodes number more than 50*125",
Set percentage of nodes scored in each cycle dynamically based on the cluster size
2018-12-18 03:17:40 +00:00
percentageOfNodesToScore: 40,
numAllNodes: 6000,
wantNumNodes: 2400,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
g := &genericScheduler{
percentageOfNodesToScore: tt.percentageOfNodesToScore,
}
if gotNumNodes := g.numFeasibleNodesToFind(tt.numAllNodes); gotNumNodes != tt.wantNumNodes {
t.Errorf("genericScheduler.numFeasibleNodesToFind() = %v, want %v", gotNumNodes, tt.wantNumNodes)
}
})
}
}