Update to fix controller-runtime generics introductions

Author: JoelSpeed

pkg/controller/machine/drain_controller.go

@@ -56,11 +56,11 @@ func newDrainController(mgr manager.Manager) reconcile.Reconciler {
 // As we know drains are a slower operation then traditional reconciles, we start with a
 // larger base delay to allow the pods time for graceful shutdown.
 // We cap out at 1000 seconds as with the default queue.
-func newDrainRateLimiter() workqueue.RateLimiter {
-	return workqueue.NewMaxOfRateLimiter(
-		workqueue.NewItemExponentialFailureRateLimiter(5*time.Second, 1000*time.Second),
+func newDrainRateLimiter() workqueue.TypedRateLimiter[reconcile.Request] {
+	return workqueue.NewTypedMaxOfRateLimiter[reconcile.Request](
+		workqueue.NewTypedItemExponentialFailureRateLimiter[reconcile.Request](5*time.Second, 1000*time.Second),
 		// 10 qps, 100 bucket size.  This is only for retry speed and its only the overall factor (not per item)
-		&workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(10), 100)},
+		&workqueue.TypedBucketRateLimiter[reconcile.Request]{Limiter: rate.NewLimiter(rate.Limit(10), 100)},
 	)
 }
 

pkg/controller/machinehealthcheck/machinehealthcheck_controller.go

@@ -121,7 +121,7 @@ func indexMachineByNodeName(object client.Object) []string {
 }
 
 // add adds a new Controller to mgr with r as the reconcile.Reconciler
-func add(mgr manager.Manager, r reconcile.Reconciler, mapMachineToMHC handler.TypedMapFunc[*machinev1.Machine], mapNodeToMHC handler.TypedMapFunc[*corev1.Node]) error {
+func add(mgr manager.Manager, r reconcile.Reconciler, mapMachineToMHC handler.TypedMapFunc[*machinev1.Machine, reconcile.Request], mapNodeToMHC handler.TypedMapFunc[*corev1.Node, reconcile.Request]) error {
 	c, err := controller.New(controllerName, mgr, controller.Options{Reconciler: r})
 	if err != nil {
 		return err

pkg/controller/machineset/controller.go

@@ -86,7 +86,7 @@ func newReconciler(mgr manager.Manager, gate featuregate.MutableFeatureGate) *Re
 }
 
 // add adds a new Controller to mgr with r as the reconcile.Reconciler.
-func add(mgr manager.Manager, r reconcile.Reconciler, mapFn handler.TypedMapFunc[*machinev1.Machine]) error {
+func add(mgr manager.Manager, r reconcile.Reconciler, mapFn handler.TypedMapFunc[*machinev1.Machine, reconcile.Request]) error {
 	// Create a new controller.
 	c, err := controller.New(controllerName, mgr, controller.Options{Reconciler: r})
 	if err != nil {

pkg/controller/nodelink/nodelink_controller.go

@@ -161,7 +161,7 @@ func newReconciler(mgr manager.Manager) (*ReconcileNodeLink, error) {
 }
 
 // add adds a new Controller to mgr with r as the reconcile.Reconciler
-func add(mgr manager.Manager, r reconcile.Reconciler, mapFn handler.TypedMapFunc[*machinev1.Machine]) error {
+func add(mgr manager.Manager, r reconcile.Reconciler, mapFn handler.TypedMapFunc[*machinev1.Machine, reconcile.Request]) error {
 	// Create a new controller
 	c, err := controller.New("nodelink-controller", mgr, controller.Options{Reconciler: r})
 	if err != nil {

pkg/operator/operator.go

@@ -81,7 +81,7 @@ type Operator struct {
 	featureGateAccessor featuregates.FeatureGateAccess
 
 	// queue only ever has one item, but it has nice error handling backoff/retry semantics
-	queue           workqueue.RateLimitingInterface
+	queue           workqueue.TypedRateLimitingInterface[string]
 	operandVersions []osconfigv1.OperandVersion
 
 	generations []osoperatorv1.GenerationStatus
@@ -122,16 +122,18 @@ func New(
 	}
 
 	optr := &Operator{
-		namespace:       namespace,
-		name:            name,
-		imagesFile:      imagesFile,
-		kubeClient:      kubeClient,
-		osClient:        osClient,
-		machineClient:   machineClient,
-		dynamicClient:   dynamicClient,
-		eventRecorder:   eventRecorder,
-		recorder:        recorder,
-		queue:           workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineapioperator"),
+		namespace:     namespace,
+		name:          name,
+		imagesFile:    imagesFile,
+		kubeClient:    kubeClient,
+		osClient:      osClient,
+		machineClient: machineClient,
+		dynamicClient: dynamicClient,
+		eventRecorder: eventRecorder,
+		recorder:      recorder,
+		queue: workqueue.NewTypedRateLimitingQueueWithConfig(workqueue.DefaultTypedControllerRateLimiter[string](), workqueue.TypedRateLimitingQueueConfig[string]{
+			Name: "machineapioperator",
+		}),
 		operandVersions: operandVersions,
 	}
 
@@ -368,13 +370,13 @@ func (optr *Operator) processNextWorkItem() bool {
 	defer optr.queue.Done(key)
 
 	klog.V(4).Infof("Processing key %s", key)
-	result, err := optr.syncHandler(key.(string))
+	result, err := optr.syncHandler(key)
 	optr.handleSyncResult(result, err, key)
 
 	return true
 }
 
-func (optr *Operator) handleSyncResult(result reconcile.Result, err error, key interface{}) {
+func (optr *Operator) handleSyncResult(result reconcile.Result, err error, key string) {
 	switch {
 	case err != nil && optr.queue.NumRequeues(key) < maxRetries:
 		klog.V(1).Infof("Error syncing operator %v: %v", key, err)

pkg/operator/operator_test.go

@@ -90,20 +90,22 @@ func newFakeOperator(kubeObjects, osObjects, machineObjects []runtime.Object, im
 	}
 
 	optr := &Operator{
-		kubeClient:                    kubeClient,
-		osClient:                      osClient,
-		machineClient:                 machineClient,
-		dynamicClient:                 dynamicClient,
-		deployLister:                  deployInformer.Lister(),
-		proxyLister:                   proxyInformer.Lister(),
-		daemonsetLister:               daemonsetInformer.Lister(),
-		mutatingWebhookLister:         mutatingWebhookInformer.Lister(),
-		validatingWebhookLister:       validatingWebhookInformer.Lister(),
-		featureGateAccessor:           featureGateAccessor,
-		imagesFile:                    imagesFile,
-		namespace:                     targetNamespace,
-		eventRecorder:                 record.NewFakeRecorder(50),
-		queue:                         workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "machineapioperator"),
+		kubeClient:              kubeClient,
+		osClient:                osClient,
+		machineClient:           machineClient,
+		dynamicClient:           dynamicClient,
+		deployLister:            deployInformer.Lister(),
+		proxyLister:             proxyInformer.Lister(),
+		daemonsetLister:         daemonsetInformer.Lister(),
+		mutatingWebhookLister:   mutatingWebhookInformer.Lister(),
+		validatingWebhookLister: validatingWebhookInformer.Lister(),
+		featureGateAccessor:     featureGateAccessor,
+		imagesFile:              imagesFile,
+		namespace:               targetNamespace,
+		eventRecorder:           record.NewFakeRecorder(50),
+		queue: workqueue.NewTypedRateLimitingQueueWithConfig(workqueue.DefaultTypedControllerRateLimiter[string](), workqueue.TypedRateLimitingQueueConfig[string]{
+			Name: "machineapioperator",
+		}),
 		deployListerSynced:            deployInformer.Informer().HasSynced,
 		proxyListerSynced:             proxyInformer.Informer().HasSynced,
 		daemonsetListerSynced:         daemonsetInformer.Informer().HasSynced,