diff --git a/internal/controller/garbagecollector_controller.go b/internal/controller/garbagecollector_controller.go index 2fa3ac9d..28918ad0 100644 --- a/internal/controller/garbagecollector_controller.go +++ b/internal/controller/garbagecollector_controller.go @@ -29,6 +29,7 @@ import ( "k8s.io/apimachinery/pkg/types" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -278,6 +279,6 @@ func (r *GarbageCollectorReconciler) SetupWithManager(mgr ctrl.Manager) error { WithLogConstructor(func(_ *reconcile.Request) logr.Logger { return logr.New(ctrl.Log.GetSink().WithValues("controller", "nonadmingarbagecollector")) }). - WatchesRawSource(&source.PeriodicalSource{Frequency: r.Frequency}). + WatchesRawSource(&source.PeriodicalSource{Frequency: r.Frequency}, &handler.EnqueueRequestForObject{}). Complete(r) } diff --git a/internal/controller/garbagecollector_controller_test.go b/internal/controller/garbagecollector_controller_test.go index fa36b931..022d90f3 100644 --- a/internal/controller/garbagecollector_controller_test.go +++ b/internal/controller/garbagecollector_controller_test.go @@ -27,11 +27,9 @@ import ( velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" - "sigs.k8s.io/controller-runtime/pkg/config" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" "github.com/migtools/oadp-non-admin/internal/common/constant" @@ -148,9 +146,6 @@ var _ = ginkgo.Describe("Test full reconcile loop of GarbageCollector Controller gomega.Expect(restoresInOADPNamespace.Items).To(gomega.HaveLen(scenario.restores + scenario.orphanRestores)) k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, Scheme: k8sClient.Scheme(), Cache: cache.Options{ DefaultNamespaces: map[string]cache.Config{ diff --git a/internal/controller/nonadminbackup_controller.go b/internal/controller/nonadminbackup_controller.go index 56d9293d..7f8448e4 100644 --- a/internal/controller/nonadminbackup_controller.go +++ b/internal/controller/nonadminbackup_controller.go @@ -34,6 +34,7 @@ import ( "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/util/retry" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" @@ -194,7 +195,7 @@ func (r *NonAdminBackupReconciler) setStatusAndConditionForDeletionAndCallDelete }, ) if updatedPhase || updatedCondition { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -238,7 +239,7 @@ func (r *NonAdminBackupReconciler) setStatusForDirectKubernetesAPIDeletion(ctx c }, ) if updatedPhase || updatedCondition { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -350,7 +351,7 @@ func (r *NonAdminBackupReconciler) createVeleroDeleteBackupRequest(ctx context.C // Status will be applied based on the current state of the DeleteBackupRequest. updated := updateNonAdminBackupDeleteBackupRequestStatus(&nab.Status, deleteBackupRequest) if updated { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, "Failed to update NonAdminBackup Status after DeleteBackupRequest reconciliation") return false, err } @@ -457,9 +458,10 @@ func (r *NonAdminBackupReconciler) deleteDeleteBackupRequestObjects(ctx context. func (r *NonAdminBackupReconciler) removeNabFinalizerUponVeleroBackupDeletion(ctx context.Context, logger logr.Logger, nab *nacv1alpha1.NonAdminBackup) (bool, error) { logger.V(1).Info("VeleroBackup deleted, removing NonAdminBackup finalizer") + patch := client.MergeFrom(nab.DeepCopy()) controllerutil.RemoveFinalizer(nab, constant.NabFinalizerName) - if err := r.Update(ctx, nab); err != nil { + if err := r.Patch(ctx, nab, patch); err != nil { logger.Error(err, "Failed to remove finalizer from NonAdminBackup") return false, err } @@ -490,7 +492,7 @@ func (r *NonAdminBackupReconciler) initNabCreate(ctx context.Context, logger log // Set phase to New if updated := updateNonAdminPhase(&nab.Status.Phase, nacv1alpha1.NonAdminPhaseNew); updated { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -527,7 +529,7 @@ func (r *NonAdminBackupReconciler) validateSpec(ctx context.Context, logger logr }, ) if updatedPhase || updatedCondition { - if updateErr := r.Status().Update(ctx, nab); updateErr != nil { + if updateErr := r.updateStatusWithRetry(ctx, logger, nab); updateErr != nil { logger.Error(updateErr, statusUpdateError) return false, updateErr } @@ -548,7 +550,7 @@ func (r *NonAdminBackupReconciler) validateSpec(ctx context.Context, logger logr }, ) if updated { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -590,7 +592,7 @@ func (r *NonAdminBackupReconciler) setBackupUUIDInStatus(ctx context.Context, lo Namespace: r.OADPNamespace, Name: veleroBackupNACUUID, } - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -606,8 +608,9 @@ func (r *NonAdminBackupReconciler) setFinalizerOnNonAdminBackup(ctx context.Cont // to ensure we won't risk having orphant Velero Backup resource, due to an unexpected error // while adding finalizer after creatign Velero Backup if !controllerutil.ContainsFinalizer(nab, constant.NabFinalizerName) { + patch := client.MergeFrom(nab.DeepCopy()) controllerutil.AddFinalizer(nab, constant.NabFinalizerName) - if err := r.Update(ctx, nab); err != nil { + if err := r.Patch(ctx, nab, patch); err != nil { logger.Error(err, "Failed to add finalizer") return false, err } @@ -663,7 +666,7 @@ func (r *NonAdminBackupReconciler) createVeleroBackupAndSyncWithNonAdminBackup(c }, ) if updatedPhase || updatedCondition { - if updateErr := r.Status().Update(ctx, nab); updateErr != nil { + if updateErr := r.updateStatusWithRetry(ctx, logger, nab); updateErr != nil { logger.Error(updateErr, nonAdminRestoreStatusUpdateFailureMessage) return false, updateErr } @@ -798,7 +801,7 @@ func (r *NonAdminBackupReconciler) createVeleroBackupAndSyncWithNonAdminBackup(c updatedDataUploadStatus := updateNonAdminBackupDataUploadStatus(&nab.Status, dataUploads) if updated || updatedPhase || updatedCondition || updatedQueueInfo || updatedPodVolumeBackupStatus || updatedDataUploadStatus { - if err := r.Status().Update(ctx, nab); err != nil { + if err := r.updateStatusWithRetry(ctx, logger, nab); err != nil { logger.Error(err, statusUpdateError) return false, err } @@ -810,6 +813,40 @@ func (r *NonAdminBackupReconciler) createVeleroBackupAndSyncWithNonAdminBackup(c return false, nil } +// updateStatusWithRetry updates the NonAdminBackup status with retry logic to handle resource version conflicts +func (r *NonAdminBackupReconciler) updateStatusWithRetry(ctx context.Context, logger logr.Logger, nab *nacv1alpha1.NonAdminBackup) error { + return retry.RetryOnConflict(retry.DefaultRetry, func() error { + // Always fetch the latest version before updating status + current := &nacv1alpha1.NonAdminBackup{} + if err := r.Get(ctx, client.ObjectKeyFromObject(nab), current); err != nil { + return err + } + + // Preserve existing conditions and merge in new status updates + // This prevents losing conditions that were set by other reconcile steps + current.Status.Phase = nab.Status.Phase + current.Status.VeleroBackup = nab.Status.VeleroBackup + current.Status.QueueInfo = nab.Status.QueueInfo + current.Status.VeleroDeleteBackupRequest = nab.Status.VeleroDeleteBackupRequest + current.Status.DataMoverDataUploads = nab.Status.DataMoverDataUploads + current.Status.FileSystemPodVolumeBackups = nab.Status.FileSystemPodVolumeBackups + + // Merge conditions instead of replacing them + for _, newCondition := range nab.Status.Conditions { + meta.SetStatusCondition(¤t.Status.Conditions, newCondition) + } + + // Attempt status update on fresh resource version + if err := r.Status().Update(ctx, current); err != nil { + logger.V(1).Info("Status update conflict, retrying...", "error", err.Error()) + return err + } + + logger.V(1).Info("Status update successful") + return nil + }) +} + // SetupWithManager sets up the controller with the Manager. func (r *NonAdminBackupReconciler) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). diff --git a/internal/controller/nonadminbackup_controller_test.go b/internal/controller/nonadminbackup_controller_test.go index 65d4b914..ba76bc50 100644 --- a/internal/controller/nonadminbackup_controller_test.go +++ b/internal/controller/nonadminbackup_controller_test.go @@ -36,7 +36,6 @@ import ( "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" - "sigs.k8s.io/controller-runtime/pkg/config" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -123,21 +122,27 @@ func checkTestNonAdminBackupStatus(nonAdminBackup *nacv1alpha1.NonAdminBackup, e } } - if len(nonAdminBackup.Status.Conditions) != len(expectedStatus.Conditions) { - return fmt.Errorf("NonAdminBackup Status has %v Condition(s), expected to have %v", len(nonAdminBackup.Status.Conditions), len(expectedStatus.Conditions)) - } - for index := range nonAdminBackup.Status.Conditions { - if nonAdminBackup.Status.Conditions[index].Type != expectedStatus.Conditions[index].Type { - return fmt.Errorf("NonAdminBackup Status Conditions [%v] Type %v is not equal to expected %v", index, nonAdminBackup.Status.Conditions[index].Type, expectedStatus.Conditions[index].Type) - } - if nonAdminBackup.Status.Conditions[index].Status != expectedStatus.Conditions[index].Status { - return fmt.Errorf("NonAdminBackup Status Conditions [%v] Status %v is not equal to expected %v", index, nonAdminBackup.Status.Conditions[index].Status, expectedStatus.Conditions[index].Status) - } - if nonAdminBackup.Status.Conditions[index].Reason != expectedStatus.Conditions[index].Reason { - return fmt.Errorf("NonAdminBackup Status Conditions [%v] Reason %v is not equal to expected %v", index, nonAdminBackup.Status.Conditions[index].Reason, expectedStatus.Conditions[index].Reason) + // Check that all expected conditions are present with correct values + // More robust than exact array matching - allows for additional conditions or different ordering + for _, expectedCondition := range expectedStatus.Conditions { + found := false + for _, actualCondition := range nonAdminBackup.Status.Conditions { + if actualCondition.Type == expectedCondition.Type { + found = true + if actualCondition.Status != expectedCondition.Status { + return fmt.Errorf("NonAdminBackup Status Condition Type %v has Status %v, expected %v", expectedCondition.Type, actualCondition.Status, expectedCondition.Status) + } + if actualCondition.Reason != expectedCondition.Reason { + return fmt.Errorf("NonAdminBackup Status Condition Type %v has Reason %v, expected %v", expectedCondition.Type, actualCondition.Reason, expectedCondition.Reason) + } + if !strings.Contains(actualCondition.Message, expectedCondition.Message) { + return fmt.Errorf("NonAdminBackup Status Condition Type %v has Message %v, expected to contain %v", expectedCondition.Type, actualCondition.Message, expectedCondition.Message) + } + break + } } - if !strings.Contains(nonAdminBackup.Status.Conditions[index].Message, expectedStatus.Conditions[index].Message) { - return fmt.Errorf("NonAdminBackup Status Conditions [%v] Message %v does not contain expected message %v", index, nonAdminBackup.Status.Conditions[index].Message, expectedStatus.Conditions[index].Message) + if !found { + return fmt.Errorf("NonAdminBackup Status missing expected Condition Type %v", expectedCondition.Type) } } @@ -1145,9 +1150,6 @@ var _ = ginkgo.Describe("Test full reconcile loop of NonAdminBackup Controller", gomega.Expect(createTestNamespaces(ctx, nonAdminObjectNamespace, oadpNamespace)).To(gomega.Succeed()) k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, Scheme: k8sClient.Scheme(), Cache: cache.Options{ DefaultNamespaces: map[string]cache.Config{ @@ -1581,9 +1583,6 @@ var _ = ginkgo.Describe("Test full reconcile loop of NonAdminBackup Controller", gomega.Expect(k8sClient.Update(ctx, veleroBackup)).To(gomega.Succeed()) k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, Scheme: k8sClient.Scheme(), Cache: cache.Options{ DefaultNamespaces: map[string]cache.Config{ diff --git a/internal/controller/nonadminbackupstoragelocation_controller.go b/internal/controller/nonadminbackupstoragelocation_controller.go index fb63fe61..6a4fb8c2 100644 --- a/internal/controller/nonadminbackupstoragelocation_controller.go +++ b/internal/controller/nonadminbackupstoragelocation_controller.go @@ -53,7 +53,6 @@ import ( "github.com/go-logr/logr" oadpv1alpha1 "github.com/openshift/oadp-operator/api/v1alpha1" - oadpcommon "github.com/openshift/oadp-operator/pkg/common" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "github.com/vmware-tanzu/velero/pkg/builder" corev1 "k8s.io/api/core/v1" @@ -892,12 +891,8 @@ func (r *NonAdminBackupStorageLocationReconciler) createVeleroBSL(ctx context.Co enforcedBSLSpec := getEnforcedBSLSpec(nabsl, r.EnforcedBslSpec) - err = oadpcommon.UpdateBackupStorageLocation(veleroBsl, *enforcedBSLSpec) - - if err != nil { - logger.Error(err, "Failed to update VeleroBackupStorageLocation spec") - return false, err - } + // Update the VeleroBackupStorageLocation spec + veleroBsl.Spec = *enforcedBSLSpec // NaBSL/BSL must have a unique prefix for proper function of the non-admin backup sync controller // 1. Check if user has specified the prefix as "foo" in NaBSL creation, then prefix used would be /foo diff --git a/internal/controller/nonadminbackupstoragelocation_controller_test.go b/internal/controller/nonadminbackupstoragelocation_controller_test.go index 02ee0d2c..eb52a431 100644 --- a/internal/controller/nonadminbackupstoragelocation_controller_test.go +++ b/internal/controller/nonadminbackupstoragelocation_controller_test.go @@ -51,9 +51,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/wait" - "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/config" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" "github.com/migtools/oadp-non-admin/internal/common/constant" @@ -232,9 +230,6 @@ var _ = ginkgo.Describe("Test full reconcile loop of NonAdminBackupStorageLocati } k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, Scheme: k8sClient.Scheme(), }) gomega.Expect(err).ToNot(gomega.HaveOccurred()) diff --git a/internal/controller/nonadminbackupsynchronizer_controller.go b/internal/controller/nonadminbackupsynchronizer_controller.go index 33050f17..93f8a12d 100644 --- a/internal/controller/nonadminbackupsynchronizer_controller.go +++ b/internal/controller/nonadminbackupsynchronizer_controller.go @@ -31,6 +31,7 @@ import ( "k8s.io/apimachinery/pkg/types" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -169,6 +170,6 @@ func (r *NonAdminBackupSynchronizerReconciler) SetupWithManager(mgr ctrl.Manager WithLogConstructor(func(_ *reconcile.Request) logr.Logger { return logr.New(ctrl.Log.GetSink().WithValues("controller", "nonadminbackupsynchronizer")) }). - WatchesRawSource(&source.PeriodicalSource{Frequency: r.SyncPeriod}). + WatchesRawSource(&source.PeriodicalSource{Frequency: r.SyncPeriod}, &handler.EnqueueRequestForObject{}). Complete(r) } diff --git a/internal/controller/nonadminbackupsynchronizer_controller_test.go b/internal/controller/nonadminbackupsynchronizer_controller_test.go index 6c51e189..b29782fc 100644 --- a/internal/controller/nonadminbackupsynchronizer_controller_test.go +++ b/internal/controller/nonadminbackupsynchronizer_controller_test.go @@ -26,11 +26,9 @@ import ( "github.com/onsi/gomega" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" - "sigs.k8s.io/controller-runtime/pkg/config" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" "github.com/migtools/oadp-non-admin/internal/common/constant" @@ -160,9 +158,6 @@ var _ = ginkgo.Describe("Test full reconcile loop of NonAdminBackup Synchronizer gomega.Expect(nonAdminBackupsInNonAminNamespace.Items).To(gomega.BeEmpty()) k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, Scheme: k8sClient.Scheme(), Cache: cache.Options{ DefaultNamespaces: map[string]cache.Config{ diff --git a/internal/controller/nonadmindownloadrequest_controller.go b/internal/controller/nonadmindownloadrequest_controller.go index 5fbcf9dc..249aba79 100644 --- a/internal/controller/nonadmindownloadrequest_controller.go +++ b/internal/controller/nonadmindownloadrequest_controller.go @@ -226,10 +226,10 @@ func (r *NonAdminDownloadRequestReconciler) processDownloadRequest(ctx context.C func (r *NonAdminDownloadRequestReconciler) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). For(&nacv1alpha1.NonAdminDownloadRequest{}, builder.WithPredicates(ctrlpredicate.Funcs{ - CreateFunc: func(_ event.TypedCreateEvent[client.Object]) bool { + CreateFunc: func(_ event.CreateEvent) bool { return true // required fields are set via velero validation markers }, - UpdateFunc: func(tue event.TypedUpdateEvent[client.Object]) bool { + UpdateFunc: func(tue event.UpdateEvent) bool { // only process update on spec change if tue.ObjectNew.GetGeneration() == tue.ObjectOld.GetGeneration() { return false @@ -239,16 +239,16 @@ func (r *NonAdminDownloadRequestReconciler) SetupWithManager(mgr ctrl.Manager) e } return false }, - DeleteFunc: func(_ event.TypedDeleteEvent[client.Object]) bool { + DeleteFunc: func(_ event.DeleteEvent) bool { return true }, // we process delete events by deleting corresponding velero download requests if found - GenericFunc: func(_ event.TypedGenericEvent[client.Object]) bool { + GenericFunc: func(_ event.GenericEvent) bool { return false }, })). Named("nonadmindownloadrequest"). Watches(&velerov1.DownloadRequest{}, handler.Funcs{ - UpdateFunc: func(ctx context.Context, tue event.TypedUpdateEvent[client.Object], rli workqueue.TypedRateLimitingInterface[reconcile.Request]) { + UpdateFunc: func(ctx context.Context, tue event.UpdateEvent, rli workqueue.RateLimitingInterface) { if dr, ok := tue.ObjectNew.(*velerov1.DownloadRequest); ok && dr.Status.Phase == velerov1.DownloadRequestPhaseProcessed { // only reconcile on updates when downloadrequests is processed log := function.GetLogger(ctx, dr, "VeleroDownloadRequestHandler") diff --git a/internal/controller/nonadmindownloadrequest_controller_test.go b/internal/controller/nonadmindownloadrequest_controller_test.go index 6ac463ed..a331dffe 100644 --- a/internal/controller/nonadmindownloadrequest_controller_test.go +++ b/internal/controller/nonadmindownloadrequest_controller_test.go @@ -29,7 +29,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/kubernetes/scheme" - "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" @@ -65,10 +64,8 @@ var _ = ginkgo.Describe("NonAdminDownloadRequest Controller", func() { nonAdminNamespace = fmt.Sprintf("%s-nan-%d", nonAdminNamespacePrefix, counter) oadpNamespace = fmt.Sprintf("%s-on-%d", oadpNamespacePrefix, counter) k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, - Scheme: k8sClient.Scheme(), + Controller: config.Controller{}, + Scheme: k8sClient.Scheme(), Cache: cache.Options{ DefaultNamespaces: map[string]cache.Config{ nonAdminNamespace: {}, @@ -413,10 +410,8 @@ var _ = ginkgo.Describe("NonAdminDownloadRequest Controller", func() { ginkgo.Context("Testing SetupWithManager", func() { ginkgo.It("Should set up the controller with the manager", func() { mgr, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, - Scheme: scheme.Scheme, + Controller: config.Controller{}, + Scheme: scheme.Scheme, }) gomega.Expect(err).NotTo(gomega.HaveOccurred()) diff --git a/internal/controller/nonadminrestore_controller_test.go b/internal/controller/nonadminrestore_controller_test.go index 369b76c7..f541f475 100644 --- a/internal/controller/nonadminrestore_controller_test.go +++ b/internal/controller/nonadminrestore_controller_test.go @@ -209,10 +209,8 @@ var _ = ginkgo.Describe("Test full reconcile loop of NonAdminRestore Controller" } k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{ - Controller: config.Controller{ - SkipNameValidation: ptr.To(true), - }, - Scheme: k8sClient.Scheme(), + Controller: config.Controller{}, + Scheme: k8sClient.Scheme(), }) gomega.Expect(err).ToNot(gomega.HaveOccurred()) diff --git a/internal/handler/nonadminbackupstoragelocationrequest_handler.go b/internal/handler/nonadminbackupstoragelocationrequest_handler.go index 86d9ce6c..f1e38dfb 100644 --- a/internal/handler/nonadminbackupstoragelocationrequest_handler.go +++ b/internal/handler/nonadminbackupstoragelocationrequest_handler.go @@ -22,7 +22,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -34,12 +33,12 @@ import ( type NonAdminBackupStorageLocationRequestHandler struct{} // Create event handler -func (NonAdminBackupStorageLocationRequestHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBackupStorageLocationRequestHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the NonAdminBackupStorageLocationRequest object } // Update event handler adds NonAdminBackupStorageLocationRequest's NonAdminBackupStorageLocation to controller queue -func (NonAdminBackupStorageLocationRequestHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBackupStorageLocationRequestHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "NonAdminBackupStorageLocationRequestHandler") annotations := evt.ObjectNew.GetAnnotations() @@ -54,7 +53,7 @@ func (NonAdminBackupStorageLocationRequestHandler) Update(ctx context.Context, e } // Delete event handler -func (NonAdminBackupStorageLocationRequestHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBackupStorageLocationRequestHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.Object, "NonAdminBackupStorageLocationRequestHandler") annotations := evt.Object.GetAnnotations() @@ -69,6 +68,6 @@ func (NonAdminBackupStorageLocationRequestHandler) Delete(ctx context.Context, e } // Generic event handler -func (NonAdminBackupStorageLocationRequestHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBackupStorageLocationRequestHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the NonAdminBackupStorageLocationRequest object } diff --git a/internal/handler/nonadminbsl_secret_handler.go b/internal/handler/nonadminbsl_secret_handler.go index e19bd22b..d13d5275 100644 --- a/internal/handler/nonadminbsl_secret_handler.go +++ b/internal/handler/nonadminbsl_secret_handler.go @@ -19,11 +19,11 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -37,7 +37,7 @@ type NonAdminBslSecretHandler struct { } // Create event handler -func (h NonAdminBslSecretHandler) Create(ctx context.Context, evt event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h NonAdminBslSecretHandler) Create(ctx context.Context, evt event.CreateEvent, q workqueue.RateLimitingInterface) { // Create event handler for the Secret object logger := function.GetLogger(ctx, evt.Object, "NonAdminBslSecretHandler") @@ -65,16 +65,16 @@ func (h NonAdminBslSecretHandler) Create(ctx context.Context, evt event.CreateEv } // Update event handler -func (NonAdminBslSecretHandler) Update(_ context.Context, _ event.UpdateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBslSecretHandler) Update(_ context.Context, _ event.UpdateEvent, _ workqueue.RateLimitingInterface) { // Update event handler for the Secret object } // Delete event handler -func (NonAdminBslSecretHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBslSecretHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the Secret object } // Generic event handler -func (NonAdminBslSecretHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (NonAdminBslSecretHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the Secret object } diff --git a/internal/handler/velerobackup_handler.go b/internal/handler/velerobackup_handler.go index 7740dca7..30490a45 100644 --- a/internal/handler/velerobackup_handler.go +++ b/internal/handler/velerobackup_handler.go @@ -22,7 +22,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -34,12 +33,12 @@ import ( type VeleroBackupHandler struct{} // Create event handler -func (VeleroBackupHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the Backup object } // Update event handler adds Velero Backup's NonAdminBackup to controller queue -func (VeleroBackupHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroBackupHandler") annotations := evt.ObjectNew.GetAnnotations() @@ -54,7 +53,7 @@ func (VeleroBackupHandler) Update(ctx context.Context, evt event.TypedUpdateEven } // Delete event handler -func (VeleroBackupHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.Object, "VeleroBackupHandler") annotations := evt.Object.GetAnnotations() @@ -69,6 +68,6 @@ func (VeleroBackupHandler) Delete(ctx context.Context, evt event.DeleteEvent, q } // Generic event handler -func (VeleroBackupHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the Backup object } diff --git a/internal/handler/velerobackup_queue_handler.go b/internal/handler/velerobackup_queue_handler.go index 2aa881f7..4ce049b9 100644 --- a/internal/handler/velerobackup_queue_handler.go +++ b/internal/handler/velerobackup_queue_handler.go @@ -19,10 +19,10 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -37,12 +37,12 @@ type VeleroBackupQueueHandler struct { } // Create event handler -func (VeleroBackupQueueHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupQueueHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the Backup object } // Update event handler adds Velero Backup's NonAdminBackup to controller queue -func (h VeleroBackupQueueHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroBackupQueueHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { // Only update to the first in the queue Velero Backup should trigger changes to the // NonAdminBackup objects. Updates to the Velero Backup 2nd and 3rd does not lower the // queue. This optimizes the number of times we need to update the NonAdminBackup objects @@ -87,11 +87,11 @@ func (h VeleroBackupQueueHandler) Update(ctx context.Context, evt event.TypedUpd } // Delete event handler -func (VeleroBackupQueueHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupQueueHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the Backup object } // Generic event handler -func (VeleroBackupQueueHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupQueueHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the Backup object } diff --git a/internal/handler/velerobackupstoragelocation_handler.go b/internal/handler/velerobackupstoragelocation_handler.go index 38aa3541..bdac2bc4 100644 --- a/internal/handler/velerobackupstoragelocation_handler.go +++ b/internal/handler/velerobackupstoragelocation_handler.go @@ -22,7 +22,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -34,12 +33,12 @@ import ( type VeleroBackupStorageLocationHandler struct{} // Create event handler -func (VeleroBackupStorageLocationHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupStorageLocationHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the BackupStorageLocation object } // Update event handler adds Velero BackupStorageLocation's NonAdminBackupStorageLocation to controller queue -func (VeleroBackupStorageLocationHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupStorageLocationHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroBackupStorageLocationHandler") annotations := evt.ObjectNew.GetAnnotations() @@ -54,11 +53,11 @@ func (VeleroBackupStorageLocationHandler) Update(ctx context.Context, evt event. } // Delete event handler -func (VeleroBackupStorageLocationHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupStorageLocationHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the BackupStorageLocation object } // Generic event handler -func (VeleroBackupStorageLocationHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroBackupStorageLocationHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the BackupStorageLocation object } diff --git a/internal/handler/velerodatadownload_handler.go b/internal/handler/velerodatadownload_handler.go index b9e47780..2253b64e 100644 --- a/internal/handler/velerodatadownload_handler.go +++ b/internal/handler/velerodatadownload_handler.go @@ -19,11 +19,11 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -38,12 +38,12 @@ type VeleroDataDownloadHandler struct { } // Create event handler -func (VeleroDataDownloadHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataDownloadHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the DataDownload object } // Update event handler adds Velero DataDownload's NonAdminRestore to controller queue -func (h VeleroDataDownloadHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroDataDownloadHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroDataDownloadHandler") owners := evt.ObjectNew.GetOwnerReferences() @@ -73,11 +73,11 @@ func (h VeleroDataDownloadHandler) Update(ctx context.Context, evt event.TypedUp } // Delete event handler -func (VeleroDataDownloadHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataDownloadHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the DataDownload object } // Generic event handler -func (VeleroDataDownloadHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataDownloadHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the DataDownload object } diff --git a/internal/handler/velerodataupload_handler.go b/internal/handler/velerodataupload_handler.go index 56f12f6f..e872b766 100644 --- a/internal/handler/velerodataupload_handler.go +++ b/internal/handler/velerodataupload_handler.go @@ -19,11 +19,11 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -38,12 +38,12 @@ type VeleroDataUploadHandler struct { } // Create event handler -func (VeleroDataUploadHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataUploadHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the DataUpload object } // Update event handler adds Velero DataUpload's NonAdminBackup to controller queue -func (h VeleroDataUploadHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroDataUploadHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroDataUploadHandler") owners := evt.ObjectNew.GetOwnerReferences() @@ -73,11 +73,11 @@ func (h VeleroDataUploadHandler) Update(ctx context.Context, evt event.TypedUpda } // Delete event handler -func (VeleroDataUploadHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataUploadHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the DataUpload object } // Generic event handler -func (VeleroDataUploadHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroDataUploadHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the DataUpload object } diff --git a/internal/handler/veleropodvolumebackup_handler.go b/internal/handler/veleropodvolumebackup_handler.go index 0826c77a..7ef8e661 100644 --- a/internal/handler/veleropodvolumebackup_handler.go +++ b/internal/handler/veleropodvolumebackup_handler.go @@ -19,11 +19,11 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -38,12 +38,12 @@ type VeleroPodVolumeBackupHandler struct { } // Create event handler -func (VeleroPodVolumeBackupHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeBackupHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the PodVolumeBackup object } // Update event handler adds Velero PodVolumeBackup's NonAdminBackup to controller queue -func (h VeleroPodVolumeBackupHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroPodVolumeBackupHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroPodVolumeBackupHandler") owners := evt.ObjectNew.GetOwnerReferences() @@ -73,11 +73,11 @@ func (h VeleroPodVolumeBackupHandler) Update(ctx context.Context, evt event.Type } // Delete event handler -func (VeleroPodVolumeBackupHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeBackupHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the PodVolumeBackup object } // Generic event handler -func (VeleroPodVolumeBackupHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeBackupHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the PodVolumeBackup object } diff --git a/internal/handler/veleropodvolumerestore_handler.go b/internal/handler/veleropodvolumerestore_handler.go index f0415be4..08ceac90 100644 --- a/internal/handler/veleropodvolumerestore_handler.go +++ b/internal/handler/veleropodvolumerestore_handler.go @@ -19,11 +19,11 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -38,12 +38,12 @@ type VeleroPodVolumeRestoreHandler struct { } // Create event handler -func (VeleroPodVolumeRestoreHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeRestoreHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the PodVolumeRestore object } // Update event handler adds Velero PodVolumeRestore's NonAdminRestore to controller queue -func (h VeleroPodVolumeRestoreHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroPodVolumeRestoreHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroPodVolumeRestoreHandler") owners := evt.ObjectNew.GetOwnerReferences() @@ -73,11 +73,11 @@ func (h VeleroPodVolumeRestoreHandler) Update(ctx context.Context, evt event.Typ } // Delete event handler -func (VeleroPodVolumeRestoreHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeRestoreHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the PodVolumeRestore object } // Generic event handler -func (VeleroPodVolumeRestoreHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroPodVolumeRestoreHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the PodVolumeRestore object } diff --git a/internal/handler/velerorestore_handler.go b/internal/handler/velerorestore_handler.go index f14ce6e0..515de660 100644 --- a/internal/handler/velerorestore_handler.go +++ b/internal/handler/velerorestore_handler.go @@ -21,7 +21,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -33,12 +32,12 @@ import ( type VeleroRestoreHandler struct{} // Create event handler -func (VeleroRestoreHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the Restore object } // Update event handler adds Velero Restore's NonAdminRestore to controller queue -func (VeleroRestoreHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroRestoreHandler") annotations := evt.ObjectNew.GetAnnotations() @@ -53,7 +52,7 @@ func (VeleroRestoreHandler) Update(ctx context.Context, evt event.TypedUpdateEve } // Delete event handler -func (VeleroRestoreHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreHandler) Delete(ctx context.Context, evt event.DeleteEvent, q workqueue.RateLimitingInterface) { logger := function.GetLogger(ctx, evt.Object, "VeleroRestoreHandler") annotations := evt.Object.GetAnnotations() @@ -68,6 +67,6 @@ func (VeleroRestoreHandler) Delete(ctx context.Context, evt event.DeleteEvent, q } // Generic event handler -func (VeleroRestoreHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the Restore object } diff --git a/internal/handler/velerorestore_queue_handler.go b/internal/handler/velerorestore_queue_handler.go index 18f2d7a8..3e709ff1 100644 --- a/internal/handler/velerorestore_queue_handler.go +++ b/internal/handler/velerorestore_queue_handler.go @@ -19,10 +19,10 @@ package handler import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/util/workqueue" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -37,12 +37,12 @@ type VeleroRestoreQueueHandler struct { } // Create event handler -func (VeleroRestoreQueueHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreQueueHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.RateLimitingInterface) { // Create event handler for the Restore object } // Update event handler adds Velero Restore's NonAdminRestore to controller queue -func (h VeleroRestoreQueueHandler) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object], q workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (h VeleroRestoreQueueHandler) Update(ctx context.Context, evt event.UpdateEvent, q workqueue.RateLimitingInterface) { // Only update to the first in the queue Velero Restore should trigger changes to the // NonAdminRestore objects. Updates to the Velero Restore 2nd and 3rd does not lower the // queue. This optimizes the number of times we need to update the NonAdminRestore objects @@ -87,11 +87,11 @@ func (h VeleroRestoreQueueHandler) Update(ctx context.Context, evt event.TypedUp } // Delete event handler -func (VeleroRestoreQueueHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreQueueHandler) Delete(_ context.Context, _ event.DeleteEvent, _ workqueue.RateLimitingInterface) { // Delete event handler for the Restore object } // Generic event handler -func (VeleroRestoreQueueHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) { +func (VeleroRestoreQueueHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue.RateLimitingInterface) { // Generic event handler for the Restore object } diff --git a/internal/predicate/composite_nabsl_predicate.go b/internal/predicate/composite_nabsl_predicate.go index 90afad82..f1b920bf 100644 --- a/internal/predicate/composite_nabsl_predicate.go +++ b/internal/predicate/composite_nabsl_predicate.go @@ -22,7 +22,6 @@ import ( velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" corev1 "k8s.io/api/core/v1" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" @@ -50,7 +49,7 @@ func (p CompositeNaBSLPredicate) Create(evt event.CreateEvent) bool { } // Update event filter accepts both NonAdminBackupStorageLocation and Velero BackupStorageLocation update events -func (p CompositeNaBSLPredicate) Update(evt event.TypedUpdateEvent[client.Object]) bool { +func (p CompositeNaBSLPredicate) Update(evt event.UpdateEvent) bool { switch evt.ObjectNew.(type) { case *nacv1alpha1.NonAdminBackupStorageLocation: return p.NonAdminBackupStorageLocationPredicate.Update(p.Context, evt) diff --git a/internal/predicate/compositebackup_predicate.go b/internal/predicate/compositebackup_predicate.go index b79ec618..1dfebe86 100644 --- a/internal/predicate/compositebackup_predicate.go +++ b/internal/predicate/compositebackup_predicate.go @@ -22,7 +22,6 @@ import ( velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" velerov2alpha1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v2alpha1" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" @@ -49,7 +48,7 @@ func (p CompositeBackupPredicate) Create(evt event.CreateEvent) bool { } // Update event filter accepts both NonAdminBackup and Velero Backup update events -func (p CompositeBackupPredicate) Update(evt event.TypedUpdateEvent[client.Object]) bool { +func (p CompositeBackupPredicate) Update(evt event.UpdateEvent) bool { switch evt.ObjectNew.(type) { case *nacv1alpha1.NonAdminBackup: return p.NonAdminBackupPredicate.Update(p.Context, evt) diff --git a/internal/predicate/compositerestore_predicate.go b/internal/predicate/compositerestore_predicate.go index 1ba5d7d8..ea2c0de9 100644 --- a/internal/predicate/compositerestore_predicate.go +++ b/internal/predicate/compositerestore_predicate.go @@ -21,7 +21,6 @@ import ( velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" velerov2alpha1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v2alpha1" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" nacv1alpha1 "github.com/migtools/oadp-non-admin/api/v1alpha1" @@ -48,7 +47,7 @@ func (p CompositeRestorePredicate) Create(evt event.CreateEvent) bool { } // Update event filter accepts both NonAdminRestore and Velero Restore update events -func (p CompositeRestorePredicate) Update(evt event.TypedUpdateEvent[client.Object]) bool { +func (p CompositeRestorePredicate) Update(evt event.UpdateEvent) bool { switch evt.ObjectNew.(type) { case *nacv1alpha1.NonAdminRestore: return p.NonAdminRestorePredicate.Update(p.Context, evt) diff --git a/internal/predicate/nonadminbackup_predicate.go b/internal/predicate/nonadminbackup_predicate.go index 0f2d277a..b06ad18e 100644 --- a/internal/predicate/nonadminbackup_predicate.go +++ b/internal/predicate/nonadminbackup_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -38,7 +37,7 @@ func (NonAdminBackupPredicate) Create(ctx context.Context, evt event.CreateEvent } // Update event filter only accepts NonAdminBackup update events that include spec change -func (NonAdminBackupPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (NonAdminBackupPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, nonAdminBackupPredicateKey) if evt.ObjectNew.GetGeneration() != evt.ObjectOld.GetGeneration() { diff --git a/internal/predicate/nonadminbackupstoragelocation_predicate.go b/internal/predicate/nonadminbackupstoragelocation_predicate.go index ad3a5e5f..d4f98e7f 100644 --- a/internal/predicate/nonadminbackupstoragelocation_predicate.go +++ b/internal/predicate/nonadminbackupstoragelocation_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -38,7 +37,7 @@ func (NonAdminBackupStorageLocationPredicate) Create(ctx context.Context, evt ev } // Update event filter only accepts NonAdminBackupStorageLocation update events that include spec change -func (NonAdminBackupStorageLocationPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (NonAdminBackupStorageLocationPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, nonAdminBackupStorageLocationPredicateKey) // spec change diff --git a/internal/predicate/nonadminbackupstoragelocationrequest_predicate.go b/internal/predicate/nonadminbackupstoragelocationrequest_predicate.go index 5e47943b..244a3b50 100644 --- a/internal/predicate/nonadminbackupstoragelocationrequest_predicate.go +++ b/internal/predicate/nonadminbackupstoragelocationrequest_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -39,7 +38,7 @@ func (NonAdminBackupStorageLocationRequestPredicate) Create(ctx context.Context, } // Update event filter only accepts NonAdminBackupStorageLocationRequest update events that include spec change -func (NonAdminBackupStorageLocationRequestPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (NonAdminBackupStorageLocationRequestPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, nonAdminBackupStorageLocationRequestPredicateKey) // spec change diff --git a/internal/predicate/nonadminrestore_predicate.go b/internal/predicate/nonadminrestore_predicate.go index af8cf454..361422ab 100644 --- a/internal/predicate/nonadminrestore_predicate.go +++ b/internal/predicate/nonadminrestore_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -38,7 +37,7 @@ func (NonAdminRestorePredicate) Create(ctx context.Context, evt event.CreateEven } // Update event filter only accepts NonAdminRestore update events that include generation change -func (NonAdminRestorePredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (NonAdminRestorePredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, nonAdminRestorePredicateKey) if evt.ObjectNew.GetGeneration() != evt.ObjectOld.GetGeneration() { diff --git a/internal/predicate/velerobackup_predicate.go b/internal/predicate/velerobackup_predicate.go index 79f11032..f3840e49 100644 --- a/internal/predicate/velerobackup_predicate.go +++ b/internal/predicate/velerobackup_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -32,7 +31,7 @@ type VeleroBackupPredicate struct { // Update event filter only accepts Velero Backup update events from OADP namespace // and from Velero Backups that have required metadata -func (p VeleroBackupPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroBackupPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroBackupPredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/velerobackup_queue_predicate.go b/internal/predicate/velerobackup_queue_predicate.go index 87efde9b..42e87173 100644 --- a/internal/predicate/velerobackup_queue_predicate.go +++ b/internal/predicate/velerobackup_queue_predicate.go @@ -20,7 +20,6 @@ import ( "context" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -35,7 +34,7 @@ type VeleroBackupQueuePredicate struct { // and from Velero Backups that have a new CompletionTimestamp. We are not interested in // checking if the Velero Backup contains NonAdminBackup metadata, because every Velero Backup // may change the Queue position of the NonAdminBackup object. -func (p VeleroBackupQueuePredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroBackupQueuePredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroBackupQueuePredicate") // Ensure the new and old objects are of the expected type diff --git a/internal/predicate/velerobackupstoragelocation_predicate.go b/internal/predicate/velerobackupstoragelocation_predicate.go index 5452a0f1..1daeccf3 100644 --- a/internal/predicate/velerobackupstoragelocation_predicate.go +++ b/internal/predicate/velerobackupstoragelocation_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -32,7 +31,7 @@ type VeleroBackupStorageLocationPredicate struct { // Update event filter only accepts Velero Backup update events from OADP namespace // and from Velero Backups that have required metadata -func (p VeleroBackupStorageLocationPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroBackupStorageLocationPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroBackupStorageLocationPredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/velerodatadownload_predicate.go b/internal/predicate/velerodatadownload_predicate.go index c9d794aa..bf71f0a5 100644 --- a/internal/predicate/velerodatadownload_predicate.go +++ b/internal/predicate/velerodatadownload_predicate.go @@ -35,7 +35,7 @@ type VeleroDataDownloadPredicate struct { // Update event filter only accepts Velero DataDownload update events from OADP namespace // and from Velero DataDownload that have required metadata -func (p VeleroDataDownloadPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroDataDownloadPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroDataDownloadPredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/velerodataupload_predicate.go b/internal/predicate/velerodataupload_predicate.go index 64f938f2..0b4a8d46 100644 --- a/internal/predicate/velerodataupload_predicate.go +++ b/internal/predicate/velerodataupload_predicate.go @@ -18,10 +18,10 @@ package predicate import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -35,7 +35,7 @@ type VeleroDataUploadPredicate struct { // Update event filter only accepts Velero DataUpload update events from OADP namespace // and from Velero DataUpload that have required metadata -func (p VeleroDataUploadPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroDataUploadPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroDataUploadPredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/veleropodvolumebackup_predicate.go b/internal/predicate/veleropodvolumebackup_predicate.go index 8328eb5b..b7f2bc63 100644 --- a/internal/predicate/veleropodvolumebackup_predicate.go +++ b/internal/predicate/veleropodvolumebackup_predicate.go @@ -18,10 +18,10 @@ package predicate import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -35,7 +35,7 @@ type VeleroPodVolumeBackupPredicate struct { // Update event filter only accepts Velero PodVolumeBackup update events from OADP namespace // and from Velero PodVolumeBackup that have required metadata -func (p VeleroPodVolumeBackupPredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroPodVolumeBackupPredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroPodVolumeBackupPredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/veleropodvolumerestore_predicate.go b/internal/predicate/veleropodvolumerestore_predicate.go index 072ac61c..5b16ead1 100644 --- a/internal/predicate/veleropodvolumerestore_predicate.go +++ b/internal/predicate/veleropodvolumerestore_predicate.go @@ -18,10 +18,10 @@ package predicate import ( "context" + "sigs.k8s.io/controller-runtime/pkg/client" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" "k8s.io/apimachinery/pkg/types" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -35,7 +35,7 @@ type VeleroPodVolumeRestorePredicate struct { // Update event filter only accepts Velero PodVolumeRestore update events from OADP namespace // and from Velero PodVolumeRestore that have required metadata -func (p VeleroPodVolumeRestorePredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroPodVolumeRestorePredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroPodVolumeRestorePredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/velerorestore_predicate.go b/internal/predicate/velerorestore_predicate.go index a12a431f..2035a6d5 100644 --- a/internal/predicate/velerorestore_predicate.go +++ b/internal/predicate/velerorestore_predicate.go @@ -19,7 +19,6 @@ package predicate import ( "context" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -32,7 +31,7 @@ type VeleroRestorePredicate struct { // Update event filter only accepts Velero Restore update events from OADP namespace // and from Velero Restores that have required metadata -func (p VeleroRestorePredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroRestorePredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroRestorePredicate") namespace := evt.ObjectNew.GetNamespace() diff --git a/internal/predicate/velerorestore_queue_predicate.go b/internal/predicate/velerorestore_queue_predicate.go index 06ef69bc..c5880b12 100644 --- a/internal/predicate/velerorestore_queue_predicate.go +++ b/internal/predicate/velerorestore_queue_predicate.go @@ -20,7 +20,6 @@ import ( "context" velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1" - "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/event" "github.com/migtools/oadp-non-admin/internal/common/function" @@ -35,7 +34,7 @@ type VeleroRestoreQueuePredicate struct { // and from Velero Restores that have a new CompletionTimestamp. We are not interested in // checking if the Velero Restore contains NonAdminRestore metadata, because every Velero Restore // may change the Queue position of the NonAdminRestore object. -func (p VeleroRestoreQueuePredicate) Update(ctx context.Context, evt event.TypedUpdateEvent[client.Object]) bool { +func (p VeleroRestoreQueuePredicate) Update(ctx context.Context, evt event.UpdateEvent) bool { logger := function.GetLogger(ctx, evt.ObjectNew, "VeleroRestoreQueuePredicate") // Ensure the new and old objects are of the expected type diff --git a/internal/source/periodical_source.go b/internal/source/periodical_source.go index b8ae1d99..11069b3a 100644 --- a/internal/source/periodical_source.go +++ b/internal/source/periodical_source.go @@ -24,7 +24,8 @@ import ( "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/workqueue" ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/reconcile" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/predicate" ) // PeriodicalSource will periodically add an empty object to controller queue @@ -33,7 +34,7 @@ type PeriodicalSource struct { } // Start periodically adds an empty object to queue -func (p PeriodicalSource) Start(ctx context.Context, q workqueue.TypedRateLimitingInterface[reconcile.Request]) error { //nolint:unparam // object must implement function with this signature +func (p PeriodicalSource) Start(ctx context.Context, h handler.EventHandler, q workqueue.RateLimitingInterface, predicates ...predicate.Predicate) error { //nolint:unparam // object must implement function with this signature go wait.Until(func() { q.Add(ctrl.Request{}) }, p.Frequency, ctx.Done())