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

CSIMigration feature gate to GA

Browse Source
This commit is contained in:
Jiawei Wang 2022-06-06 21:19:19 +00:00
parent 59ffc93678
commit 760365d5c9
22 changed files with 29 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
pkg/apis/storage/validation/validation.go
View File

@ -31,9 +31,6 @@ import (
"k8s.io/kubernetes/pkg/apis/core/helper"
apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
"k8s.io/kubernetes/pkg/apis/storage"
utilfeature "k8s.io/apiserver/pkg/util/feature"
"k8s.io/kubernetes/pkg/features"
)
const (
@ -179,11 +176,7 @@ func validateVolumeAttachmentSource(source *storage.VolumeAttachmentSource, fldP
allErrs := field.ErrorList{}
switch {
case source.InlineVolumeSpec == nil && source.PersistentVolumeName == nil:
if utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
allErrs = append(allErrs, field.Required(fldPath, "must specify exactly one of inlineVolumeSpec and persistentVolumeName"))
} else {
allErrs = append(allErrs, field.Required(fldPath, "must specify persistentVolumeName when CSIMigration feature is disabled"))
}
allErrs = append(allErrs, field.Required(fldPath, "must specify exactly one of inlineVolumeSpec and persistentVolumeName"))
case source.InlineVolumeSpec != nil && source.PersistentVolumeName != nil:
allErrs = append(allErrs, field.Forbidden(fldPath, "must specify exactly one of inlineVolumeSpec and persistentVolumeName"))
case source.PersistentVolumeName != nil:

38
pkg/apis/storage/validation/validation_test.go
View File

@ -23,11 +23,8 @@ import (
"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"
api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/kubernetes/pkg/apis/storage"
"k8s.io/kubernetes/pkg/features"
utilpointer "k8s.io/utils/pointer"
)
@ -158,7 +155,6 @@ func TestValidateStorageClass(t *testing.T) {
}
func TestVolumeAttachmentValidation(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
volumeName := "pv-name"
empty := ""
migrationEnabledSuccessCases := []storage.VolumeAttachment{
@ -384,43 +380,9 @@ func TestVolumeAttachmentValidation(t *testing.T) {
t.Errorf("expected failure for test: %v", volumeAttachment)
}
}
// validate with CSIMigration disabled
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, false)()
migrationDisabledSuccessCases := []storage.VolumeAttachment{
{
// PVName specified with migration disabled
ObjectMeta: metav1.ObjectMeta{Name: "foo"},
Spec: storage.VolumeAttachmentSpec{
Attacher: "myattacher",
NodeName: "node",
Source: storage.VolumeAttachmentSource{
PersistentVolumeName: &volumeName,
},
},
},
{
// InlineSpec specified with migration disabled
ObjectMeta: metav1.ObjectMeta{Name: "foo"},
Spec: storage.VolumeAttachmentSpec{
Attacher: "myattacher",
NodeName: "node",
Source: storage.VolumeAttachmentSource{
InlineVolumeSpec: &inlineSpec,
},
},
},
}
for _, volumeAttachment := range migrationDisabledSuccessCases {
if errs := ValidateVolumeAttachment(&volumeAttachment); len(errs) != 0 {
t.Errorf("expected success: %v %v", volumeAttachment, errs)
}
}
}
func TestVolumeAttachmentUpdateValidation(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
volumeName := "foo"
newVolumeName := "bar"

7
pkg/controller/volume/attachdetach/attach_detach_controller.go
View File

@ -54,7 +54,6 @@ import (
"k8s.io/kubernetes/pkg/controller/volume/attachdetach/statusupdater"
"k8s.io/kubernetes/pkg/controller/volume/attachdetach/util"
"k8s.io/kubernetes/pkg/controller/volume/common"
"k8s.io/kubernetes/pkg/features"
proxyutil "k8s.io/kubernetes/pkg/proxy/util"
"k8s.io/kubernetes/pkg/volume"
"k8s.io/kubernetes/pkg/volume/csi"
@ -138,10 +137,8 @@ func NewAttachDetachController(
filteredDialOptions: filteredDialOptions,
}
if utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
adc.csiNodeLister = csiNodeInformer.Lister()
adc.csiNodeSynced = csiNodeInformer.Informer().HasSynced
}
adc.csiNodeLister = csiNodeInformer.Lister()
adc.csiNodeSynced = csiNodeInformer.Informer().HasSynced
adc.csiDriverLister = csiDriverInformer.Lister()
adc.csiDriversSynced = csiDriverInformer.Informer().HasSynced

1
pkg/controller/volume/attachdetach/attach_detach_controller_test.go
View File

@ -431,7 +431,6 @@ func volumeAttachmentRecoveryTestCase(t *testing.T, tc vaTest) {
informerFactory := informers.NewSharedInformerFactory(fakeKubeClient, time.Second*1)
var plugins []volume.VolumePlugin
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, tc.csiMigration)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationGCE, tc.csiMigration)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.InTreePluginGCEUnregister, tc.csiMigration)()

7
pkg/controller/volume/attachdetach/util/util.go
View File

@ -24,12 +24,10 @@ import (
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/sets"
utilfeature "k8s.io/apiserver/pkg/util/feature"
corelisters "k8s.io/client-go/listers/core/v1"
"k8s.io/component-helpers/storage/ephemeral"
"k8s.io/klog/v2"
"k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/volume"
"k8s.io/kubernetes/pkg/volume/csimigration"
"k8s.io/kubernetes/pkg/volume/util"
@ -315,11 +313,6 @@ func translateInTreeSpecToCSIIfNeeded(spec *volume.Spec, nodeName types.NodeName
}
func isCSIMigrationSupportedOnNode(nodeName types.NodeName, spec *volume.Spec, vpm *volume.VolumePluginMgr, csiMigratedPluginManager csimigration.PluginManager) (bool, error) {
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
// If CSIMigration is disabled, CSI migration paths will not be taken for the node.
return false, nil
}
pluginName, err := csiMigratedPluginManager.GetInTreePluginNameFromSpec(spec.PersistentVolume, spec.Volume)
if err != nil {
return false, err

2
pkg/controller/volume/expand/expand_controller_test.go
View File

@ -126,10 +126,8 @@ func TestSyncHandler(t *testing.T) {
}
if test.csiMigrationEnabled {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationAWS, true)()
} else {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, false)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationAWS, false)()
}

8
pkg/controller/volume/persistentvolume/pv_controller_test.go
View File

@ -471,8 +471,6 @@ func makeStorageClass(scName string, mode *storagev1.VolumeBindingMode) *storage
}
func TestAnnealMigrationAnnotations(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
const testPlugin = "non-migrated-plugin"
const gcePlugin = "kubernetes.io/gce-pd"
const gceDriver = "pd.csi.storage.gke.io"
@ -687,7 +685,7 @@ func TestModifyDeletionFinalizers(t *testing.T) {
volumeAnnotations: map[string]string{volume.AnnDynamicallyProvisioned: gcePlugin, volume.AnnMigratedTo: gceDriver},
expVolumeFinalizers: []string{volume.PVDeletionProtectionFinalizer},
expModified: true,
migratedDriverGates: []featuregate.Feature{features.CSIMigration, features.CSIMigrationGCE},
migratedDriverGates: []featuregate.Feature{features.CSIMigrationGCE},
},
{
// csi-migration is not completely enabled as the specific plugin feature is not present. This is equivalent
@ -696,7 +694,7 @@ func TestModifyDeletionFinalizers(t *testing.T) {
initialVolume: newVolumeWithFinalizers("volume-13-8", "1Gi", "uid11-23", "claim11-23", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classCopper, []string{volume.PVDeletionProtectionFinalizer}, volume.AnnDynamicallyProvisioned, volume.AnnBoundByController),
expVolumeFinalizers: []string{volume.PVDeletionInTreeProtectionFinalizer},
expModified: true,
migratedDriverGates: []featuregate.Feature{features.CSIMigration},
migratedDriverGates: []featuregate.Feature{},
},
{
// same as 13-8 but multiple finalizers exists, only the pv deletion protection finalizer needs to be
@ -705,7 +703,7 @@ func TestModifyDeletionFinalizers(t *testing.T) {
initialVolume: newVolumeWithFinalizers("volume-13-9", "1Gi", "uid11-23", "claim11-23", v1.VolumeBound, v1.PersistentVolumeReclaimDelete, classCopper, []string{volume.PVDeletionProtectionFinalizer, customFinalizer}, volume.AnnDynamicallyProvisioned, volume.AnnBoundByController),
expVolumeFinalizers: []string{customFinalizer, volume.PVDeletionInTreeProtectionFinalizer},
expModified: true,
migratedDriverGates: []featuregate.Feature{features.CSIMigration},
migratedDriverGates: []featuregate.Feature{},
},
{
// corner error case.

2
pkg/features/kube_features.go
View File

@ -817,7 +817,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS
CSIInlineVolume: {Default: true, PreRelease: featuregate.Beta},
CSIMigration: {Default: true, PreRelease: featuregate.Beta},
CSIMigration: {Default: true, PreRelease: featuregate.GA, LockToDefault: true}, // remove in 1.27
CSIMigrationAWS: {Default: true, PreRelease: featuregate.Beta},

10
pkg/registry/storage/volumeattachment/strategy.go
View File

@ -23,11 +23,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"
"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
)
@ -61,11 +59,6 @@ func (volumeAttachmentStrategy) GetResetFields() map[fieldpath.APIVersion]*field
func (volumeAttachmentStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) {
volumeAttachment := obj.(*storage.VolumeAttachment)
volumeAttachment.Status = storage.VolumeAttachmentStatus{}
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
volumeAttachment.Spec.Source.InlineVolumeSpec = nil
}
}
func (volumeAttachmentStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
@ -99,9 +92,6 @@ func (volumeAttachmentStrategy) PrepareForUpdate(ctx context.Context, obj, old r
newVolumeAttachment.Status = oldVolumeAttachment.Status
// No need to increment Generation because we don't allow updates to spec
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && oldVolumeAttachment.Spec.Source.InlineVolumeSpec == nil {
newVolumeAttachment.Spec.Source.InlineVolumeSpec = nil
}
}
func (volumeAttachmentStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {

17
pkg/registry/storage/volumeattachment/strategy_test.go
View File

@ -25,11 +25,8 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/diff"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/kubernetes/pkg/apis/storage"
"k8s.io/kubernetes/pkg/features"
)
func getValidVolumeAttachment(name string) *storage.VolumeAttachment {
@ -127,7 +124,6 @@ func TestVolumeAttachmentStrategySourceInlineSpec(t *testing.T) {
volumeAttachment := getValidVolumeAttachmentWithInlineSpec("valid-attachment")
volumeAttachmentSaved := volumeAttachment.DeepCopy()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
Strategy.PrepareForCreate(ctx, volumeAttachment)
if volumeAttachment.Spec.Source.InlineVolumeSpec == nil {
t.Errorf("InlineVolumeSpec unexpectedly set to nil during PrepareForCreate")
@ -139,23 +135,10 @@ func TestVolumeAttachmentStrategySourceInlineSpec(t *testing.T) {
if volumeAttachmentSaved.Spec.Source.InlineVolumeSpec == nil {
t.Errorf("InlineVolumeSpec unexpectedly set to nil during PrepareForUpdate")
}
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, false)()
Strategy.PrepareForUpdate(ctx, volumeAttachmentSaved, volumeAttachment)
if volumeAttachmentSaved.Spec.Source.InlineVolumeSpec == nil {
t.Errorf("InlineVolumeSpec unexpectedly set to nil during PrepareForUpdate")
}
volumeAttachment = getValidVolumeAttachmentWithInlineSpec("valid-attachment")
volumeAttachmentNew := volumeAttachment.DeepCopy()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, false)()
Strategy.PrepareForCreate(ctx, volumeAttachment)
if volumeAttachment.Spec.Source.InlineVolumeSpec != nil {
t.Errorf("InlineVolumeSpec unexpectedly not dropped during PrepareForCreate")
}
Strategy.PrepareForUpdate(ctx, volumeAttachmentNew, volumeAttachment)
if volumeAttachmentNew.Spec.Source.InlineVolumeSpec != nil {
t.Errorf("InlineVolumeSpec unexpectedly not dropped during PrepareForUpdate")
}
}
func TestVolumeAttachmentStatusStrategy(t *testing.T) {

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

@ -534,11 +534,9 @@ func TestCSILimits(t *testing.T) {
t.Run(test.test, func(t *testing.T) {
node, csiNode := getNodeWithPodAndVolumeLimits(test.limitSource, test.existingPods, int64(test.maxVols), test.driverNames...)
if test.migrationEnabled {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationAWS, true)()
enableMigrationOnNode(csiNode, csilibplugins.AWSEBSInTreePluginName)
} else {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, false)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationAWS, false)()
}
csiTranslator := csitrans.New()

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

@ -19,7 +19,7 @@ package nodevolumelimits
import (
"strings"
"k8s.io/api/core/v1"
v1 "k8s.io/api/core/v1"
storagev1 "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/util/sets"
utilfeature "k8s.io/apiserver/pkg/util/feature"
@ -38,10 +38,6 @@ func isCSIMigrationOn(csiNode *storagev1.CSINode, pluginName string) bool {
// In-tree storage to CSI driver migration feature should be enabled,
// along with the plugin-specific one
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
return false
}
switch pluginName {
case csilibplugins.AWSEBSInTreePluginName:
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAWS) {

4
pkg/scheduler/framework/plugins/volumebinding/binder.go
View File

@ -1046,10 +1046,6 @@ func (b *volumeBinder) tryTranslatePVToCSI(pv *v1.PersistentVolume, csiNode *sto
return pv, nil
}
if !utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
return pv, nil
}
pluginName, err := b.translator.GetInTreePluginNameFromSpec(pv, nil)
if err != nil {
return nil, fmt.Errorf("could not get plugin name from pv: %v", err)

2
pkg/scheduler/framework/plugins/volumebinding/binder_test.go
View File

@ -1217,7 +1217,6 @@ func TestFindPodVolumesWithCSIMigration(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, true)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationGCE, true)()
// Setup
@ -1844,7 +1843,6 @@ func TestCheckBindingsWithCSIMigration(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, scenario.migrationEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigrationGCE, scenario.migrationEnabled)()
// Setup

26
pkg/volume/csi/csi_plugin.go
View File

@ -217,40 +217,38 @@ func (p *csiPlugin) Init(host volume.VolumeHost) error {
var migratedPlugins = map[string](func() bool){
csitranslationplugins.GCEPDInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationGCE)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationGCE)
},
csitranslationplugins.AWSEBSInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAWS)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAWS)
},
csitranslationplugins.CinderInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration)
return true
},
csitranslationplugins.AzureDiskInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAzureDisk)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAzureDisk)
},
csitranslationplugins.AzureFileInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAzureFile)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationAzureFile)
},
csitranslationplugins.VSphereInTreePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationvSphere)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationvSphere)
},
csitranslationplugins.PortworxVolumePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationPortworx)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationPortworx)
},
csitranslationplugins.RBDVolumePluginName: func() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) && utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationRBD)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationRBD)
},
}
// Initializing the label management channels
nim = nodeinfomanager.NewNodeInfoManager(host.GetNodeName(), host, migratedPlugins)
if utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
// This function prevents Kubelet from posting Ready status until CSINode
// is both installed and initialized
if err := initializeCSINode(host); err != nil {
return errors.New(log("failed to initialize CSINode: %v", err))
}
// This function prevents Kubelet from posting Ready status until CSINode
// is both installed and initialized
if err := initializeCSINode(host); err != nil {
return errors.New(log("failed to initialize CSINode: %v", err))
}
return nil

10
pkg/volume/csimigration/plugin_manager.go
View File

@ -85,9 +85,7 @@ func (pm PluginManager) IsMigrationCompleteForPlugin(pluginName string) bool {
// for a particular storage plugin
func (pm PluginManager) IsMigrationEnabledForPlugin(pluginName string) bool {
// CSIMigration feature should be enabled along with the plugin-specific one
if !pm.featureGate.Enabled(features.CSIMigration) {
return false
}
// CSIMigration has been GA. It will be enabled by default.
switch pluginName {
case csilibplugins.AWSEBSInTreePluginName:
@ -163,11 +161,7 @@ func TranslateInTreeSpecToCSI(spec *volume.Spec, podNamespace string, translator
// by looking up the pluginUnregister flag
func CheckMigrationFeatureFlags(f featuregate.FeatureGate, pluginMigration,
pluginUnregister featuregate.Feature) (migrationComplete bool, err error) {
if f.Enabled(pluginMigration) && !f.Enabled(features.CSIMigration) {
return false, fmt.Errorf("enabling %q requires CSIMigration to be enabled", pluginMigration)
}
// This is for other in-tree plugin that get migration finished
// This is for in-tree plugin that get migration finished
if f.Enabled(pluginMigration) && f.Enabled(pluginUnregister) {
return true, nil
}

31
pkg/volume/csimigration/plugin_manager_test.go
View File

@ -127,7 +127,6 @@ func TestIsMigratable(t *testing.T) {
for _, test := range testCases {
pm := NewPluginManager(csiTranslator, utilfeature.DefaultFeatureGate)
t.Run(fmt.Sprintf("Testing %v", test.name), func(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, test.csiMigrationEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, test.pluginFeature, test.pluginFeatureEnabled)()
migratable, err := pm.IsMigratable(test.spec)
if migratable != test.isMigratable {
@ -145,37 +144,24 @@ func TestCheckMigrationFeatureFlags(t *testing.T) {
name string
pluginFeature featuregate.Feature
pluginFeatureEnabled bool
csiMigrationEnabled bool
pluginUnregsiterFeature featuregate.Feature
pluginUnregsiterEnabled bool
expectMigrationComplete bool
expectErr bool
}{
{
name: "plugin specific feature flag enabled with migration flag disabled",
name: "plugin specific migration feature enabled with plugin unregister disabled",
pluginFeature: features.CSIMigrationvSphere,
pluginFeatureEnabled: true,
csiMigrationEnabled: false,
pluginUnregsiterFeature: features.InTreePluginvSphereUnregister,
pluginUnregsiterEnabled: false,
expectMigrationComplete: false,
expectErr: true,
},
{
name: "plugin specific migration feature and CSI migration flag both enabled with plugin unregister disabled",
pluginFeature: features.CSIMigrationvSphere,
pluginFeatureEnabled: true,
csiMigrationEnabled: true,
pluginUnregsiterFeature: features.InTreePluginvSphereUnregister,
pluginUnregsiterEnabled: false,
expectMigrationComplete: false,
expectErr: false,
},
{
name: "plugin specific migration feature and plugin unregister disabled and CSI migration flag enabled",
name: "plugin specific migration feature and plugin unregister disabled",
pluginFeature: features.CSIMigrationvSphere,
pluginFeatureEnabled: false,
csiMigrationEnabled: true,
pluginUnregsiterFeature: features.InTreePluginvSphereUnregister,
pluginUnregsiterEnabled: false,
expectMigrationComplete: false,
@ -185,26 +171,14 @@ func TestCheckMigrationFeatureFlags(t *testing.T) {
name: "all features enabled",
pluginFeature: features.CSIMigrationvSphere,
pluginFeatureEnabled: true,
csiMigrationEnabled: true,
pluginUnregsiterFeature: features.InTreePluginvSphereUnregister,
pluginUnregsiterEnabled: true,
expectMigrationComplete: true,
expectErr: false,
},
{
name: "all features disabled",
pluginFeature: features.CSIMigrationvSphere,
pluginFeatureEnabled: false,
csiMigrationEnabled: false,
pluginUnregsiterFeature: features.InTreePluginvSphereUnregister,
pluginUnregsiterEnabled: false,
expectMigrationComplete: false,
expectErr: false,
},
}
for _, test := range testCases {
t.Run(fmt.Sprintf("Testing %v", test.name), func(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, test.csiMigrationEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, test.pluginFeature, test.pluginFeatureEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, test.pluginUnregsiterFeature, test.pluginUnregsiterEnabled)()
migrationComplete, err := CheckMigrationFeatureFlags(utilfeature.DefaultFeatureGate, test.pluginFeature, test.pluginUnregsiterFeature)
@ -326,7 +300,6 @@ func TestMigrationFeatureFlagStatus(t *testing.T) {
for _, test := range testCases {
pm := NewPluginManager(csiTranslator, utilfeature.DefaultFeatureGate)
t.Run(fmt.Sprintf("Testing %v", test.name), func(t *testing.T) {
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIMigration, test.csiMigrationEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, test.pluginFeature, test.pluginFeatureEnabled)()
defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, test.inTreePluginUnregister, test.inTreePluginUnregisterEnabled)()

3
pkg/volume/portworx/portworx.go
View File

@ -67,8 +67,7 @@ func getPath(uid types.UID, volName string, host volume.VolumeHost) string {
}
func (plugin *portworxVolumePlugin) IsMigratedToCSI() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) &&
utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationPortworx)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationPortworx)
}
func (plugin *portworxVolumePlugin) Init(host volume.VolumeHost) error {

3
pkg/volume/rbd/rbd.go
View File

@ -80,8 +80,7 @@ func getPath(uid types.UID, volName string, host volume.VolumeHost) string {
}
func (plugin *rbdPlugin) IsMigratedToCSI() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) &&
utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationRBD)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationRBD)
}
func (plugin *rbdPlugin) Init(host volume.VolumeHost) error {

3
pkg/volume/vsphere_volume/vsphere_volume.go
View File

@ -75,8 +75,7 @@ func (plugin *vsphereVolumePlugin) GetPluginName() string {
}
func (plugin *vsphereVolumePlugin) IsMigratedToCSI() bool {
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) &&
utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationvSphere)
return utilfeature.DefaultFeatureGate.Enabled(features.CSIMigrationvSphere)
}
func (plugin *vsphereVolumePlugin) GetVolumeName(spec *volume.Spec) (string, error) {

4
plugin/pkg/auth/authorizer/rbac/bootstrappolicy/controller_policy.go
View File

@ -75,9 +75,7 @@ func buildControllerRoles() ([]rbacv1.ClusterRole, []rbacv1.ClusterRoleBinding)
}
role.Rules = append(role.Rules, rbacv1helpers.NewRule("get", "watch", "list").Groups("storage.k8s.io").Resources("csidrivers").RuleOrDie())
if utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
role.Rules = append(role.Rules, rbacv1helpers.NewRule("get", "watch", "list").Groups("storage.k8s.io").Resources("csinodes").RuleOrDie())
}
role.Rules = append(role.Rules, rbacv1helpers.NewRule("get", "watch", "list").Groups("storage.k8s.io").Resources("csinodes").RuleOrDie())
return role
}())

6
test/integration/volume/attach_detach_test.go
View File

@ -26,7 +26,6 @@ import (
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/wait"
utilfeature "k8s.io/apiserver/pkg/util/feature"
clientgoinformers "k8s.io/client-go/informers"
clientset "k8s.io/client-go/kubernetes"
restclient "k8s.io/client-go/rest"
@ -37,7 +36,6 @@ import (
volumecache "k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
"k8s.io/kubernetes/pkg/controller/volume/persistentvolume"
persistentvolumeoptions "k8s.io/kubernetes/pkg/controller/volume/persistentvolume/options"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/volume"
volumetest "k8s.io/kubernetes/pkg/volume/testing"
"k8s.io/kubernetes/pkg/volume/util"
@ -213,9 +211,7 @@ func TestPodDeletionWithDswp(t *testing.T) {
}
func initCSIObjects(stopCh <-chan struct{}, informers clientgoinformers.SharedInformerFactory) {
if utilfeature.DefaultFeatureGate.Enabled(features.CSIMigration) {
go informers.Storage().V1().CSINodes().Informer().Run(stopCh)
}
go informers.Storage().V1().CSINodes().Informer().Run(stopCh)
go informers.Storage().V1().CSIDrivers().Informer().Run(stopCh)
}