removing deprecated flags

Author: YahiaBadr

cluster-autoscaler/config/autoscaling_options.go

@@ -104,8 +104,6 @@ type AutoscalingOptions struct {
 	// NodeGroupDefaults are default values for per NodeGroup options.
 	// They will be used any time a specific value is not provided for a given NodeGroup.
 	NodeGroupDefaults NodeGroupAutoscalingOptions
-	// MaxEmptyBulkDelete is a number of empty nodes that can be removed at the same time.
-	MaxEmptyBulkDelete int
 	// MaxNodesTotal sets the maximum number of nodes in the whole cluster
 	MaxNodesTotal int
 	// MaxCoresTotal sets the maximum number of cores in the whole cluster
@@ -198,10 +196,6 @@ type AutoscalingOptions struct {
 	ConfigNamespace string
 	// ClusterName if available
 	ClusterName string
-	// NodeAutoprovisioningEnabled tells whether the node auto-provisioning is enabled for this cluster.
-	NodeAutoprovisioningEnabled bool
-	// MaxAutoprovisionedNodeGroupCount is the maximum number of autoprovisioned groups in the cluster.
-	MaxAutoprovisionedNodeGroupCount int
 	// UnremovableNodeRecheckTimeout is the timeout before we check again a node that couldn't be removed before
 	UnremovableNodeRecheckTimeout time.Duration
 	// Pods with priority below cutoff are expendable. They can be killed without any consideration during scale down and they don't cause scale-up.

cluster-autoscaler/config/flags/flags.go

@@ -28,7 +28,6 @@ import (
 	cloudBuilder "k8s.io/autoscaler/cluster-autoscaler/cloudprovider/builder"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/gce/localssdsize"
 	"k8s.io/autoscaler/cluster-autoscaler/config"
-	"k8s.io/autoscaler/cluster-autoscaler/core/scaledown/actuation"
 	"k8s.io/autoscaler/cluster-autoscaler/estimator"
 	"k8s.io/autoscaler/cluster-autoscaler/expander"
 	scheduler_util "k8s.io/autoscaler/cluster-autoscaler/utils/scheduler"
@@ -228,11 +227,7 @@ var (
 	checkCapacityProcessorInstance               = flag.String("check-capacity-processor-instance", "", "Name of the processor instance. Only ProvisioningRequests that define this name in their parameters with the key \"processorInstance\" will be processed by this CA instance. It only refers to check capacity ProvisioningRequests, but if not empty, best-effort atomic ProvisioningRequests processing is disabled in this instance. Not recommended: Until CA 1.35, ProvisioningRequests with this name as prefix in their class will be also processed.")
 
 	// Deprecated flags
-	_                                = flag.Bool("gce-expander-ephemeral-storage-support", true, "Whether scale-up takes ephemeral storage resources into account for GCE cloud provider (Deprecated, to be removed in 1.30+)")
-	ignoreTaintsFlag                 = multiStringFlag("ignore-taint", "Specifies a taint to ignore in node templates when considering to scale a node group (Deprecated, use startup-taints instead)")
-	maxAutoprovisionedNodeGroupCount = flag.Int("max-autoprovisioned-node-group-count", 15, "The maximum number of autoprovisioned groups in the cluster.This flag is deprecated and will be removed in future releases.")
-	maxEmptyBulkDeleteFlag           = flag.Int("max-empty-bulk-delete", 10, "Maximum number of empty nodes that can be deleted at the same time. DEPRECATED: Use --max-scale-down-parallelism instead.")
-	nodeAutoprovisioningEnabled      = flag.Bool("node-autoprovisioning-enabled", false, "Should CA autoprovision node groups when needed.This flag is deprecated and will be removed in future releases.")
+	ignoreTaintsFlag = multiStringFlag("ignore-taint", "Specifies a taint to ignore in node templates when considering to scale a node group (Deprecated, use startup-taints instead)")
 )
 
 var autoscalingOptions *config.AutoscalingOptions
@@ -264,24 +259,6 @@ func createAutoscalingOptions() config.AutoscalingOptions {
 		klog.Fatalf("Failed to parse flags: %v", err)
 	}
 
-	// in order to avoid inconsistent deletion thresholds for the legacy planner and the new actuator, the max-empty-bulk-delete,
-	// and max-scale-down-parallelism flags must be set to the same value.
-	if isFlagPassed("max-empty-bulk-delete") && !isFlagPassed("max-scale-down-parallelism") {
-		*maxScaleDownParallelismFlag = *maxEmptyBulkDeleteFlag
-		klog.Warning("The max-empty-bulk-delete flag will be deprecated in k8s version 1.29. Please use max-scale-down-parallelism instead.")
-		klog.Infof("Setting max-scale-down-parallelism to %d, based on the max-empty-bulk-delete value %d", *maxScaleDownParallelismFlag, *maxEmptyBulkDeleteFlag)
-	} else if !isFlagPassed("max-empty-bulk-delete") && isFlagPassed("max-scale-down-parallelism") {
-		*maxEmptyBulkDeleteFlag = *maxScaleDownParallelismFlag
-	}
-
-	if isFlagPassed("node-autoprovisioning-enabled") {
-		klog.Warning("The node-autoprovisioning-enabled flag is deprecated and will be removed in k8s version 1.31.")
-	}
-
-	if isFlagPassed("max-autoprovisioned-node-group-count") {
-		klog.Warning("The max-autoprovisioned-node-group-count flag is deprecated and will be removed in k8s version 1.31.")
-	}
-
 	var parsedSchedConfig *scheduler_config.KubeSchedulerConfiguration
 	// if scheduler config flag was set by the user
 	if pflag.CommandLine.Changed(config.SchedulerConfigFileFlag) {
@@ -297,7 +274,7 @@ func createAutoscalingOptions() config.AutoscalingOptions {
 
 	var drainPriorityConfigMap []kubelet_config.ShutdownGracePeriodByPodPriority
 	if isFlagPassed("drain-priority-config") {
-		drainPriorityConfigMap = actuation.ParseShutdownGracePeriodsAndPriorities(*drainPriorityConfig)
+		drainPriorityConfigMap = parseShutdownGracePeriodsAndPriorities(*drainPriorityConfig)
 		if len(drainPriorityConfigMap) == 0 {
 			klog.Fatalf("Invalid configuration, parsing --drain-priority-config")
 		}
@@ -326,7 +303,6 @@ func createAutoscalingOptions() config.AutoscalingOptions {
 		IgnoreMirrorPodsUtilization:      *ignoreMirrorPodsUtilization,
 		MaxBulkSoftTaintCount:            *maxBulkSoftTaintCount,
 		MaxBulkSoftTaintTime:             *maxBulkSoftTaintTime,
-		MaxEmptyBulkDelete:               *maxEmptyBulkDeleteFlag,
 		MaxGracefulTerminationSec:        *maxGracefulTerminationFlag,
 		MaxPodEvictionTime:               *maxPodEvictionTime,
 		MaxNodesTotal:                    *maxNodesTotal,
@@ -353,8 +329,6 @@ func createAutoscalingOptions() config.AutoscalingOptions {
 		BalanceSimilarNodeGroups:         *balanceSimilarNodeGroupsFlag,
 		ConfigNamespace:                  *namespace,
 		ClusterName:                      *clusterName,
-		NodeAutoprovisioningEnabled:      *nodeAutoprovisioningEnabled,
-		MaxAutoprovisionedNodeGroupCount: *maxAutoprovisionedNodeGroupCount,
 		UnremovableNodeRecheckTimeout:    *unremovableNodeRecheckTimeout,
 		ExpendablePodsPriorityCutoff:     *expendablePodsPriorityCutoff,
 		Regional:                         *regional,
@@ -523,3 +497,36 @@ func parseSingleGpuLimit(limits string) (config.GpuLimits, error) {
 	}
 	return parsedGpuLimits, nil
 }
+
+// parseShutdownGracePeriodsAndPriorities parse priorityGracePeriodStr and returns an array of ShutdownGracePeriodByPodPriority if succeeded.
+// Otherwise, returns an empty list
+func parseShutdownGracePeriodsAndPriorities(priorityGracePeriodStr string) []kubelet_config.ShutdownGracePeriodByPodPriority {
+	var priorityGracePeriodMap, emptyMap []kubelet_config.ShutdownGracePeriodByPodPriority
+
+	if priorityGracePeriodStr == "" {
+		return emptyMap
+	}
+	priorityGracePeriodStrArr := strings.Split(priorityGracePeriodStr, ",")
+	for _, item := range priorityGracePeriodStrArr {
+		priorityAndPeriod := strings.Split(item, ":")
+		if len(priorityAndPeriod) != 2 {
+			klog.Errorf("Parsing shutdown grace periods failed because '%s' is not a priority and grace period couple separated by ':'", item)
+			return emptyMap
+		}
+		priority, err := strconv.Atoi(priorityAndPeriod[0])
+		if err != nil {
+			klog.Errorf("Parsing shutdown grace periods and priorities failed: %v", err)
+			return emptyMap
+		}
+		shutDownGracePeriod, err := strconv.Atoi(priorityAndPeriod[1])
+		if err != nil {
+			klog.Errorf("Parsing shutdown grace periods and priorities failed: %v", err)
+			return emptyMap
+		}
+		priorityGracePeriodMap = append(priorityGracePeriodMap, kubelet_config.ShutdownGracePeriodByPodPriority{
+			Priority:                   int32(priority),
+			ShutdownGracePeriodSeconds: int64(shutDownGracePeriod),
+		})
+	}
+	return priorityGracePeriodMap
+}

cluster-autoscaler/config/flags/flags_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"k8s.io/autoscaler/cluster-autoscaler/config"
+	kubelet_config "k8s.io/kubernetes/pkg/kubelet/apis/config"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -91,3 +92,57 @@ func TestParseSingleGpuLimit(t *testing.T) {
 		}
 	}
 }
+
+func TestParseShutdownGracePeriodsAndPriorities(t *testing.T) {
+	testCases := []struct {
+		name  string
+		input string
+		want  []kubelet_config.ShutdownGracePeriodByPodPriority
+	}{
+		{
+			name:  "empty input",
+			input: "",
+			want:  nil,
+		},
+		{
+			name:  "Incorrect string - incorrect priority grace period pairs",
+			input: "1:2,34",
+			want:  nil,
+		},
+		{
+			name:  "Incorrect string - trailing ,",
+			input: "1:2, 3:4,",
+			want:  nil,
+		},
+		{
+			name:  "Incorrect string - trailing space",
+			input: "1:2,3:4 ",
+			want:  nil,
+		},
+		{
+			name:  "Non integers - 1",
+			input: "1:2,3:a",
+			want:  nil,
+		},
+		{
+			name:  "Non integers - 2",
+			input: "1:2,3:23.2",
+			want:  nil,
+		},
+		{
+			name:  "parsable input",
+			input: "1:2,3:4",
+			want: []kubelet_config.ShutdownGracePeriodByPodPriority{
+				{1, 2},
+				{3, 4},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			shutdownGracePeriodByPodPriority := parseShutdownGracePeriodsAndPriorities(tc.input)
+			assert.Equal(t, tc.want, shutdownGracePeriodByPodPriority)
+		})
+	}
+}

cluster-autoscaler/core/scaledown/actuation/priority.go

@@ -19,11 +19,8 @@ package actuation
 import (
 	"math"
 	"sort"
-	"strconv"
-	"strings"
 
 	apiv1 "k8s.io/api/core/v1"
-	"k8s.io/klog/v2"
 	kubelet_config "k8s.io/kubernetes/pkg/kubelet/apis/config"
 )
 
@@ -73,39 +70,6 @@ func groupIndex(pod *apiv1.Pod, groups []podEvictionGroup) int {
 	return index
 }
 
-// ParseShutdownGracePeriodsAndPriorities parse priorityGracePeriodStr and returns an array of ShutdownGracePeriodByPodPriority if succeeded.
-// Otherwise, returns an empty list
-func ParseShutdownGracePeriodsAndPriorities(priorityGracePeriodStr string) []kubelet_config.ShutdownGracePeriodByPodPriority {
-	var priorityGracePeriodMap, emptyMap []kubelet_config.ShutdownGracePeriodByPodPriority
-
-	if priorityGracePeriodStr == "" {
-		return emptyMap
-	}
-	priorityGracePeriodStrArr := strings.Split(priorityGracePeriodStr, ",")
-	for _, item := range priorityGracePeriodStrArr {
-		priorityAndPeriod := strings.Split(item, ":")
-		if len(priorityAndPeriod) != 2 {
-			klog.Errorf("Parsing shutdown grace periods failed because '%s' is not a priority and grace period couple separated by ':'", item)
-			return emptyMap
-		}
-		priority, err := strconv.Atoi(priorityAndPeriod[0])
-		if err != nil {
-			klog.Errorf("Parsing shutdown grace periods and priorities failed: %v", err)
-			return emptyMap
-		}
-		shutDownGracePeriod, err := strconv.Atoi(priorityAndPeriod[1])
-		if err != nil {
-			klog.Errorf("Parsing shutdown grace periods and priorities failed: %v", err)
-			return emptyMap
-		}
-		priorityGracePeriodMap = append(priorityGracePeriodMap, kubelet_config.ShutdownGracePeriodByPodPriority{
-			Priority:                   int32(priority),
-			ShutdownGracePeriodSeconds: int64(shutDownGracePeriod),
-		})
-	}
-	return priorityGracePeriodMap
-}
-
 // SingleRuleDrainConfig returns an array of ShutdownGracePeriodByPodPriority with a single ShutdownGracePeriodByPodPriority
 func SingleRuleDrainConfig(shutdownGracePeriodSeconds int) []kubelet_config.ShutdownGracePeriodByPodPriority {
 	return []kubelet_config.ShutdownGracePeriodByPodPriority{

cluster-autoscaler/core/scaledown/actuation/priority_test.go

@@ -183,57 +183,3 @@ func TestGroupByPriority(t *testing.T) {
 	groups := groupByPriority(shutdownGracePeriodByPodPriority, []*apiv1.Pod{p1, p2, p3, p4, p5}, []*apiv1.Pod{p6, p7, p8, p9, p10})
 	assert.Equal(t, wantGroups, groups)
 }
-
-func TestParseShutdownGracePeriodsAndPriorities(t *testing.T) {
-	testCases := []struct {
-		name  string
-		input string
-		want  []kubelet_config.ShutdownGracePeriodByPodPriority
-	}{
-		{
-			name:  "empty input",
-			input: "",
-			want:  nil,
-		},
-		{
-			name:  "Incorrect string - incorrect priority grace period pairs",
-			input: "1:2,34",
-			want:  nil,
-		},
-		{
-			name:  "Incorrect string - trailing ,",
-			input: "1:2, 3:4,",
-			want:  nil,
-		},
-		{
-			name:  "Incorrect string - trailing space",
-			input: "1:2,3:4 ",
-			want:  nil,
-		},
-		{
-			name:  "Non integers - 1",
-			input: "1:2,3:a",
-			want:  nil,
-		},
-		{
-			name:  "Non integers - 2",
-			input: "1:2,3:23.2",
-			want:  nil,
-		},
-		{
-			name:  "parsable input",
-			input: "1:2,3:4",
-			want: []kubelet_config.ShutdownGracePeriodByPodPriority{
-				{1, 2},
-				{3, 4},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			shutdownGracePeriodByPodPriority := ParseShutdownGracePeriodsAndPriorities(tc.input)
-			assert.Equal(t, tc.want, shutdownGracePeriodByPodPriority)
-		})
-	}
-}

cluster-autoscaler/core/scaleup/orchestrator/async_initializer_test.go

@@ -67,8 +67,7 @@ func TestNodePoolAsyncInitialization(t *testing.T) {
 					return nil
 				}, nil)
 			options := config.AutoscalingOptions{
-				NodeAutoprovisioningEnabled: true,
-				AsyncNodeGroupsEnabled:      true,
+				AsyncNodeGroupsEnabled: true,
 			}
 			listers := kube_util.NewListerRegistry(nil, nil, nil, nil, nil, nil, nil, nil, nil)
 			context, err := NewScaleTestAutoscalingContext(options, &fake.Clientset{}, listers, provider, nil, nil)

cluster-autoscaler/core/scaleup/orchestrator/orchestrator_test.go

@@ -826,7 +826,6 @@ func TestNoCreateNodeGroupMaxCoresLimitHit(t *testing.T) {
 	options := defaultOptions
 	options.MaxCoresTotal = 7
 	options.MaxMemoryTotal = 100000
-	options.NodeAutoprovisioningEnabled = true
 
 	largeNode := BuildTestNode("n", 8000, 8000)
 	SetNodeReadyState(largeNode, true, time.Time{})
@@ -1555,11 +1554,9 @@ func TestScaleUpAutoprovisionedNodeGroup(t *testing.T) {
 		}, nil, []string{"T1"}, map[string]*framework.NodeInfo{"T1": ti1})
 
 	options := config.AutoscalingOptions{
-		EstimatorName:                    estimator.BinpackingEstimatorName,
-		MaxCoresTotal:                    5000 * 64,
-		MaxMemoryTotal:                   5000 * 64 * 20,
-		NodeAutoprovisioningEnabled:      true,
-		MaxAutoprovisionedNodeGroupCount: 10,
+		EstimatorName:  estimator.BinpackingEstimatorName,
+		MaxCoresTotal:  5000 * 64,
+		MaxMemoryTotal: 5000 * 64 * 20,
 	}
 	podLister := kube_util.NewTestPodLister([]*apiv1.Pod{})
 	listers := kube_util.NewListerRegistry(nil, nil, podLister, nil, nil, nil, nil, nil, nil)
@@ -1608,12 +1605,10 @@ func TestScaleUpBalanceAutoprovisionedNodeGroups(t *testing.T) {
 		}, nil, []string{"T1"}, map[string]*framework.NodeInfo{"T1": ti1})
 
 	options := config.AutoscalingOptions{
-		BalanceSimilarNodeGroups:         true,
-		EstimatorName:                    estimator.BinpackingEstimatorName,
-		MaxCoresTotal:                    5000 * 64,
-		MaxMemoryTotal:                   5000 * 64 * 20,
-		NodeAutoprovisioningEnabled:      true,
-		MaxAutoprovisionedNodeGroupCount: 10,
+		BalanceSimilarNodeGroups: true,
+		EstimatorName:            estimator.BinpackingEstimatorName,
+		MaxCoresTotal:            5000 * 64,
+		MaxMemoryTotal:           5000 * 64 * 20,
 	}
 	podLister := kube_util.NewTestPodLister([]*apiv1.Pod{})
 	listers := kube_util.NewListerRegistry(nil, nil, podLister, nil, nil, nil, nil, nil, nil)
@@ -1762,8 +1757,7 @@ func TestScaleupAsyncNodeGroupsEnabled(t *testing.T) {
 		}
 
 		options := config.AutoscalingOptions{
-			NodeAutoprovisioningEnabled: true,
-			AsyncNodeGroupsEnabled:      true,
+			AsyncNodeGroupsEnabled: true,
 		}
 		podLister := kube_util.NewTestPodLister([]*apiv1.Pod{})
 		listers := kube_util.NewListerRegistry(nil, nil, podLister, nil, nil, nil, nil, nil, nil)

cluster-autoscaler/core/static_autoscaler_test.go

@@ -807,13 +807,11 @@ func TestStaticAutoscalerRunOnceWithAutoprovisionedEnabled(t *testing.T) {
 			ScaleDownUtilizationThreshold: 0.5,
 			MaxNodeProvisionTime:          10 * time.Second,
 		},
-		EstimatorName:                    estimator.BinpackingEstimatorName,
-		ScaleDownEnabled:                 true,
-		MaxNodesTotal:                    100,
-		MaxCoresTotal:                    100,
-		MaxMemoryTotal:                   100000,
-		NodeAutoprovisioningEnabled:      true,
-		MaxAutoprovisionedNodeGroupCount: 10,
+		EstimatorName:    estimator.BinpackingEstimatorName,
+		ScaleDownEnabled: true,
+		MaxNodesTotal:    100,
+		MaxCoresTotal:    100,
+		MaxMemoryTotal:   100000,
 	}
 	processorCallbacks := newStaticAutoscalerProcessorCallbacks()
 

cluster-autoscaler/core/test/common.go

@@ -248,9 +248,6 @@ func (p *MockAutoprovisioningNodeGroupManager) createNodeGroup(context *context.
 
 // RemoveUnneededNodeGroups removes uneeded node groups
 func (p *MockAutoprovisioningNodeGroupManager) RemoveUnneededNodeGroups(context *context.AutoscalingContext) (removedNodeGroups []cloudprovider.NodeGroup, err error) {
-	if !context.AutoscalingOptions.NodeAutoprovisioningEnabled {
-		return nil, nil
-	}
 	removedNodeGroups = make([]cloudprovider.NodeGroup, 0)
 	nodeGroups := context.CloudProvider.NodeGroups()
 	for _, nodeGroup := range nodeGroups {