github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-24 12:15:52 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #83568 from bertinatto/volume_limits_ga

Browse Source 
Promote volume limits to GA
This commit is contained in:
Kubernetes Prow Robot 2019-11-12 11:50:22 -08:00 committed by GitHub
commit c580a12c8e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 99 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/features/kube_features.go
View File

@ -282,6 +282,8 @@ const (
// owner: @gnufied
// beta : v1.12
// GA : v1.17
//
// Add support for volume plugins to report node specific
// volume limits
@ -523,7 +525,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS
ExpandPersistentVolumes: {Default: true, PreRelease: featuregate.Beta},
ExpandInUsePersistentVolumes: {Default: true, PreRelease: featuregate.Beta},
ExpandCSIVolumes: {Default: true, PreRelease: featuregate.Beta},
AttachVolumeLimit: {Default: true, PreRelease: featuregate.Beta},
AttachVolumeLimit: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, // remove in 1.19
CPUManager: {Default: true, PreRelease: featuregate.Beta},
CPUCFSQuotaPeriod: {Default: false, PreRelease: featuregate.Alpha},
TopologyManager: {Default: false, PreRelease: featuregate.Alpha},

8
pkg/kubelet/kubelet_node_status.go
View File

@ -31,12 +31,10 @@ import (
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
utilfeature "k8s.io/apiserver/pkg/util/feature"
cloudprovider "k8s.io/cloud-provider"
"k8s.io/klog"
k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
"k8s.io/kubernetes/pkg/features"
kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
"k8s.io/kubernetes/pkg/kubelet/events"
"k8s.io/kubernetes/pkg/kubelet/nodestatus"
@ -548,9 +546,9 @@ func (kl *Kubelet) defaultNodeStatusFuncs() []func(*v1.Node) error {
nodestatus.Images(kl.nodeStatusMaxImages, kl.imageManager.GetImageList),
nodestatus.GoRuntime(),
)
if utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
setters = append(setters, nodestatus.VolumeLimits(kl.volumePluginMgr.ListVolumePluginWithLimits))
}
// Volume limits
setters = append(setters, nodestatus.VolumeLimits(kl.volumePluginMgr.ListVolumePluginWithLimits))
setters = append(setters,
nodestatus.MemoryPressureCondition(kl.clock.Now, kl.evictionManager.IsUnderMemoryPressure, kl.recordNodeStatusEvent),
nodestatus.DiskPressureCondition(kl.clock.Now, kl.evictionManager.IsUnderDiskPressure, kl.recordNodeStatusEvent),

5
pkg/registry/storage/csinode/BUILD
View File

@ -12,11 +12,9 @@ go_library(
"//pkg/api/legacyscheme:go_default_library",
"//pkg/apis/storage:go_default_library",
"//pkg/apis/storage/validation:go_default_library",
"//pkg/features:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
"//staging/src/k8s.io/apiserver/pkg/storage/names:go_default_library",
"//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
],
)
@ -43,12 +41,9 @@ go_test(
embed = [":go_default_library"],
deps = [
"//pkg/apis/storage:go_default_library",
"//pkg/features:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
"//staging/src/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
"//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
"//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
"//vendor/k8s.io/utils/pointer:go_default_library",
],
)

33
pkg/registry/storage/csinode/strategy.go
View File

@ -22,11 +22,9 @@ import (
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/validation/field"
"k8s.io/apiserver/pkg/storage/names"
utilfeature "k8s.io/apiserver/pkg/util/feature"
"k8s.io/kubernetes/pkg/api/legacyscheme"
"k8s.io/kubernetes/pkg/apis/storage"
"k8s.io/kubernetes/pkg/apis/storage/validation"
"k8s.io/kubernetes/pkg/features"
)
// csiNodeStrategy implements behavior for CSINode objects
@ -45,12 +43,6 @@ func (csiNodeStrategy) NamespaceScoped() bool {
// PrepareForCreate clears fields that are not allowed to be set on creation.
func (csiNodeStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) {
csiNode := obj.(*storage.CSINode)
if !utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
for i := range csiNode.Spec.Drivers {
csiNode.Spec.Drivers[i].Allocatable = nil
}
}
}
func (csiNodeStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
@ -72,31 +64,6 @@ func (csiNodeStrategy) AllowCreateOnUpdate() bool {
// PrepareForUpdate sets the driver's Allocatable fields that are not allowed to be set by an end user updating a CSINode.
func (csiNodeStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) {
newCSINode := obj.(*storage.CSINode)
oldCSINode := old.(*storage.CSINode)
inUse := getAllocatablesInUse(oldCSINode)
if !utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
for i := range newCSINode.Spec.Drivers {
if !inUse[newCSINode.Spec.Drivers[i].Name] {
newCSINode.Spec.Drivers[i].Allocatable = nil
}
}
}
}
func getAllocatablesInUse(obj *storage.CSINode) map[string]bool {
inUse := make(map[string]bool)
if obj == nil {
return inUse
}
for i := range obj.Spec.Drivers {
if obj.Spec.Drivers[i].Allocatable != nil {
inUse[obj.Spec.Drivers[i].Name] = true
}
}
return inUse
}
func (csiNodeStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {

64
pkg/registry/storage/csinode/strategy_test.go
View File

@ -23,10 +23,7 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/validation/field"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/apis/storage"
"k8s.io/kubernetes/pkg/features"
utilpointer "k8s.io/utils/pointer"
)
@ -47,7 +44,7 @@ func TestPrepareForCreate(t *testing.T) {
},
}
volumeLimitsEnabledCases := []struct {
volumeLimitsCases := []struct {
name string
obj *storage.CSINode
expected *storage.CSINode
@ -64,32 +61,7 @@ func TestPrepareForCreate(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range volumeLimitsEnabledCases {
t.Run(test.name, func(t *testing.T) {
testPrepareForCreate(t, test.obj, test.expected)
})
}
volumeLimitsDisabledCases := []struct {
name string
obj *storage.CSINode
expected *storage.CSINode
}{
{
"empty allocatable",
emptyAllocatable,
emptyAllocatable,
},
{
"drop allocatable",
valid,
emptyAllocatable,
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, false)()
for _, test := range volumeLimitsDisabledCases {
for _, test := range volumeLimitsCases {
t.Run(test.name, func(t *testing.T) {
testPrepareForCreate(t, test.obj, test.expected)
})
@ -140,7 +112,7 @@ func TestPrepareForUpdate(t *testing.T) {
},
}
volumeLimitsEnabledCases := []struct {
volumeLimitsCases := []struct {
name string
old *storage.CSINode
new *storage.CSINode
@ -166,35 +138,7 @@ func TestPrepareForUpdate(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range volumeLimitsEnabledCases {
t.Run(test.name, func(t *testing.T) {
testPrepareForUpdate(t, test.new, test.old, test.expected)
})
}
volumeLimitsDisabledCases := []struct {
name string
old *storage.CSINode
new *storage.CSINode
expected *storage.CSINode
}{
{
"allow empty allocatable when it's not set",
emptyAllocatable,
emptyAllocatable,
emptyAllocatable,
},
{
"drop allocatable when it's not set",
emptyAllocatable,
valid,
emptyAllocatable,
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, false)()
for _, test := range volumeLimitsDisabledCases {
for _, test := range volumeLimitsCases {
t.Run(test.name, func(t *testing.T) {
testPrepareForUpdate(t, test.new, test.old, test.expected)
})

2
pkg/scheduler/BUILD
View File

@ -48,13 +48,11 @@ go_library(
"//staging/src/k8s.io/client-go/informers/core/v1:go_default_library",
"//staging/src/k8s.io/client-go/informers/policy/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/informers/storage/v1:go_default_library",
"//staging/src/k8s.io/client-go/informers/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/kubernetes:go_default_library",
"//staging/src/k8s.io/client-go/listers/apps/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/policy/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/tools/cache:go_default_library",
"//staging/src/k8s.io/client-go/tools/events:go_default_library",
"//vendor/k8s.io/klog:go_default_library",

3
pkg/scheduler/algorithm/predicates/BUILD
View File

@ -28,7 +28,6 @@ go_library(
"//pkg/volume/util:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/fields:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
@ -37,7 +36,6 @@ go_library(
"//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
"//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/util/workqueue:go_default_library",
"//staging/src/k8s.io/cloud-provider/volume/helpers:go_default_library",
"//staging/src/k8s.io/csi-translation-lib:go_default_library",
@ -67,7 +65,6 @@ go_test(
"//pkg/volume/util:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",

21
pkg/scheduler/algorithm/predicates/csi_volume_predicate.go
View File

@ -20,16 +20,13 @@ import (
"fmt"
v1 "k8s.io/api/core/v1"
storagev1beta1 "k8s.io/api/storage/v1beta1"
storagev1 "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/util/rand"
utilfeature "k8s.io/apiserver/pkg/util/feature"
corelisters "k8s.io/client-go/listers/core/v1"
storagelisters "k8s.io/client-go/listers/storage/v1"
v1beta1storagelisters "k8s.io/client-go/listers/storage/v1beta1"
csitrans "k8s.io/csi-translation-lib"
"k8s.io/klog"
v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
"k8s.io/kubernetes/pkg/features"
schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo"
volumeutil "k8s.io/kubernetes/pkg/volume/util"
)
@ -46,7 +43,7 @@ type InTreeToCSITranslator interface {
// CSIMaxVolumeLimitChecker defines predicate needed for counting CSI volumes
type CSIMaxVolumeLimitChecker struct {
csiNodeLister v1beta1storagelisters.CSINodeLister
csiNodeLister storagelisters.CSINodeLister
pvLister corelisters.PersistentVolumeLister
pvcLister corelisters.PersistentVolumeClaimLister
scLister storagelisters.StorageClassLister
@ -58,7 +55,7 @@ type CSIMaxVolumeLimitChecker struct {
// NewCSIMaxVolumeLimitPredicate returns a predicate for counting CSI volumes
func NewCSIMaxVolumeLimitPredicate(
csiNodeLister v1beta1storagelisters.CSINodeLister, pvLister corelisters.PersistentVolumeLister, pvcLister corelisters.PersistentVolumeClaimLister, scLister storagelisters.StorageClassLister) FitPredicate {
csiNodeLister storagelisters.CSINodeLister, pvLister corelisters.PersistentVolumeLister, pvcLister corelisters.PersistentVolumeClaimLister, scLister storagelisters.StorageClassLister) FitPredicate {
c := &CSIMaxVolumeLimitChecker{
csiNodeLister: csiNodeLister,
pvLister: pvLister,
@ -70,7 +67,7 @@ func NewCSIMaxVolumeLimitPredicate(
return c.attachableLimitPredicate
}
func getVolumeLimits(nodeInfo *schedulernodeinfo.NodeInfo, csiNode *storagev1beta1.CSINode) map[v1.ResourceName]int64 {
func getVolumeLimits(nodeInfo *schedulernodeinfo.NodeInfo, csiNode *storagev1.CSINode) map[v1.ResourceName]int64 {
// TODO: stop getting values from Node object in v1.18
nodeVolumeLimits := nodeInfo.VolumeLimits()
if csiNode != nil {
@ -93,10 +90,6 @@ func (c *CSIMaxVolumeLimitChecker) attachableLimitPredicate(
return true, nil, nil
}
if !utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
return true, nil, nil
}
node := nodeInfo.Node()
if node == nil {
return false, nil, fmt.Errorf("node not found")
@ -160,7 +153,7 @@ func (c *CSIMaxVolumeLimitChecker) attachableLimitPredicate(
}
func (c *CSIMaxVolumeLimitChecker) filterAttachableVolumes(
csiNode *storagev1beta1.CSINode, volumes []v1.Volume, namespace string, result map[string]string) error {
csiNode *storagev1.CSINode, volumes []v1.Volume, namespace string, result map[string]string) error {
for _, vol := range volumes {
// CSI volumes can only be used as persistent volumes
if vol.PersistentVolumeClaim == nil {
@ -195,7 +188,7 @@ func (c *CSIMaxVolumeLimitChecker) filterAttachableVolumes(
// getCSIDriverInfo returns the CSI driver name and volume ID of a given PVC.
// If the PVC is from a migrated in-tree plugin, this function will return
// the information of the CSI driver that the plugin has been migrated to.
func (c *CSIMaxVolumeLimitChecker) getCSIDriverInfo(csiNode *storagev1beta1.CSINode, pvc *v1.PersistentVolumeClaim) (string, string) {
func (c *CSIMaxVolumeLimitChecker) getCSIDriverInfo(csiNode *storagev1.CSINode, pvc *v1.PersistentVolumeClaim) (string, string) {
pvName := pvc.Spec.VolumeName
namespace := pvc.Namespace
pvcName := pvc.Name
@ -250,7 +243,7 @@ func (c *CSIMaxVolumeLimitChecker) getCSIDriverInfo(csiNode *storagev1beta1.CSIN
}
// getCSIDriverInfoFromSC returns the CSI driver name and a random volume ID of a given PVC's StorageClass.
func (c *CSIMaxVolumeLimitChecker) getCSIDriverInfoFromSC(csiNode *storagev1beta1.CSINode, pvc *v1.PersistentVolumeClaim) (string, string) {
func (c *CSIMaxVolumeLimitChecker) getCSIDriverInfoFromSC(csiNode *storagev1.CSINode, pvc *v1.PersistentVolumeClaim) (string, string) {
namespace := pvc.Namespace
pvcName := pvc.Name
scName := v1helper.GetPersistentVolumeClaimClass(pvc)

7
pkg/scheduler/algorithm/predicates/csi_volume_predicate_test.go
View File

@ -23,7 +23,7 @@ import (
"testing"
v1 "k8s.io/api/core/v1"
storagev1beta1 "k8s.io/api/storage/v1beta1"
storagev1 "k8s.io/api/storage/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/sets"
utilfeature "k8s.io/apiserver/pkg/util/feature"
@ -434,7 +434,6 @@ func TestCSIVolumeCountPredicate(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
// running attachable predicate tests with feature gate and limit present on nodes
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
@ -547,7 +546,7 @@ func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) fakel
return pvcLister
}
func enableMigrationOnNode(csiNode *storagev1beta1.CSINode, pluginName string) {
func enableMigrationOnNode(csiNode *storagev1.CSINode, pluginName string) {
nodeInfoAnnotations := csiNode.GetAnnotations()
if nodeInfoAnnotations == nil {
nodeInfoAnnotations = map[string]string{}
@ -570,7 +569,7 @@ func getFakeCSIStorageClassLister(scName, provisionerName string) fakelisters.St
}
}
func getFakeCSINodeLister(csiNode *storagev1beta1.CSINode) fakelisters.CSINodeLister {
func getFakeCSINodeLister(csiNode *storagev1.CSINode) fakelisters.CSINodeLister {
if csiNode != nil {
return fakelisters.CSINodeLister(*csiNode)
}

45
pkg/scheduler/algorithm/predicates/max_attachable_volume_predicate_test.go
View File

@ -19,18 +19,14 @@ package predicates
import (
"os"
"reflect"
"strconv"
"strings"
"testing"
v1 "k8s.io/api/core/v1"
"k8s.io/api/storage/v1beta1"
storagev1 "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/features"
fakelisters "k8s.io/kubernetes/pkg/scheduler/listers/fake"
schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo"
volumeutil "k8s.io/kubernetes/pkg/volume/util"
@ -848,31 +844,6 @@ func TestVolumeCountConflicts(t *testing.T) {
expectedFailureReasons := []PredicateFailureReason{ErrMaxVolumeCountExceeded}
// running attachable predicate tests without feature gate and no limit present on nodes
for _, test := range tests {
os.Setenv(KubeMaxPDVols, strconv.Itoa(test.maxVols))
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)
pred := NewMaxPDVolumeCountPredicate(test.filterName,
getFakeCSINodeLister(csiNode),
getFakeStorageClassLister(test.filterName),
getFakePVLister(test.filterName),
getFakePVCLister(test.filterName))
factory := &MetadataProducerFactory{}
fits, reasons, err := pred(test.newPod, factory.GetPredicateMetadata(test.newPod, nil), node)
if err != nil {
t.Errorf("[%s]%s: unexpected error: %v", test.filterName, test.test, err)
}
if !fits && !reflect.DeepEqual(reasons, expectedFailureReasons) {
t.Errorf("[%s]%s: unexpected failure reasons: %v, want: %v", test.filterName, test.test, reasons, expectedFailureReasons)
}
if fits != test.fits {
t.Errorf("[%s]%s: expected %v, got %v", test.filterName, test.test, test.fits, fits)
}
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
// running attachable predicate tests with feature gate and limit present on nodes
for _, test := range tests {
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)
@ -1104,7 +1075,7 @@ func TestMaxVolumeFuncM4WithBothBetaAndStableLabels(t *testing.T) {
}
}
func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int64, driverNames ...string) (*schedulernodeinfo.NodeInfo, *v1beta1.CSINode) {
func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int64, driverNames ...string) (*schedulernodeinfo.NodeInfo, *storagev1.CSINode) {
nodeInfo := schedulernodeinfo.NewNodeInfo(pods...)
node := &v1.Node{
ObjectMeta: metav1.ObjectMeta{Name: "node-for-max-pd-test-1"},
@ -1112,7 +1083,7 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
Allocatable: v1.ResourceList{},
},
}
var csiNode *v1beta1.CSINode
var csiNode *storagev1.CSINode
addLimitToNode := func() {
for _, driver := range driverNames {
@ -1121,10 +1092,10 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
}
initCSINode := func() {
csiNode = &v1beta1.CSINode{
csiNode = &storagev1.CSINode{
ObjectMeta: metav1.ObjectMeta{Name: "csi-node-for-max-pd-test-1"},
Spec: v1beta1.CSINodeSpec{
Drivers: []v1beta1.CSINodeDriver{},
Spec: storagev1.CSINodeSpec{
Drivers: []storagev1.CSINodeDriver{},
},
}
}
@ -1132,12 +1103,12 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
addDriversCSINode := func(addLimits bool) {
initCSINode()
for _, driver := range driverNames {
driver := v1beta1.CSINodeDriver{
driver := storagev1.CSINodeDriver{
Name: driver,
NodeID: "node-for-max-pd-test-1",
}
if addLimits {
driver.Allocatable = &v1beta1.VolumeNodeResources{
driver.Allocatable = &storagev1.VolumeNodeResources{
Count: utilpointer.Int32Ptr(int32(limit)),
}
}

26
pkg/scheduler/algorithm/predicates/predicates.go
View File

@ -27,7 +27,6 @@ import (
v1 "k8s.io/api/core/v1"
storage "k8s.io/api/storage/v1"
v1beta1storage "k8s.io/api/storage/v1beta1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
@ -36,7 +35,6 @@ import (
utilfeature "k8s.io/apiserver/pkg/util/feature"
corelisters "k8s.io/client-go/listers/core/v1"
storagelisters "k8s.io/client-go/listers/storage/v1"
v1beta1storagelisters "k8s.io/client-go/listers/storage/v1beta1"
volumehelpers "k8s.io/cloud-provider/volume/helpers"
csilibplugins "k8s.io/csi-translation-lib/plugins"
v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
@ -225,7 +223,7 @@ type MaxPDVolumeCountChecker struct {
filter VolumeFilter
volumeLimitKey v1.ResourceName
maxVolumeFunc func(node *v1.Node) int
csiNodeLister v1beta1storagelisters.CSINodeLister
csiNodeLister storagelisters.CSINodeLister
pvLister corelisters.PersistentVolumeLister
pvcLister corelisters.PersistentVolumeClaimLister
scLister storagelisters.StorageClassLister
@ -244,7 +242,7 @@ type VolumeFilter struct {
// MatchProvisioner evaluates if the StorageClass provisioner matches the running predicate
MatchProvisioner func(sc *storage.StorageClass) (relevant bool)
// IsMigrated returns a boolean specifying whether the plugin is migrated to a CSI driver
IsMigrated func(csiNode *v1beta1storage.CSINode) bool
IsMigrated func(csiNode *storage.CSINode) bool
}
// NewMaxPDVolumeCountPredicate creates a predicate which evaluates whether a pod can fit based on the
@ -257,7 +255,7 @@ type VolumeFilter struct {
// The predicate looks for both volumes used directly, as well as PVC volumes that are backed by relevant volume
// types, counts the number of unique volumes, and rejects the new pod if it would place the total count over
// the maximum.
func NewMaxPDVolumeCountPredicate(filterName string, csiNodeLister v1beta1storagelisters.CSINodeLister, scLister storagelisters.StorageClassLister,
func NewMaxPDVolumeCountPredicate(filterName string, csiNodeLister storagelisters.CSINodeLister, scLister storagelisters.StorageClassLister,
pvLister corelisters.PersistentVolumeLister, pvcLister corelisters.PersistentVolumeClaimLister) FitPredicate {
var filter VolumeFilter
var volumeLimitKey v1.ResourceName
@ -441,7 +439,7 @@ func (c *MaxPDVolumeCountChecker) predicate(pod *v1.Pod, meta Metadata, nodeInfo
}
var (
csiNode *v1beta1storage.CSINode
csiNode *storage.CSINode
err error
)
if c.csiNodeLister != nil {
@ -477,11 +475,9 @@ func (c *MaxPDVolumeCountChecker) predicate(pod *v1.Pod, meta Metadata, nodeInfo
numNewVolumes := len(newVolumes)
maxAttachLimit := c.maxVolumeFunc(node)
if utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
volumeLimits := nodeInfo.VolumeLimits()
if maxAttachLimitFromAllocatable, ok := volumeLimits[c.volumeLimitKey]; ok {
maxAttachLimit = int(maxAttachLimitFromAllocatable)
}
volumeLimits := nodeInfo.VolumeLimits()
if maxAttachLimitFromAllocatable, ok := volumeLimits[c.volumeLimitKey]; ok {
maxAttachLimit = int(maxAttachLimitFromAllocatable)
}
if numExistingVolumes+numNewVolumes > maxAttachLimit {
@ -520,7 +516,7 @@ var EBSVolumeFilter = VolumeFilter{
return false
},
IsMigrated: func(csiNode *v1beta1storage.CSINode) bool {
IsMigrated: func(csiNode *storage.CSINode) bool {
return isCSIMigrationOn(csiNode, csilibplugins.AWSEBSInTreePluginName)
},
}
@ -548,7 +544,7 @@ var GCEPDVolumeFilter = VolumeFilter{
return false
},
IsMigrated: func(csiNode *v1beta1storage.CSINode) bool {
IsMigrated: func(csiNode *storage.CSINode) bool {
return isCSIMigrationOn(csiNode, csilibplugins.GCEPDInTreePluginName)
},
}
@ -576,7 +572,7 @@ var AzureDiskVolumeFilter = VolumeFilter{
return false
},
IsMigrated: func(csiNode *v1beta1storage.CSINode) bool {
IsMigrated: func(csiNode *storage.CSINode) bool {
return isCSIMigrationOn(csiNode, csilibplugins.AzureDiskInTreePluginName)
},
}
@ -605,7 +601,7 @@ var CinderVolumeFilter = VolumeFilter{
return false
},
IsMigrated: func(csiNode *v1beta1storage.CSINode) bool {
IsMigrated: func(csiNode *storage.CSINode) bool {
return isCSIMigrationOn(csiNode, csilibplugins.CinderInTreePluginName)
},
}

6
pkg/scheduler/algorithm/predicates/utils.go
View File

@ -19,8 +19,8 @@ package predicates
import (
"strings"
"k8s.io/api/core/v1"
storagev1beta1 "k8s.io/api/storage/v1beta1"
v1 "k8s.io/api/core/v1"
storagev1 "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
utilfeature "k8s.io/apiserver/pkg/util/feature"
@ -97,7 +97,7 @@ func SetPredicatesOrderingDuringTest(value []string) func() {
// isCSIMigrationOn returns a boolean value indicating whether
// the CSI migration has been enabled for a particular storage plugin.
func isCSIMigrationOn(csiNode *storagev1beta1.CSINode, pluginName string) bool {
func isCSIMigrationOn(csiNode *storagev1.CSINode, pluginName string) bool {
if csiNode == nil || len(pluginName) == 0 {
return false
}

3
pkg/scheduler/algorithm_factory.go
View File

@ -29,7 +29,6 @@ import (
corelisters "k8s.io/client-go/listers/core/v1"
policylisters "k8s.io/client-go/listers/policy/v1beta1"
storagelisters "k8s.io/client-go/listers/storage/v1"
v1beta1storagelisters "k8s.io/client-go/listers/storage/v1beta1"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
schedulerapi "k8s.io/kubernetes/pkg/scheduler/apis/config"
@ -53,7 +52,7 @@ type PluginFactoryArgs struct {
ReplicaSetLister appslisters.ReplicaSetLister
StatefulSetLister appslisters.StatefulSetLister
PDBLister policylisters.PodDisruptionBudgetLister
CSINodeLister v1beta1storagelisters.CSINodeLister
CSINodeLister storagelisters.CSINodeLister
PVLister corelisters.PersistentVolumeLister
PVCLister corelisters.PersistentVolumeClaimLister
StorageClassLister storagelisters.StorageClassLister

24
pkg/scheduler/apis/config/testing/compatibility_test.go
View File

@ -1169,30 +1169,6 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
},
},
},
{
name: "disable beta feature AttachVolumeLimit",
JSON: `{
"kind": "Policy",
"apiVersion": "v1",
"predicates": [
{"name": "MaxCSIVolumeCountPred"},
{"name": "CheckVolumeBinding"}
],
"priorities": [
]
}`,
featureGates: map[featuregate.Feature]bool{
features.AttachVolumeLimit: false,
},
wantPlugins: map[string][]config.Plugin{
"FilterPlugin": {
{Name: "NodeUnschedulable"},
{Name: "TaintToleration"},
{Name: "NodeVolumeLimits"},
{Name: "VolumeBinding"},
},
},
},
}
registeredPredicates := sets.NewString(scheduler.ListRegisteredFitPredicates()...)
registeredPriorities := sets.NewString(scheduler.ListRegisteredPriorityFunctions()...)

8
pkg/scheduler/factory.go
View File

@ -34,13 +34,11 @@ import (
coreinformers "k8s.io/client-go/informers/core/v1"
policyinformers "k8s.io/client-go/informers/policy/v1beta1"
storageinformersv1 "k8s.io/client-go/informers/storage/v1"
storageinformersv1beta1 "k8s.io/client-go/informers/storage/v1beta1"
clientset "k8s.io/client-go/kubernetes"
appslisters "k8s.io/client-go/listers/apps/v1"
corelisters "k8s.io/client-go/listers/core/v1"
policylisters "k8s.io/client-go/listers/policy/v1beta1"
storagelistersv1 "k8s.io/client-go/listers/storage/v1"
storagelistersv1beta1 "k8s.io/client-go/listers/storage/v1beta1"
"k8s.io/client-go/tools/cache"
"k8s.io/klog"
"k8s.io/kubernetes/pkg/features"
@ -93,7 +91,7 @@ type Configurator struct {
// a means to list all StorageClasses
storageClassLister storagelistersv1.StorageClassLister
// a means to list all CSINodes
csiNodeLister storagelistersv1beta1.CSINodeLister
csiNodeLister storagelistersv1.CSINodeLister
// a means to list all Nodes
nodeLister corelisters.NodeLister
// a means to list all Pods
@ -154,7 +152,7 @@ type ConfigFactoryArgs struct {
ServiceInformer coreinformers.ServiceInformer
PdbInformer policyinformers.PodDisruptionBudgetInformer
StorageClassInformer storageinformersv1.StorageClassInformer
CSINodeInformer storageinformersv1beta1.CSINodeInformer
CSINodeInformer storageinformersv1.CSINodeInformer
VolumeBinder *volumebinder.VolumeBinder
SchedulerCache internalcache.Cache
HardPodAffinitySymmetricWeight int32
@ -184,7 +182,7 @@ func NewConfigFactory(args *ConfigFactoryArgs) *Configurator {
storageClassLister = args.StorageClassInformer.Lister()
}
var csiNodeLister storagelistersv1beta1.CSINodeLister
var csiNodeLister storagelistersv1.CSINodeLister
if args.CSINodeInformer != nil {
csiNodeLister = args.CSINodeInformer.Lister()
}

2
pkg/scheduler/factory_test.go
View File

@ -552,7 +552,7 @@ func newConfigFactoryWithFrameworkRegistry(
ServiceInformer: informerFactory.Core().V1().Services(),
PdbInformer: informerFactory.Policy().V1beta1().PodDisruptionBudgets(),
StorageClassInformer: informerFactory.Storage().V1().StorageClasses(),
CSINodeInformer: informerFactory.Storage().V1beta1().CSINodes(),
CSINodeInformer: informerFactory.Storage().V1().CSINodes(),
HardPodAffinitySymmetricWeight: hardPodAffinitySymmetricWeight,
DisablePreemption: disablePodPreemption,
PercentageOfNodesToScore: schedulerapi.DefaultPercentageOfNodesToScore,

4
pkg/scheduler/framework/plugins/nodevolumelimits/BUILD
View File

@ -22,7 +22,7 @@ go_library(
"//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
"//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
"//staging/src/k8s.io/client-go/informers:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
],
)
@ -44,7 +44,7 @@ go_test(
"//pkg/scheduler/nodeinfo:go_default_library",
"//pkg/volume/util:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/api/storage/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",

5
pkg/scheduler/framework/plugins/nodevolumelimits/azure_test.go
View File

@ -22,9 +22,6 @@ import (
"testing"
v1 "k8s.io/api/core/v1"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
)
@ -355,8 +352,6 @@ func TestAzureDiskLimits(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)

5
pkg/scheduler/framework/plugins/nodevolumelimits/cinder_test.go
View File

@ -22,9 +22,6 @@ import (
"testing"
v1 "k8s.io/api/core/v1"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
)
@ -84,8 +81,6 @@ func TestCinderLimits(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)

22
pkg/scheduler/framework/plugins/nodevolumelimits/csi_test.go
View File

@ -24,8 +24,7 @@ import (
"testing"
v1 "k8s.io/api/core/v1"
"k8s.io/api/storage/v1beta1"
storagev1beta1 "k8s.io/api/storage/v1beta1"
storagev1 "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/sets"
@ -447,7 +446,6 @@ func TestCSILimits(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
// running attachable predicate tests with feature gate and limit present on nodes
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
@ -546,7 +544,7 @@ func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) fakel
return pvcLister
}
func enableMigrationOnNode(csiNode *storagev1beta1.CSINode, pluginName string) {
func enableMigrationOnNode(csiNode *storagev1.CSINode, pluginName string) {
nodeInfoAnnotations := csiNode.GetAnnotations()
if nodeInfoAnnotations == nil {
nodeInfoAnnotations = map[string]string{}
@ -569,14 +567,14 @@ func getFakeCSIStorageClassLister(scName, provisionerName string) fakelisters.St
}
}
func getFakeCSINodeLister(csiNode *storagev1beta1.CSINode) fakelisters.CSINodeLister {
func getFakeCSINodeLister(csiNode *storagev1.CSINode) fakelisters.CSINodeLister {
if csiNode != nil {
return fakelisters.CSINodeLister(*csiNode)
}
return fakelisters.CSINodeLister{}
}
func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int64, driverNames ...string) (*schedulernodeinfo.NodeInfo, *v1beta1.CSINode) {
func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int64, driverNames ...string) (*schedulernodeinfo.NodeInfo, *storagev1.CSINode) {
nodeInfo := schedulernodeinfo.NewNodeInfo(pods...)
node := &v1.Node{
ObjectMeta: metav1.ObjectMeta{Name: "node-for-max-pd-test-1"},
@ -584,7 +582,7 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
Allocatable: v1.ResourceList{},
},
}
var csiNode *v1beta1.CSINode
var csiNode *storagev1.CSINode
addLimitToNode := func() {
for _, driver := range driverNames {
@ -593,10 +591,10 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
}
initCSINode := func() {
csiNode = &v1beta1.CSINode{
csiNode = &storagev1.CSINode{
ObjectMeta: metav1.ObjectMeta{Name: "csi-node-for-max-pd-test-1"},
Spec: v1beta1.CSINodeSpec{
Drivers: []v1beta1.CSINodeDriver{},
Spec: storagev1.CSINodeSpec{
Drivers: []storagev1.CSINodeDriver{},
},
}
}
@ -604,12 +602,12 @@ func getNodeWithPodAndVolumeLimits(limitSource string, pods []*v1.Pod, limit int
addDriversCSINode := func(addLimits bool) {
initCSINode()
for _, driver := range driverNames {
driver := v1beta1.CSINodeDriver{
driver := storagev1.CSINodeDriver{
Name: driver,
NodeID: "node-for-max-pd-test-1",
}
if addLimits {
driver.Allocatable = &v1beta1.VolumeNodeResources{
driver.Allocatable = &storagev1.VolumeNodeResources{
Count: utilpointer.Int32Ptr(int32(limit)),
}
}

6
pkg/scheduler/framework/plugins/nodevolumelimits/csinode_helper.go
View File

@ -19,14 +19,14 @@ package nodevolumelimits
import (
utilfeature "k8s.io/apiserver/pkg/util/feature"
"k8s.io/client-go/informers"
v1beta1 "k8s.io/client-go/listers/storage/v1beta1"
storagelisters "k8s.io/client-go/listers/storage/v1"
kubefeatures "k8s.io/kubernetes/pkg/features"
)
// getCSINodeListerIfEnabled returns the CSINode lister or nil if the feature is disabled
func getCSINodeListerIfEnabled(factory informers.SharedInformerFactory) v1beta1.CSINodeLister {
func getCSINodeListerIfEnabled(factory informers.SharedInformerFactory) storagelisters.CSINodeLister {
if !utilfeature.DefaultFeatureGate.Enabled(kubefeatures.CSINodeInfo) {
return nil
}
return factory.Storage().V1beta1().CSINodes().Lister()
return factory.Storage().V1().CSINodes().Lister()
}

5
pkg/scheduler/framework/plugins/nodevolumelimits/ebs_test.go
View File

@ -24,10 +24,7 @@ import (
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
fakelisters "k8s.io/kubernetes/pkg/scheduler/listers/fake"
@ -469,8 +466,6 @@ func TestEBSLimits(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)

5
pkg/scheduler/framework/plugins/nodevolumelimits/gce_test.go
View File

@ -22,9 +22,6 @@ import (
"testing"
v1 "k8s.io/api/core/v1"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
)
@ -355,8 +352,6 @@ func TestGCEPDLimits(t *testing.T) {
},
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, test := range tests {
t.Run(test.test, func(t *testing.T) {
node, csiNode := getNodeWithPodAndVolumeLimits("node", test.existingPods, int64(test.maxVols), test.filterName)

2
pkg/scheduler/listers/fake/BUILD
View File

@ -11,13 +11,11 @@ go_library(
"//staging/src/k8s.io/api/apps/v1:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1:go_default_library",
"//staging/src/k8s.io/api/storage/v1beta1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
"//staging/src/k8s.io/client-go/listers/apps/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
"//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
],
)

14
pkg/scheduler/listers/fake/listers.go
View File

@ -22,13 +22,11 @@ import (
appsv1 "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1"
storagev1 "k8s.io/api/storage/v1"
storagev1beta1 "k8s.io/api/storage/v1beta1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
appslisters "k8s.io/client-go/listers/apps/v1"
corelisters "k8s.io/client-go/listers/core/v1"
storagelisters "k8s.io/client-go/listers/storage/v1"
v1beta1storagelisters "k8s.io/client-go/listers/storage/v1beta1"
schedulerlisters "k8s.io/kubernetes/pkg/scheduler/listers"
schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo"
)
@ -280,19 +278,19 @@ func NewNodeInfoLister(nodes []*v1.Node) schedulerlisters.NodeInfoLister {
return NodeInfoLister(nodeInfoList)
}
var _ v1beta1storagelisters.CSINodeLister = CSINodeLister{}
var _ storagelisters.CSINodeLister = CSINodeLister{}
// CSINodeLister declares a storagev1beta1.CSINode type for testing.
type CSINodeLister storagev1beta1.CSINode
// CSINodeLister declares a storagev1.CSINode type for testing.
type CSINodeLister storagev1.CSINode
// Get returns a fake CSINode object.
func (n CSINodeLister) Get(name string) (*storagev1beta1.CSINode, error) {
csiNode := storagev1beta1.CSINode(n)
func (n CSINodeLister) Get(name string) (*storagev1.CSINode, error) {
csiNode := storagev1.CSINode(n)
return &csiNode, nil
}
// List lists all CSINodes in the indexer.
func (n CSINodeLister) List(selector labels.Selector) (ret []*storagev1beta1.CSINode, err error) {
func (n CSINodeLister) List(selector labels.Selector) (ret []*storagev1.CSINode, err error) {
return nil, fmt.Errorf("not implemented")
}

6
pkg/scheduler/scheduler.go
View File

@ -33,7 +33,7 @@ import (
"k8s.io/client-go/informers"
coreinformers "k8s.io/client-go/informers/core/v1"
policyv1beta1informers "k8s.io/client-go/informers/policy/v1beta1"
storagev1beta1informers "k8s.io/client-go/informers/storage/v1beta1"
storageinformers "k8s.io/client-go/informers/storage/v1"
clientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/cache"
"k8s.io/client-go/tools/events"
@ -292,9 +292,9 @@ func New(client clientset.Interface,
pdbInformer = informerFactory.Policy().V1beta1().PodDisruptionBudgets()
}
var csiNodeInformer storagev1beta1informers.CSINodeInformer
var csiNodeInformer storageinformers.CSINodeInformer
if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.CSINodeInfo) {
csiNodeInformer = informerFactory.Storage().V1beta1().CSINodes()
csiNodeInformer = informerFactory.Storage().V1().CSINodes()
}
// Set up the configurator which can create schedulers from configs.

18
pkg/volume/csi/nodeinfomanager/nodeinfomanager.go
View File

@ -556,17 +556,15 @@ func (nim *nodeInfoManager) installDriverToCSINode(
TopologyKeys: topologyKeys.List(),
}
if utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
if maxAttachLimit > 0 {
if maxAttachLimit > math.MaxInt32 {
klog.Warningf("Exceeded max supported attach limit value, truncating it to %d", math.MaxInt32)
maxAttachLimit = math.MaxInt32
}
m := int32(maxAttachLimit)
driverSpec.Allocatable = &storagev1.VolumeNodeResources{Count: &m}
} else {
klog.Errorf("Invalid attach limit value %d cannot be added to CSINode object for %q", maxAttachLimit, driverName)
if maxAttachLimit > 0 {
if maxAttachLimit > math.MaxInt32 {
klog.Warningf("Exceeded max supported attach limit value, truncating it to %d", math.MaxInt32)
maxAttachLimit = math.MaxInt32
}
m := int32(maxAttachLimit)
driverSpec.Allocatable = &storagev1.VolumeNodeResources{Count: &m}
} else {
klog.Errorf("Invalid attach limit value %d cannot be added to CSINode object for %q", maxAttachLimit, driverName)
}
newDriverSpecs = append(newDriverSpecs, driverSpec)

1
pkg/volume/csi/nodeinfomanager/nodeinfomanager_test.go
View File

@ -1011,7 +1011,6 @@ func getClientSet(existingNode *v1.Node, existingCSINode *storage.CSINode) *fake
func test(t *testing.T, addNodeInfo bool, csiNodeInfoEnabled bool, testcases []testcase) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSINodeInfo, csiNodeInfoEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.AttachVolumeLimit, true)()
for _, tc := range testcases {
t.Logf("test case: %q", tc.name)

6
plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go
View File

@ -498,10 +498,8 @@ func ClusterRoles() []rbacv1.ClusterRole {
// Needed to check API access. These creates are non-mutating
rbacv1helpers.NewRule("create").Groups(authenticationGroup).Resources("tokenreviews").RuleOrDie(),
rbacv1helpers.NewRule("create").Groups(authorizationGroup).Resources("subjectaccessreviews").RuleOrDie(),
}
if utilfeature.DefaultFeatureGate.Enabled(features.CSINodeInfo) &&
utilfeature.DefaultFeatureGate.Enabled(features.AttachVolumeLimit) {
kubeSchedulerRules = append(kubeSchedulerRules, rbacv1helpers.NewRule(Read...).Groups(storageGroup).Resources("csinodes").RuleOrDie())
// Needed for volume limits
rbacv1helpers.NewRule(Read...).Groups(storageGroup).Resources("csinodes").RuleOrDie(),
}
roles = append(roles, rbacv1.ClusterRole{
// a role to use for the kube-scheduler

1
test/e2e/storage/drivers/csi.go
View File

@ -106,6 +106,7 @@ func InitHostPathCSIDriver() testsuites.TestDriver {
testsuites.CapPVCDataSource: true,
testsuites.CapControllerExpansion: true,
testsuites.CapSingleNodeVolume: true,
testsuites.CapVolumeLimits: true,
}
return initHostPathCSIDriver("csi-hostpath",
capabilities,

26
test/e2e/storage/testsuites/volumelimits.go
View File

@ -109,7 +109,7 @@ func (t *volumeLimitsTestSuite) defineTests(driver TestDriver, pattern testpatte
// And one extra pod with a CSI volume should get Pending with a condition
// that says it's unschedulable because of volume limit.
// BEWARE: the test may create lot of volumes and it's really slow.
ginkgo.It("should support volume limits [Slow][Serial]", func() {
ginkgo.It("should support volume limits [Serial]", func() {
driverInfo := driver.GetDriverInfo()
if !driverInfo.Capabilities[CapVolumeLimits] {
ginkgo.Skip(fmt.Sprintf("driver %s does not support volume limits", driverInfo.Name))
@ -124,15 +124,19 @@ func (t *volumeLimitsTestSuite) defineTests(driver TestDriver, pattern testpatte
l.config, l.testCleanup = driver.PrepareTest(f)
defer l.testCleanup()
ginkgo.By("Picking a random node")
var nodeName string
node, err := e2enode.GetRandomReadySchedulableNode(f.ClientSet)
framework.ExpectNoError(err)
nodeName = node.Name
ginkgo.By("Picking a node")
// Some CSI drivers are deployed to a single node (e.g csi-hostpath),
// so we use that node instead of picking a random one.
nodeName := l.config.ClientNodeName
if nodeName == "" {
node, err := e2enode.GetRandomReadySchedulableNode(f.ClientSet)
framework.ExpectNoError(err)
nodeName = node.Name
}
framework.Logf("Selected node %s", nodeName)
ginkgo.By("Checking node limits")
limit, err := getNodeLimits(l.cs, nodeName, driverInfo)
limit, err := getNodeLimits(l.cs, l.config, nodeName, driverInfo)
framework.ExpectNoError(err)
framework.Logf("Node %s can handle %d volumes of driver %s", nodeName, limit, driverInfo.Name)
@ -283,9 +287,9 @@ func waitForAllPVCsPhase(cs clientset.Interface, timeout time.Duration, pvcs []*
return pvNames, err
}
func getNodeLimits(cs clientset.Interface, nodeName string, driverInfo *DriverInfo) (int, error) {
func getNodeLimits(cs clientset.Interface, config *PerTestConfig, nodeName string, driverInfo *DriverInfo) (int, error) {
if len(driverInfo.InTreePluginName) == 0 {
return getCSINodeLimits(cs, nodeName, driverInfo)
return getCSINodeLimits(cs, config, nodeName, driverInfo)
}
return getInTreeNodeLimits(cs, nodeName, driverInfo)
}
@ -317,7 +321,7 @@ func getInTreeNodeLimits(cs clientset.Interface, nodeName string, driverInfo *Dr
return int(limit.Value()), nil
}
func getCSINodeLimits(cs clientset.Interface, nodeName string, driverInfo *DriverInfo) (int, error) {
func getCSINodeLimits(cs clientset.Interface, config *PerTestConfig, nodeName string, driverInfo *DriverInfo) (int, error) {
// Wait in a loop, the driver might just have been installed and kubelet takes a while to publish everything.
var limit int
err := wait.PollImmediate(2*time.Second, csiNodeInfoTimeout, func() (bool, error) {
@ -328,7 +332,7 @@ func getCSINodeLimits(cs clientset.Interface, nodeName string, driverInfo *Drive
}
var csiDriver *storagev1.CSINodeDriver
for _, c := range csiNode.Spec.Drivers {
if c.Name == driverInfo.Name {
if c.Name == driverInfo.Name || c.Name == config.GetUniqueDriverName() {
csiDriver = &c
break
}

3
test/e2e/testing-manifests/storage-csi/hostpath/hostpath/csi-hostpath-plugin.yaml
View File

@ -62,12 +62,13 @@ spec:
name: csi-data-dir
- name: hostpath
image: quay.io/k8scsi/hostpathplugin:v1.2.0
image: quay.io/k8scsi/hostpathplugin:v1.3.0-rc1
args:
- "--drivername=hostpath.csi.k8s.io"
- "--v=5"
- "--endpoint=$(CSI_ENDPOINT)"
- "--nodeid=$(KUBE_NODE_NAME)"
- "--maxvolumespernode=10"
env:
- name: CSI_ENDPOINT
value: unix:///csi/csi.sock