Use TypedRateLimitingInterface to replace deprecated RateLimiter

Signed-off-by: Jian Qiu <jqiu@redhat.com>

Author: qiujian16

pkg/basecontroller/factory/base_controller.go

@@ -147,12 +147,7 @@ func (c *baseController) processNextWorkItem(queueCtx context.Context) {
 	defer c.syncContext.Queue().Done(key)
 
 	syncCtx := c.syncContext.(syncContext)
-	var ok bool
-	queueKey, ok := key.(string)
-	if !ok {
-		utilruntime.HandleError(fmt.Errorf("%q controller failed to process key %q (not a string)", c.name, key))
-		return
-	}
+	queueKey := key
 
 	if err := c.sync(queueCtx, syncCtx, queueKey); err != nil {
 		if klog.V(4).Enabled() || key != "key" {

pkg/basecontroller/factory/controller_context.go

@@ -12,19 +12,22 @@ import (
 // syncContext implements SyncContext and provide user access to queue and object that caused
 // the sync to be triggered.
 type syncContext struct {
-	queue workqueue.RateLimitingInterface // nolint:staticcheck // SA1019
+	queue workqueue.TypedRateLimitingInterface[string]
 }
 
 var _ SyncContext = syncContext{}
 
 // NewSyncContext gives new sync context.
 func NewSyncContext(name string) SyncContext {
 	return syncContext{
-		queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), name), // nolint:staticcheck // SA1019
+		queue: workqueue.NewTypedRateLimitingQueueWithConfig(
+			workqueue.DefaultTypedControllerRateLimiter[string](),
+			workqueue.TypedRateLimitingQueueConfig[string]{Name: name},
+		),
 	}
 }
 
-func (c syncContext) Queue() workqueue.RateLimitingInterface { // nolint:staticcheck // SA1019
+func (c syncContext) Queue() workqueue.TypedRateLimitingInterface[string] {
 	return c.queue
 }
 

pkg/basecontroller/factory/interfaces.go

@@ -33,7 +33,7 @@ type Controller interface {
 type SyncContext interface {
 	// Queue gives access to controller queue. This can be used for manual requeue, although if a Sync() function return
 	// an error, the object is automatically re-queued. Use with caution.
-	Queue() workqueue.RateLimitingInterface // nolint:staticcheck // SA1019
+	Queue() workqueue.TypedRateLimitingInterface[string]
 }
 
 // SyncFunc is a function that contain main controller logic.

pkg/cloudevents/clients/work/garbagecollector/garbagecollector.go

@@ -66,7 +66,7 @@ type GarbageCollector struct {
 	// each monitor list/watches a resource (including manifestwork)
 	monitors monitors
 	// garbage collector attempts to delete the items in attemptToDelete queue when the time is ripe.
-	attemptToDelete workqueue.RateLimitingInterface // nolint:staticcheck // SA1019
+	attemptToDelete workqueue.TypedRateLimitingInterface[*dependent]
 }
 
 // NewGarbageCollector creates a new garbage collector instance.
@@ -89,7 +89,10 @@ func NewGarbageCollector(
 		workInformer:    workInformer,
 		metadataClient:  metadataClient,
 		ownerGVRFilters: ownerGVRFilters,
-		attemptToDelete: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "garbage_collector_attempt_to_delete"), // nolint:staticcheck // SA1019
+		attemptToDelete: workqueue.NewTypedRateLimitingQueueWithConfig(
+			workqueue.DefaultTypedControllerRateLimiter[*dependent](),
+			workqueue.TypedRateLimitingQueueConfig[*dependent]{Name: "garbage_collector_attempt_to_delete"},
+		),
 	}
 }
 

pkg/cloudevents/clients/work/garbagecollector/garbagecollector_test.go

@@ -87,7 +87,10 @@ func TestProcessManifestWorkEvent(t *testing.T) {
 		workIndexer:     fakeWorkInformer.Informer().GetIndexer(),
 		workInformer:    fakeWorkInformer,
 		metadataClient:  metadataClient,
-		attemptToDelete: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "garbage_collector_attempt_to_delete"), // nolint:staticcheck // SA1019
+		attemptToDelete: workqueue.NewTypedRateLimitingQueueWithConfig(
+			workqueue.DefaultTypedControllerRateLimiter[*dependent](),
+			workqueue.TypedRateLimitingQueueConfig[*dependent]{Name: "garbage_collector_attempt_to_delete"},
+		),
 	}
 	go fakeWorkInformer.Informer().Run(ctx.Done())
 	if !cache.WaitForCacheSync(ctx.Done(), fakeWorkInformer.Informer().HasSynced) {
@@ -223,7 +226,10 @@ func setupGC(t *testing.T, config *rest.Config) *GarbageCollector {
 		workInformer:    workInformer.Work().V1().ManifestWorks(),
 		metadataClient:  metadataClient,
 		ownerGVRFilters: ownerGVRFilters,
-		attemptToDelete: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "garbage_collector_attempt_to_delete"), // nolint:staticcheck // SA1019
+		attemptToDelete: workqueue.NewTypedRateLimitingQueueWithConfig(
+			workqueue.DefaultTypedControllerRateLimiter[*dependent](),
+			workqueue.TypedRateLimitingQueueConfig[*dependent]{Name: "garbage_collector_attempt_to_delete"},
+		),
 	}
 }
 

pkg/cloudevents/clients/work/store/base.go

@@ -24,7 +24,7 @@ type baseSourceStore struct {
 	store.BaseClientWatchStore[*workv1.ManifestWork]
 
 	// a queue to save the received work events
-	receivedWorks workqueue.RateLimitingInterface // nolint:staticcheck // SA1019
+	receivedWorks workqueue.TypedRateLimitingInterface[*workv1.ManifestWork]
 }
 
 func (bs *baseSourceStore) HandleReceivedResource(action types.ResourceAction, work *workv1.ManifestWork) error {
@@ -39,11 +39,11 @@ func (bs *baseSourceStore) HandleReceivedResource(action types.ResourceAction, w
 
 // workProcessor process the received works from given work queue with a specific store
 type workProcessor struct {
-	works workqueue.RateLimitingInterface // nolint:staticcheck // SA1019
+	works workqueue.TypedRateLimitingInterface[*workv1.ManifestWork]
 	store store.ClientWatcherStore[*workv1.ManifestWork]
 }
 
-func newWorkProcessor(works workqueue.RateLimitingInterface, store store.ClientWatcherStore[*workv1.ManifestWork]) *workProcessor { // nolint:staticcheck // SA1019
+func newWorkProcessor(works workqueue.TypedRateLimitingInterface[*workv1.ManifestWork], store store.ClientWatcherStore[*workv1.ManifestWork]) *workProcessor {
 	return &workProcessor{
 		works: works,
 		store: store,
@@ -79,7 +79,7 @@ func (b *workProcessor) processNextWork() bool {
 	}
 	defer b.works.Done(key)
 
-	if err := b.handleWork(key.(*workv1.ManifestWork)); err != nil {
+	if err := b.handleWork(key); err != nil {
 		// we failed to handle the work, we should requeue the item to work on later
 		// this method will add a backoff to avoid hotlooping on particular items
 		b.works.AddRateLimited(key)

pkg/cloudevents/clients/work/store/informer.go

@@ -34,7 +34,10 @@ func NewSourceInformerWatcherStore(ctx context.Context) *SourceInformerWatcherSt
 	s := &SourceInformerWatcherStore{
 		baseSourceStore: baseSourceStore{
 			BaseClientWatchStore: store.BaseClientWatchStore[*workv1.ManifestWork]{},
-			receivedWorks:        workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "informer-watcher-store"), // nolint:staticcheck // SA1019
+			receivedWorks:        workqueue.NewTypedRateLimitingQueueWithConfig(
+				workqueue.DefaultTypedControllerRateLimiter[*workv1.ManifestWork](),
+				workqueue.TypedRateLimitingQueueConfig[*workv1.ManifestWork]{Name: "informer-watcher-store"},
+			),
 		},
 		watcher: store.NewWatcher(),
 	}

pkg/cloudevents/clients/work/store/local.go

@@ -66,7 +66,10 @@ func NewSourceLocalWatcherStore(ctx context.Context, listFunc ListLocalWorksFunc
 
 			// A queue to save the received work events, it helps us retry events
 			// where errors occurred while processing
-			receivedWorks: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "local-watcher-store"), // nolint:staticcheck // SA1019
+			receivedWorks: workqueue.NewTypedRateLimitingQueueWithConfig(
+				workqueue.DefaultTypedControllerRateLimiter[*workv1.ManifestWork](),
+				workqueue.TypedRateLimitingQueueConfig[*workv1.ManifestWork]{Name: "local-watcher-store"},
+			),
 		},
 
 		watcher: store.NewWatcher(),