Merge pull request #1408 from grant-he/master

Address various linter (staticcheck, modernize, etc.) comments.

Author: k8s-ci-robot

cmd/csi-provisioner/csi-provisioner.go

@@ -392,18 +392,19 @@ func main() {
 
 	// -------------------------------
 	// PersistentVolumeClaims informer
-	rateLimiter := workqueue.NewItemExponentialFailureRateLimiter(*retryIntervalStart, *retryIntervalMax)
-	claimQueue := workqueue.NewNamedRateLimitingQueue(rateLimiter, "claims")
+	genericRateLimiter := workqueue.NewTypedItemExponentialFailureRateLimiter[any](*retryIntervalStart, *retryIntervalMax)
+	claimRateLimiter := workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax)
+	claimQueue := workqueue.NewTypedRateLimitingQueueWithConfig(claimRateLimiter, workqueue.TypedRateLimitingQueueConfig[string]{Name: "claims"})
 	claimInformer := factory.Core().V1().PersistentVolumeClaims().Informer()
 
 	// Setup options
 	provisionerOptions := []func(*controller.ProvisionController) error{
 		controller.LeaderElection(false), // Always disable leader election in provisioner lib. Leader election should be done here in the CSI provisioner level instead.
 		controller.FailedProvisionThreshold(0),
 		controller.FailedDeleteThreshold(0),
-		controller.RateLimiter(rateLimiter),
+		controller.RateLimiter(genericRateLimiter),
 		controller.Threadiness(int(*workerThreads)),
-		controller.CreateProvisionedPVLimiter(workqueue.DefaultControllerRateLimiter()),
+		controller.CreateProvisionedPVLimiter(workqueue.DefaultTypedControllerRateLimiter[any]()),
 		controller.ClaimsInformer(claimInformer),
 		controller.NodesLister(nodeLister),
 		controller.RetryIntervalMax(*retryIntervalMax),
@@ -483,12 +484,13 @@ func main() {
 
 		var topologyInformer topology.Informer
 		if nodeDeployment == nil {
+			topologyRateLimiter := workqueue.NewTypedItemExponentialFailureRateLimiter[string](*retryIntervalStart, *retryIntervalMax)
 			topologyInformer = topology.NewNodeTopology(
 				provisionerName,
 				clientset,
 				factory.Core().V1().Nodes(),
 				factory.Storage().V1().CSINodes(),
-				workqueue.NewNamedRateLimitingQueue(rateLimiter, "csitopology"),
+				workqueue.NewTypedRateLimitingQueueWithConfig(topologyRateLimiter, workqueue.TypedRateLimitingQueueConfig[string]{Name: "csitopology"}),
 			)
 		} else {
 			var segment topology.Segment
@@ -548,12 +550,13 @@ func main() {
 			klog.Fatalf("unexpected error when checking for the V1 CSIStorageCapacity API: %v", err)
 		}
 
+		capacityRateLimiter := workqueue.NewTypedItemExponentialFailureRateLimiter[capacity.QueueKey](*retryIntervalStart, *retryIntervalMax)
 		capacityController = capacity.NewCentralCapacityController(
 			csi.NewControllerClient(grpcClient),
 			provisionerName,
 			clientFactory,
 			// Metrics for the queue is available in the default registry.
-			workqueue.NewNamedRateLimitingQueue(rateLimiter, "csistoragecapacity"),
+			workqueue.NewTypedRateLimitingQueueWithConfig(capacityRateLimiter, workqueue.TypedRateLimitingQueueConfig[capacity.QueueKey]{Name: "csistoragecapacity"}),
 			controller,
 			managedByID,
 			namespace,

cmd/csi-provisioner/util_test.go

@@ -38,7 +38,7 @@ func TestGetNameWithMaxLength(t *testing.T) {
 			base:     externalProvisioner,
 		},
 		"with empty base": {
-			expected: fmt.Sprintf("%s", "node01"),
+			expected: "node01",
 			nodeName: "node01",
 			base:     "",
 		},
@@ -70,7 +70,7 @@ func TestGetNameWithMaxLength(t *testing.T) {
 			base:     externalProvisioner,
 		},
 		"long node name ,with empty base": {
-			expected: fmt.Sprintf("%s", "fa65587e"),
+			expected: "fa65587e",
 			nodeName: fmt.Sprintf("node%s", strings.Repeat("a", 63)),
 			base:     "",
 		},

pkg/capacity/apibridge.go

@@ -117,15 +117,15 @@ var _ cache.SharedIndexInformer = csiStorageCapacityIndexInformerBridge{}
 
 func (iib csiStorageCapacityIndexInformerBridge) AddEventHandler(handlerv1 cache.ResourceEventHandler) (cache.ResourceEventHandlerRegistration, error) {
 	handlerv1beta1 := cache.ResourceEventHandlerFuncs{
-		AddFunc: func(obj interface{}) {
+		AddFunc: func(obj any) {
 			csc, ok := obj.(*storagev1beta1.CSIStorageCapacity)
 			if !ok {
 				klog.Errorf("added object: expected v1beta1.CSIStorageCapacity, got %T -> ignoring it", obj)
 				return
 			}
 			handlerv1.OnAdd(v1beta1Tov1(csc), iib.HasSynced())
 		},
-		UpdateFunc: func(oldObj interface{}, newObj interface{}) {
+		UpdateFunc: func(oldObj any, newObj any) {
 			oldCsc, ok := oldObj.(*storagev1beta1.CSIStorageCapacity)
 			if !ok {
 				klog.Errorf("updated object: expected v1beta1.CSIStorageCapacity, got %T -> ignoring it", oldObj)
@@ -138,7 +138,7 @@ func (iib csiStorageCapacityIndexInformerBridge) AddEventHandler(handlerv1 cache
 			}
 			handlerv1.OnUpdate(v1beta1Tov1(oldCsc), v1beta1Tov1(newCsc))
 		},
-		DeleteFunc: func(obj interface{}) {
+		DeleteFunc: func(obj any) {
 			// Beware of "xxx deleted" events
 			if unknown, ok := obj.(cache.DeletedFinalStateUnknown); ok && unknown.Obj != nil {
 				obj = unknown.Obj

pkg/capacity/capacity.go

@@ -79,7 +79,7 @@ type Controller struct {
 	csiController    CSICapacityClient
 	driverName       string
 	clientFactory    CSIStorageCapacityFactory
-	queue            workqueue.RateLimitingInterface
+	queue            workqueue.TypedRateLimitingInterface[QueueKey]
 	owner            *metav1.OwnerReference
 	managedByID      string
 	ownerNamespace   string
@@ -95,29 +95,28 @@ type Controller struct {
 	// have a non-nil pointer. Those get added and updated
 	// exclusively through the informer event handler to avoid
 	// races.
-	capacities     map[workItem]*storagev1.CSIStorageCapacity
+	capacities     map[WorkItem]*storagev1.CSIStorageCapacity
 	capacitiesLock sync.Mutex
 }
 
-type workItem struct {
+type WorkItem struct {
 	segment          *topology.Segment
 	storageClassName string
 }
 
-func (w workItem) equals(capacity *storagev1.CSIStorageCapacity) bool {
+func (w WorkItem) equals(capacity *storagev1.CSIStorageCapacity) bool {
 	return w.storageClassName == capacity.StorageClassName &&
 		reflect.DeepEqual(w.segment.GetLabelSelector(), capacity.NodeTopology)
 }
 
-var (
-	// Defines parameters for ExponentialBackoff used while starting up
-	// and listing CSIStorageCapacity objects.
-	listCSIStorageCapacityBackoff = wait.Backoff{
-		Duration: time.Second * 5,
-		Factor:   1.1,
-		Steps:    10,
-	}
+type QueueKey struct {
+	// item is for sync/create/update of a CSIStorageCapacity object.
+	item *WorkItem
+	// capacity is for deleting an obsolete CSIStorageCapacity object.
+	capacity *storagev1.CSIStorageCapacity
+}
 
+var (
 	objectsGoalDesc = metrics.NewDesc(
 		"csistoragecapacities_desired_goal",
 		"Number of CSIStorageCapacity objects that are supposed to be managed automatically.",
@@ -165,7 +164,7 @@ func NewCentralCapacityController(
 	csiController CSICapacityClient,
 	driverName string,
 	clientFactory CSIStorageCapacityFactory,
-	queue workqueue.RateLimitingInterface,
+	queue workqueue.TypedRateLimitingInterface[QueueKey],
 	owner *metav1.OwnerReference,
 	managedByID string,
 	ownerNamespace string,
@@ -190,29 +189,29 @@ func NewCentralCapacityController(
 		pollPeriod:       pollPeriod,
 		immediateBinding: immediateBinding,
 		timeout:          timeout,
-		capacities:       map[workItem]*storagev1.CSIStorageCapacity{},
+		capacities:       map[WorkItem]*storagev1.CSIStorageCapacity{},
 	}
 
 	// Now register for changes. Depending on the implementation of the informers,
 	// this may already invoke callbacks.
 	handler := cache.ResourceEventHandlerFuncs{
-		AddFunc: func(obj interface{}) {
+		AddFunc: func(obj any) {
 			sc, ok := obj.(*storagev1.StorageClass)
 			if !ok {
 				klog.Errorf("added object: expected StorageClass, got %T -> ignoring it", obj)
 				return
 			}
 			c.onSCAddOrUpdate(sc)
 		},
-		UpdateFunc: func(_ interface{}, newObj interface{}) {
+		UpdateFunc: func(_ any, newObj any) {
 			sc, ok := newObj.(*storagev1.StorageClass)
 			if !ok {
 				klog.Errorf("updated object: expected StorageClass, got %T -> ignoring it", newObj)
 				return
 			}
 			c.onSCAddOrUpdate(sc)
 		},
-		DeleteFunc: func(obj interface{}) {
+		DeleteFunc: func(obj any) {
 			// Beware of "xxx deleted" events
 			if unknown, ok := obj.(cache.DeletedFinalStateUnknown); ok && unknown.Obj != nil {
 				obj = unknown.Obj
@@ -244,7 +243,7 @@ func (c *Controller) Run(ctx context.Context, threadiness int) {
 	defer c.queue.ShutDown()
 
 	c.prepare(ctx)
-	for i := 0; i < threadiness; i++ {
+	for range threadiness {
 		go wait.UntilWithContext(ctx, func(ctx context.Context) {
 			c.runWorker(ctx)
 		}, time.Second)
@@ -289,23 +288,23 @@ func (c *Controller) prepare(ctx context.Context) {
 	// for all objects immediately when adding it.
 	klog.V(3).Info("Checking for existing CSIStorageCapacity objects")
 	handler := cache.ResourceEventHandlerFuncs{
-		AddFunc: func(obj interface{}) {
+		AddFunc: func(obj any) {
 			csc, ok := obj.(*storagev1.CSIStorageCapacity)
 			if !ok {
 				klog.Errorf("added object: expected CSIStorageCapacity, got %T -> ignoring it", obj)
 				return
 			}
 			c.onCAddOrUpdate(ctx, csc)
 		},
-		UpdateFunc: func(_ interface{}, newObj interface{}) {
+		UpdateFunc: func(_ any, newObj any) {
 			csc, ok := newObj.(*storagev1.CSIStorageCapacity)
 			if !ok {
 				klog.Errorf("updated object: expected CSIStorageCapacity, got %T -> ignoring it", newObj)
 				return
 			}
 			c.onCAddOrUpdate(ctx, csc)
 		},
-		DeleteFunc: func(obj interface{}) {
+		DeleteFunc: func(obj any) {
 			// Beware of "xxx deleted" events
 			if unknown, ok := obj.(cache.DeletedFinalStateUnknown); ok && unknown.Obj != nil {
 				obj = unknown.Obj
@@ -422,7 +421,7 @@ func (c *Controller) refreshTopology(nodeAffinity v1.VolumeNodeAffinity) {
 		for item := range c.capacities {
 			if item.segment.Compare(segment) == 0 {
 				klog.V(5).Infof("Capacity Controller: skipping refresh: enqueuing %+v because of the topology", item)
-				c.queue.Add(item)
+				c.queue.Add(QueueKey{item: &item})
 			}
 		}
 	}
@@ -457,15 +456,15 @@ func (c *Controller) refreshSC(storageClassName string) {
 	for item := range c.capacities {
 		if item.storageClassName == storageClassName {
 			klog.V(5).Infof("Capacity Controller: enqueuing %+v because of the storage class", item)
-			c.queue.Add(item)
+			c.queue.Add(QueueKey{item: &item})
 		}
 	}
 }
 
 // addWorkItem ensures that there is an item in c.capacities. It
 // must be called while holding c.capacitiesLock!
 func (c *Controller) addWorkItem(segment *topology.Segment, sc *storagev1.StorageClass) {
-	item := workItem{
+	item := WorkItem{
 		segment:          segment,
 		storageClassName: sc.Name,
 	}
@@ -478,13 +477,13 @@ func (c *Controller) addWorkItem(segment *topology.Segment, sc *storagev1.Storag
 	// ... and then tell our workers to update
 	// or create that capacity object.
 	klog.V(5).Infof("Capacity Controller: enqueuing %+v", item)
-	c.queue.Add(item)
+	c.queue.Add(QueueKey{item: &item})
 }
 
 // removeWorkItem ensures that the item gets removed from c.capacities. It
 // must be called while holding c.capacitiesLock!
 func (c *Controller) removeWorkItem(segment *topology.Segment, sc *storagev1.StorageClass) {
-	item := workItem{
+	item := WorkItem{
 		segment:          segment,
 		storageClassName: sc.Name,
 	}
@@ -506,7 +505,7 @@ func (c *Controller) removeWorkItem(segment *topology.Segment, sc *storagev1.Sto
 
 	// Any capacity object in the queue will be deleted.
 	klog.V(5).Infof("Capacity Controller: enqueuing CSIStorageCapacity %s for removal", capacity.Name)
-	c.queue.Add(capacity)
+	c.queue.Add(QueueKey{capacity: capacity})
 }
 
 // pollCapacities must be called periodically to detect when the underlying storage capacity has changed.
@@ -516,7 +515,7 @@ func (c *Controller) pollCapacities() {
 
 	for item := range c.capacities {
 		klog.V(5).Infof("Capacity Controller: enqueuing %+v for periodic update", item)
-		c.queue.Add(item)
+		c.queue.Add(QueueKey{item: &item})
 	}
 }
 
@@ -535,11 +534,11 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 	err := func() error {
 		defer c.queue.Done(obj)
 
-		switch obj := obj.(type) {
-		case workItem:
-			return c.syncCapacity(ctx, obj)
-		case *storagev1.CSIStorageCapacity:
-			return c.deleteCapacity(ctx, obj)
+		switch {
+		case obj.item != nil:
+			return c.syncCapacity(ctx, *obj.item)
+		case obj.capacity != nil:
+			return c.deleteCapacity(ctx, obj.capacity)
 		default:
 			klog.Warningf("unexpected work item %#v", obj)
 		}
@@ -559,7 +558,7 @@ func (c *Controller) processNextWorkItem(ctx context.Context) bool {
 }
 
 // syncCapacity gets the capacity and then updates or creates the object.
-func (c *Controller) syncCapacity(ctx context.Context, item workItem) error {
+func (c *Controller) syncCapacity(ctx context.Context, item WorkItem) error {
 	// We lock only while accessing c.capacities, but not during
 	// the potentially long-running operations. That is okay
 	// because there is only a single worker per item. In the
@@ -682,7 +681,7 @@ func (c *Controller) deleteCapacity(ctx context.Context, capacity *storagev1.CSI
 // and either remembers the pointer to it for future updates or
 // ensures that it gets deleted if no longer needed. Foreign objects
 // are ignored.
-func (c *Controller) onCAddOrUpdate(ctx context.Context, capacity *storagev1.CSIStorageCapacity) {
+func (c *Controller) onCAddOrUpdate(_ context.Context, capacity *storagev1.CSIStorageCapacity) {
 	if !c.isManaged(capacity) {
 		// Not ours (anymore?). For the unlikely case that someone removed our owner reference,
 		// we also must remove our reference to the object.
@@ -692,7 +691,7 @@ func (c *Controller) onCAddOrUpdate(ctx context.Context, capacity *storagev1.CSI
 			if capacity2 != nil && capacity2.UID == capacity.UID {
 				c.capacities[item] = nil
 				klog.V(5).Infof("Capacity Controller: CSIStorageCapacity %s owner was modified by someone, enqueueing %v for re-creation", capacity.Name, item)
-				c.queue.Add(item)
+				c.queue.Add(QueueKey{item: &item})
 			}
 		}
 		return
@@ -720,10 +719,10 @@ func (c *Controller) onCAddOrUpdate(ctx context.Context, capacity *storagev1.CSI
 	}
 	// The CSIStorageCapacity object is obsolete, delete it.
 	klog.V(5).Infof("Capacity Controller: CSIStorageCapacity %s with resource version %s is obsolete, enqueue for removal", capacity.Name, capacity.ResourceVersion)
-	c.queue.Add(capacity)
+	c.queue.Add(QueueKey{capacity: capacity})
 }
 
-func (c *Controller) onCDelete(ctx context.Context, capacity *storagev1.CSIStorageCapacity) {
+func (c *Controller) onCDelete(_ context.Context, capacity *storagev1.CSIStorageCapacity) {
 	c.capacitiesLock.Lock()
 	defer c.capacitiesLock.Unlock()
 	for item, capacity2 := range c.capacities {
@@ -732,7 +731,7 @@ func (c *Controller) onCDelete(ctx context.Context, capacity *storagev1.CSIStora
 			// Re-create it...
 			klog.V(5).Infof("Capacity Controller: CSIStorageCapacity %s was removed by someone, enqueue %v for re-creation", capacity.Name, item)
 			c.capacities[item] = nil
-			c.queue.Add(item)
+			c.queue.Add(QueueKey{item: &item})
 			return
 		}
 	}
@@ -806,7 +805,7 @@ func (c *Controller) getObjectsObsolete() int64 {
 }
 
 func (c *Controller) isObsolete(capacity *storagev1.CSIStorageCapacity) bool {
-	for item, _ := range c.capacities {
+	for item := range c.capacities {
 		if item.equals(capacity) {
 			return false
 		}