Merge pull request #545 from nixpanic/split-resize-modify

Allow modify without resize support

Author: k8s-ci-robot

cmd/csi-resizer/main.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"net/http"
@@ -207,7 +208,9 @@ func main() {
 		*timeout,
 		kubeClient,
 		driverName)
-	if err != nil {
+	if err != nil && errors.Is(err, resizer.ResizeNotSupportErr) {
+		klog.InfoS("Resize not supported", "message", err)
+	} else if err != nil {
 		klog.ErrorS(err, "Failed to create CSI resizer")
 		klog.FlushAndExit(klog.ExitFlushTimeout, 1)
 	}
@@ -219,11 +222,17 @@ func main() {
 		informerFactory,
 		*extraModifyMetadata,
 		driverName)
-	if err != nil {
+	if err != nil && errors.Is(err, modifier.ModifyNotSupportErr) {
+		klog.InfoS("Modify not supported", "message", err)
+	} else if err != nil {
 		klog.ErrorS(err, "Failed to create CSI modifier")
 		klog.FlushAndExit(klog.ExitFlushTimeout, 1)
 	}
 
+	if csiResizer == nil && csiModifier == nil {
+		klog.Fatalf("CSI driver does not support resize nor modify")
+	}
+
 	// Start HTTP server for metrics + leader election healthz
 	if addr != "" {
 		metricsManager.RegisterToServer(mux, *metricsPath)
@@ -238,17 +247,30 @@ func main() {
 		}()
 	}
 
-	resizerName := csiResizer.Name()
-	rc := controller.NewResizeController(resizerName, csiResizer, kubeClient, *resyncPeriod, informerFactory,
-		workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax),
-		*handleVolumeInUseError, *retryIntervalMax)
+	leaseHolder := ""
+	var rc controller.ResizeController
+	if csiResizer != nil {
+		resizerName := csiResizer.Name()
+		rc = controller.NewResizeController(resizerName, csiResizer, kubeClient, *resyncPeriod, informerFactory,
+			workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax),
+			*handleVolumeInUseError, *retryIntervalMax)
+
+		leaseHolder = resizerName
+	}
 
-	modifierName := csiModifier.Name()
 	var mc modifycontroller.ModifyController
-	// Add modify controller only if the feature gate is enabled
-	if utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
-		mc = modifycontroller.NewModifyController(modifierName, csiModifier, kubeClient, *resyncPeriod, *retryIntervalMax, *extraModifyMetadata, informerFactory,
-			workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax))
+	if csiModifier != nil {
+		modifierName := csiModifier.Name()
+		// Add modify controller only if the feature gate is enabled
+		if utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
+			mc = modifycontroller.NewModifyController(modifierName, csiModifier, kubeClient, *resyncPeriod,
+				*retryIntervalMax, *extraModifyMetadata, informerFactory,
+				workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax))
+		}
+
+		if leaseHolder == "" {
+			leaseHolder = modifierName
+		}
 	}
 
 	// handle SIGTERM and SIGINT by cancelling the context.
@@ -278,16 +300,20 @@ func main() {
 		informerFactory.Start(ctx.Done())
 		if utilfeature.DefaultFeatureGate.Enabled(features.ReleaseLeaderElectionOnExit) {
 			var wg sync.WaitGroup
-			go rc.Run(*workers, controllerCtx, &wg)
-			if utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
+			if rc != nil {
+				go rc.Run(*workers, controllerCtx, &wg)
+			}
+			if mc != nil && utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
 				go mc.Run(*workers, controllerCtx, &wg)
 			}
 			<-controllerCtx.Done()
 			wg.Wait()
 			terminate()
 		} else {
-			go rc.Run(*workers, ctx, nil)
-			if utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
+			if rc != nil {
+				go rc.Run(*workers, ctx, nil)
+			}
+			if mc != nil && utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
 				go mc.Run(*workers, ctx, nil)
 			}
 			<-ctx.Done()
@@ -297,7 +323,7 @@ func main() {
 	if !*enableLeaderElection {
 		run(ctx)
 	} else {
-		lockName := "external-resizer-" + util.SanitizeName(resizerName)
+		lockName := "external-resizer-" + util.SanitizeName(leaseHolder)
 		leKubeClient, err := kubernetes.NewForConfig(config)
 		if err != nil {
 			klog.ErrorS(err, "Failed to create leKubeClient")

pkg/modifier/csi_modifier.go

@@ -28,6 +28,8 @@ import (
 	"k8s.io/client-go/kubernetes"
 )
 
+var ModifyNotSupportErr = errors.New("CSI driver does not support controller modify")
+
 func NewModifierFromClient(
 	csiClient csi.Client,
 	timeout time.Duration,
@@ -36,10 +38,13 @@ func NewModifierFromClient(
 	extraModifyMetadata bool,
 	driverName string) (Modifier, error) {
 
-	_, err := supportsControllerModify(csiClient, timeout)
+	supported, err := supportsControllerModify(csiClient, timeout)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check if plugin supports controller modify: %v", err)
 	}
+	if !supported {
+		return nil, ModifyNotSupportErr
+	}
 
 	return &csiModifier{
 		name:                driverName,

pkg/modifier/csi_modifier_test.go

@@ -26,6 +26,7 @@ func TestNewModifier(t *testing.T) {
 		// Controller modify not supported.
 		{
 			SupportsControllerModify: false,
+			Error:                    ModifyNotSupportErr,
 		},
 	} {
 		client := csi.NewMockClient("mock", false, false, c.SupportsControllerModify, false, false)

pkg/modifycontroller/controller_test.go

@@ -64,7 +64,7 @@ func TestController(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			// Setup
-			client := csi.NewMockClient(testDriverName, true, true, true, true, true)
+			client := csi.NewMockClient(testDriverName, false, false, true, true, true)
 
 			initialObjects := []runtime.Object{test.pvc, test.pv, testVacObject, targetVacObject}
 			ctrlInstance := setupFakeK8sEnvironment(t, client, initialObjects)

pkg/resizer/csi_resizer.go

@@ -38,7 +38,7 @@ import (
 
 var (
 	controllerServiceNotSupportErr = errors.New("CSI driver does not support controller service")
-	resizeNotSupportErr            = errors.New("CSI driver neither supports controller resize nor node resize")
+	ResizeNotSupportErr            = errors.New("CSI driver neither supports controller resize nor node resize")
 )
 
 func NewResizerFromClient(
@@ -70,7 +70,7 @@ func NewResizerFromClient(
 			klog.InfoS("The CSI driver supports node resize only, using trivial resizer to handle resize requests")
 			return newTrivialResizer(driverName), nil
 		}
-		return nil, resizeNotSupportErr
+		return nil, ResizeNotSupportErr
 	}
 
 	_, err = supportsControllerSingleNodeMultiWriter(csiClient, timeout)

pkg/resizer/csi_resizer_test.go

@@ -69,7 +69,7 @@ func TestNewResizer(t *testing.T) {
 			SupportsPluginControllerService:         true,
 			SupportsControllerSingleNodeMultiWriter: true,
 
-			Error: resizeNotSupportErr,
+			Error: ResizeNotSupportErr,
 		},
 	} {
 		client := csi.NewMockClient("mock", c.SupportsNodeResize, c.SupportsControllerResize, false, c.SupportsPluginControllerService, c.SupportsControllerSingleNodeMultiWriter)