wait for informer caches to sync before running controllers

Signed-off-by: Steve Kriss <krisss@vmware.com>

pkg/cmd/server/server.go

@@ -550,9 +550,8 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 			s.veleroClient.VeleroV1(),
 			s.veleroClient.VeleroV1(),
 			s.veleroClient.VeleroV1(),
-			s.sharedInformerFactory.Velero().V1().Backups(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
-			s.sharedInformerFactory.Velero().V1().PodVolumeBackups(),
+			s.sharedInformerFactory.Velero().V1().Backups().Lister(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
 			s.config.backupSyncPeriod,
 			s.namespace,
 			s.config.defaultBackupLocation,
@@ -586,10 +585,10 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 			s.logLevel,
 			newPluginManager,
 			backupTracker,
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
 			s.config.defaultBackupLocation,
 			s.config.defaultBackupTTL,
-			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations(),
+			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations().Lister(),
 			defaultVolumeSnapshotLocations,
 			s.metrics,
 			s.config.formatFlag.Parse(),
@@ -621,9 +620,9 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 		gcController := controller.NewGCController(
 			s.logger,
 			s.sharedInformerFactory.Velero().V1().Backups(),
-			s.sharedInformerFactory.Velero().V1().DeleteBackupRequests(),
+			s.sharedInformerFactory.Velero().V1().DeleteBackupRequests().Lister(),
 			s.veleroClient.VeleroV1(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
 		)
 
 		return controllerRunInfo{
@@ -638,13 +637,13 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 			s.sharedInformerFactory.Velero().V1().DeleteBackupRequests(),
 			s.veleroClient.VeleroV1(), // deleteBackupRequestClient
 			s.veleroClient.VeleroV1(), // backupClient
-			s.sharedInformerFactory.Velero().V1().Restores(),
+			s.sharedInformerFactory.Velero().V1().Restores().Lister(),
 			s.veleroClient.VeleroV1(), // restoreClient
 			backupTracker,
 			s.resticManager,
-			s.sharedInformerFactory.Velero().V1().PodVolumeBackups(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
-			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations(),
+			s.sharedInformerFactory.Velero().V1().PodVolumeBackups().Lister(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
+			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations().Lister(),
 			newPluginManager,
 			s.metrics,
 		)
@@ -656,7 +655,6 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 	}
 
 	restoreControllerRunInfo := func() controllerRunInfo {
-
 		restorer, err := restore.NewKubernetesRestorer(
 			s.discoveryHelper,
 			client.NewDynamicFactory(s.dynamicClient),
@@ -675,9 +673,9 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 			s.veleroClient.VeleroV1(),
 			s.veleroClient.VeleroV1(),
 			restorer,
-			s.sharedInformerFactory.Velero().V1().Backups(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
-			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations(),
+			s.sharedInformerFactory.Velero().V1().Backups().Lister(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
+			s.sharedInformerFactory.Velero().V1().VolumeSnapshotLocations().Lister(),
 			s.logger,
 			s.logLevel,
 			newPluginManager,
@@ -697,7 +695,7 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 			s.logger,
 			s.sharedInformerFactory.Velero().V1().ResticRepositories(),
 			s.veleroClient.VeleroV1(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
 			s.resticManager,
 			s.config.defaultResticMaintenanceFrequency,
 		)
@@ -712,9 +710,9 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 		downloadRequestController := controller.NewDownloadRequestController(
 			s.veleroClient.VeleroV1(),
 			s.sharedInformerFactory.Velero().V1().DownloadRequests(),
-			s.sharedInformerFactory.Velero().V1().Restores(),
-			s.sharedInformerFactory.Velero().V1().BackupStorageLocations(),
-			s.sharedInformerFactory.Velero().V1().Backups(),
+			s.sharedInformerFactory.Velero().V1().Restores().Lister(),
+			s.sharedInformerFactory.Velero().V1().BackupStorageLocations().Lister(),
+			s.sharedInformerFactory.Velero().V1().Backups().Lister(),
 			newPluginManager,
 			s.logger,
 		)
@@ -771,8 +769,32 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 		}
 	}
 
+	// Instantiate the enabled controllers. This needs to be done *before*
+	// the shared informer factory is started, because the controller
+	// constructors add event handlers to various informers, which should
+	// be done before the informers are running.
+	controllers := make([]controllerRunInfo, 0, len(enabledControllers))
 	for _, newController := range enabledControllers {
-		controllerRunInfo := newController()
+		controllers = append(controllers, newController())
+	}
+
+	// start the informers & and wait for the caches to sync
+	s.sharedInformerFactory.Start(ctx.Done())
+	s.logger.Info("Waiting for informer caches to sync")
+	cacheSyncResults := s.sharedInformerFactory.WaitForCacheSync(ctx.Done())
+	s.logger.Info("Done waiting for informer caches to sync")
+
+	for informer, synced := range cacheSyncResults {
+		if !synced {
+			return errors.Errorf("cache was not synced for informer %v", informer)
+		}
+		s.logger.WithField("informer", informer).Info("Informer cache synced")
+	}
+
+	// now that the informer caches have all synced, we can start running the controllers
+	for i := range controllers {
+		controllerRunInfo := controllers[i]
+
 		wg.Add(1)
 		go func() {
 			controllerRunInfo.controller.Run(ctx, controllerRunInfo.numWorkers)
@@ -780,9 +802,6 @@ func (s *server) runControllers(defaultVolumeSnapshotLocations map[string]string
 		}()
 	}
 
-	// SHARED INFORMERS HAVE TO BE STARTED AFTER ALL CONTROLLERS
-	go s.sharedInformerFactory.Start(ctx.Done())
-
 	s.logger.Info("Server started successfully")
 
 	<-ctx.Done()

pkg/controller/backup_controller.go

@@ -40,8 +40,8 @@ import (
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/label"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
@@ -57,16 +57,16 @@ type backupController struct {
 	*genericController
 
 	backupper                pkgbackup.Backupper
-	lister                   listers.BackupLister
+	lister                   velerov1listers.BackupLister
 	client                   velerov1client.BackupsGetter
 	clock                    clock.Clock
 	backupLogLevel           logrus.Level
 	newPluginManager         func(logrus.FieldLogger) clientmgmt.Manager
 	backupTracker            BackupTracker
-	backupLocationLister     listers.BackupStorageLocationLister
+	backupLocationLister     velerov1listers.BackupStorageLocationLister
 	defaultBackupLocation    string
 	defaultBackupTTL         time.Duration
-	snapshotLocationLister   listers.VolumeSnapshotLocationLister
+	snapshotLocationLister   velerov1listers.VolumeSnapshotLocationLister
 	defaultSnapshotLocations map[string]string
 	metrics                  *metrics.ServerMetrics
 	newBackupStore           func(*velerov1api.BackupStorageLocation, persistence.ObjectStoreGetter, logrus.FieldLogger) (persistence.BackupStore, error)
@@ -74,17 +74,17 @@ type backupController struct {
 }
 
 func NewBackupController(
-	backupInformer informers.BackupInformer,
+	backupInformer velerov1informers.BackupInformer,
 	client velerov1client.BackupsGetter,
 	backupper pkgbackup.Backupper,
 	logger logrus.FieldLogger,
 	backupLogLevel logrus.Level,
 	newPluginManager func(logrus.FieldLogger) clientmgmt.Manager,
 	backupTracker BackupTracker,
-	backupLocationInformer informers.BackupStorageLocationInformer,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
 	defaultBackupLocation string,
 	defaultBackupTTL time.Duration,
-	volumeSnapshotLocationInformer informers.VolumeSnapshotLocationInformer,
+	volumeSnapshotLocationLister velerov1listers.VolumeSnapshotLocationLister,
 	defaultSnapshotLocations map[string]string,
 	metrics *metrics.ServerMetrics,
 	formatFlag logging.Format,
@@ -98,10 +98,10 @@ func NewBackupController(
 		backupLogLevel:           backupLogLevel,
 		newPluginManager:         newPluginManager,
 		backupTracker:            backupTracker,
-		backupLocationLister:     backupLocationInformer.Lister(),
+		backupLocationLister:     backupLocationLister,
 		defaultBackupLocation:    defaultBackupLocation,
 		defaultBackupTTL:         defaultBackupTTL,
-		snapshotLocationLister:   volumeSnapshotLocationInformer.Lister(),
+		snapshotLocationLister:   volumeSnapshotLocationLister,
 		defaultSnapshotLocations: defaultSnapshotLocations,
 		metrics:                  metrics,
 		formatFlag:               formatFlag,
@@ -110,11 +110,6 @@ func NewBackupController(
 	}
 
 	c.syncHandler = c.processBackup
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters,
-		backupInformer.Informer().HasSynced,
-		backupLocationInformer.Informer().HasSynced,
-		volumeSnapshotLocationInformer.Informer().HasSynced,
-	)
 	c.resyncFunc = c.resync
 	c.resyncPeriod = time.Minute
 

pkg/controller/backup_deletion_controller.go

@@ -36,8 +36,8 @@ import (
 	v1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/label"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
@@ -53,15 +53,15 @@ type backupDeletionController struct {
 	*genericController
 
 	deleteBackupRequestClient velerov1client.DeleteBackupRequestsGetter
-	deleteBackupRequestLister listers.DeleteBackupRequestLister
+	deleteBackupRequestLister velerov1listers.DeleteBackupRequestLister
 	backupClient              velerov1client.BackupsGetter
-	restoreLister             listers.RestoreLister
+	restoreLister             velerov1listers.RestoreLister
 	restoreClient             velerov1client.RestoresGetter
 	backupTracker             BackupTracker
 	resticMgr                 restic.RepositoryManager
-	podvolumeBackupLister     listers.PodVolumeBackupLister
-	backupLocationLister      listers.BackupStorageLocationLister
-	snapshotLocationLister    listers.VolumeSnapshotLocationLister
+	podvolumeBackupLister     velerov1listers.PodVolumeBackupLister
+	backupLocationLister      velerov1listers.BackupStorageLocationLister
+	snapshotLocationLister    velerov1listers.VolumeSnapshotLocationLister
 	processRequestFunc        func(*v1.DeleteBackupRequest) error
 	clock                     clock.Clock
 	newPluginManager          func(logrus.FieldLogger) clientmgmt.Manager
@@ -72,16 +72,16 @@ type backupDeletionController struct {
 // NewBackupDeletionController creates a new backup deletion controller.
 func NewBackupDeletionController(
 	logger logrus.FieldLogger,
-	deleteBackupRequestInformer informers.DeleteBackupRequestInformer,
+	deleteBackupRequestInformer velerov1informers.DeleteBackupRequestInformer,
 	deleteBackupRequestClient velerov1client.DeleteBackupRequestsGetter,
 	backupClient velerov1client.BackupsGetter,
-	restoreInformer informers.RestoreInformer,
+	restoreLister velerov1listers.RestoreLister,
 	restoreClient velerov1client.RestoresGetter,
 	backupTracker BackupTracker,
 	resticMgr restic.RepositoryManager,
-	podvolumeBackupInformer informers.PodVolumeBackupInformer,
-	backupLocationInformer informers.BackupStorageLocationInformer,
-	snapshotLocationInformer informers.VolumeSnapshotLocationInformer,
+	podvolumeBackupLister velerov1listers.PodVolumeBackupLister,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
+	snapshotLocationLister velerov1listers.VolumeSnapshotLocationLister,
 	newPluginManager func(logrus.FieldLogger) clientmgmt.Manager,
 	metrics *metrics.ServerMetrics,
 ) Interface {
@@ -90,13 +90,13 @@ func NewBackupDeletionController(
 		deleteBackupRequestClient: deleteBackupRequestClient,
 		deleteBackupRequestLister: deleteBackupRequestInformer.Lister(),
 		backupClient:              backupClient,
-		restoreLister:             restoreInformer.Lister(),
+		restoreLister:             restoreLister,
 		restoreClient:             restoreClient,
 		backupTracker:             backupTracker,
 		resticMgr:                 resticMgr,
-		podvolumeBackupLister:     podvolumeBackupInformer.Lister(),
-		backupLocationLister:      backupLocationInformer.Lister(),
-		snapshotLocationLister:    snapshotLocationInformer.Lister(),
+		podvolumeBackupLister:     podvolumeBackupLister,
+		backupLocationLister:      backupLocationLister,
+		snapshotLocationLister:    snapshotLocationLister,
 		metrics:                   metrics,
 		// use variables to refer to these functions so they can be
 		// replaced with fakes for testing.
@@ -107,14 +107,6 @@ func NewBackupDeletionController(
 	}
 
 	c.syncHandler = c.processQueueItem
-	c.cacheSyncWaiters = append(
-		c.cacheSyncWaiters,
-		deleteBackupRequestInformer.Informer().HasSynced,
-		restoreInformer.Informer().HasSynced,
-		podvolumeBackupInformer.Informer().HasSynced,
-		backupLocationInformer.Informer().HasSynced,
-		snapshotLocationInformer.Informer().HasSynced,
-	)
 	c.processRequestFunc = c.processRequest
 
 	deleteBackupRequestInformer.Informer().AddEventHandler(
@@ -383,7 +375,7 @@ func (c *backupDeletionController) processRequest(req *v1.DeleteBackupRequest) e
 
 func volumeSnapshotterForSnapshotLocation(
 	namespace, snapshotLocationName string,
-	snapshotLocationLister listers.VolumeSnapshotLocationLister,
+	snapshotLocationLister velerov1listers.VolumeSnapshotLocationLister,
 	pluginManager clientmgmt.Manager,
 ) (velero.VolumeSnapshotter, error) {
 	snapshotLocation, err := snapshotLocationLister.VolumeSnapshotLocations(namespace).Get(snapshotLocationName)

pkg/controller/backup_deletion_controller_test.go

@@ -55,13 +55,13 @@ func TestBackupDeletionControllerProcessQueueItem(t *testing.T) {
 		sharedInformers.Velero().V1().DeleteBackupRequests(),
 		client.VeleroV1(), // deleteBackupRequestClient
 		client.VeleroV1(), // backupClient
-		sharedInformers.Velero().V1().Restores(),
+		sharedInformers.Velero().V1().Restores().Lister(),
 		client.VeleroV1(), // restoreClient
 		NewBackupTracker(),
 		nil, // restic repository manager
-		sharedInformers.Velero().V1().PodVolumeBackups(),
-		sharedInformers.Velero().V1().BackupStorageLocations(),
-		sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+		sharedInformers.Velero().V1().PodVolumeBackups().Lister(),
+		sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+		sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 		nil, // new plugin manager func
 		metrics.NewServerMetrics(),
 	).(*backupDeletionController)
@@ -145,13 +145,13 @@ func setupBackupDeletionControllerTest(objects ...runtime.Object) *backupDeletio
 			sharedInformers.Velero().V1().DeleteBackupRequests(),
 			client.VeleroV1(), // deleteBackupRequestClient
 			client.VeleroV1(), // backupClient
-			sharedInformers.Velero().V1().Restores(),
+			sharedInformers.Velero().V1().Restores().Lister(),
 			client.VeleroV1(), // restoreClient
 			NewBackupTracker(),
 			nil, // restic repository manager
-			sharedInformers.Velero().V1().PodVolumeBackups(),
-			sharedInformers.Velero().V1().BackupStorageLocations(),
-			sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+			sharedInformers.Velero().V1().PodVolumeBackups().Lister(),
+			sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+			sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 			func(logrus.FieldLogger) clientmgmt.Manager { return pluginManager },
 			metrics.NewServerMetrics(),
 		).(*backupDeletionController),
@@ -843,13 +843,13 @@ func TestBackupDeletionControllerDeleteExpiredRequests(t *testing.T) {
 				sharedInformers.Velero().V1().DeleteBackupRequests(),
 				client.VeleroV1(), // deleteBackupRequestClient
 				client.VeleroV1(), // backupClient
-				sharedInformers.Velero().V1().Restores(),
+				sharedInformers.Velero().V1().Restores().Lister(),
 				client.VeleroV1(), // restoreClient
 				NewBackupTracker(),
 				nil,
-				sharedInformers.Velero().V1().PodVolumeBackups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+				sharedInformers.Velero().V1().PodVolumeBackups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+				sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 				nil, // new plugin manager func
 				metrics.NewServerMetrics(),
 			).(*backupDeletionController)

pkg/controller/backup_sync_controller.go

@@ -26,12 +26,10 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/client-go/tools/cache"
 
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/label"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt"
@@ -43,9 +41,8 @@ type backupSyncController struct {
 	backupClient                velerov1client.BackupsGetter
 	backupLocationClient        velerov1client.BackupStorageLocationsGetter
 	podVolumeBackupClient       velerov1client.PodVolumeBackupsGetter
-	backupLister                listers.BackupLister
-	backupStorageLocationLister listers.BackupStorageLocationLister
-	podVolumeBackupLister       listers.PodVolumeBackupLister
+	backupLister                velerov1listers.BackupLister
+	backupStorageLocationLister velerov1listers.BackupStorageLocationLister
 	namespace                   string
 	defaultBackupLocation       string
 	defaultBackupSyncPeriod     time.Duration
@@ -57,9 +54,8 @@ func NewBackupSyncController(
 	backupClient velerov1client.BackupsGetter,
 	backupLocationClient velerov1client.BackupStorageLocationsGetter,
 	podVolumeBackupClient velerov1client.PodVolumeBackupsGetter,
-	backupInformer informers.BackupInformer,
-	backupStorageLocationInformer informers.BackupStorageLocationInformer,
-	podVolumeBackupInformer informers.PodVolumeBackupInformer,
+	backupLister velerov1listers.BackupLister,
+	backupStorageLocationLister velerov1listers.BackupStorageLocationLister,
 	syncPeriod time.Duration,
 	namespace string,
 	defaultBackupLocation string,
@@ -79,9 +75,8 @@ func NewBackupSyncController(
 		namespace:                   namespace,
 		defaultBackupLocation:       defaultBackupLocation,
 		defaultBackupSyncPeriod:     syncPeriod,
-		backupLister:                backupInformer.Lister(),
-		backupStorageLocationLister: backupStorageLocationInformer.Lister(),
-		podVolumeBackupLister:       podVolumeBackupInformer.Lister(),
+		backupLister:                backupLister,
+		backupStorageLocationLister: backupStorageLocationLister,
 
 		// use variables to refer to these functions so they can be
 		// replaced with fakes for testing.
@@ -91,10 +86,6 @@ func NewBackupSyncController(
 
 	c.resyncFunc = c.run
 	c.resyncPeriod = 30 * time.Second
-	c.cacheSyncWaiters = []cache.InformerSynced{
-		backupInformer.Informer().HasSynced,
-		backupStorageLocationInformer.Informer().HasSynced,
-	}
 
 	return c
 }

pkg/controller/backup_sync_controller_test.go

@@ -341,9 +341,8 @@ func TestBackupSyncControllerRun(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				client.VeleroV1(),
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().PodVolumeBackups(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 				time.Duration(0),
 				test.namespace,
 				"",
@@ -565,9 +564,8 @@ func TestDeleteOrphanedBackups(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				client.VeleroV1(),
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().PodVolumeBackups(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 				time.Duration(0),
 				test.namespace,
 				"",
@@ -657,9 +655,8 @@ func TestStorageLabelsInDeleteOrphanedBackups(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				client.VeleroV1(),
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().PodVolumeBackups(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 				time.Duration(0),
 				test.namespace,
 				"",

pkg/controller/download_request_controller.go

@@ -32,8 +32,8 @@ import (
 
 	v1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt"
 	"github.com/vmware-tanzu/velero/pkg/util/kube"
@@ -43,11 +43,11 @@ type downloadRequestController struct {
 	*genericController
 
 	downloadRequestClient velerov1client.DownloadRequestsGetter
-	downloadRequestLister listers.DownloadRequestLister
-	restoreLister         listers.RestoreLister
+	downloadRequestLister velerov1listers.DownloadRequestLister
+	restoreLister         velerov1listers.RestoreLister
 	clock                 clock.Clock
-	backupLocationLister  listers.BackupStorageLocationLister
-	backupLister          listers.BackupLister
+	backupLocationLister  velerov1listers.BackupStorageLocationLister
+	backupLister          velerov1listers.BackupLister
 	newPluginManager      func(logrus.FieldLogger) clientmgmt.Manager
 	newBackupStore        func(*v1.BackupStorageLocation, persistence.ObjectStoreGetter, logrus.FieldLogger) (persistence.BackupStore, error)
 }
@@ -55,10 +55,10 @@ type downloadRequestController struct {
 // NewDownloadRequestController creates a new DownloadRequestController.
 func NewDownloadRequestController(
 	downloadRequestClient velerov1client.DownloadRequestsGetter,
-	downloadRequestInformer informers.DownloadRequestInformer,
-	restoreInformer informers.RestoreInformer,
-	backupLocationInformer informers.BackupStorageLocationInformer,
-	backupInformer informers.BackupInformer,
+	downloadRequestInformer velerov1informers.DownloadRequestInformer,
+	restoreLister velerov1listers.RestoreLister,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
+	backupLister velerov1listers.BackupLister,
 	newPluginManager func(logrus.FieldLogger) clientmgmt.Manager,
 	logger logrus.FieldLogger,
 ) Interface {
@@ -66,9 +66,9 @@ func NewDownloadRequestController(
 		genericController:     newGenericController("downloadrequest", logger),
 		downloadRequestClient: downloadRequestClient,
 		downloadRequestLister: downloadRequestInformer.Lister(),
-		restoreLister:         restoreInformer.Lister(),
-		backupLocationLister:  backupLocationInformer.Lister(),
-		backupLister:          backupInformer.Lister(),
+		restoreLister:         restoreLister,
+		backupLocationLister:  backupLocationLister,
+		backupLister:          backupLister,
 
 		// use variables to refer to these functions so they can be
 		// replaced with fakes for testing.
@@ -79,13 +79,6 @@ func NewDownloadRequestController(
 	}
 
 	c.syncHandler = c.processDownloadRequest
-	c.cacheSyncWaiters = append(
-		c.cacheSyncWaiters,
-		downloadRequestInformer.Informer().HasSynced,
-		restoreInformer.Informer().HasSynced,
-		backupLocationInformer.Informer().HasSynced,
-		backupInformer.Informer().HasSynced,
-	)
 
 	downloadRequestInformer.Informer().AddEventHandler(
 		cache.ResourceEventHandlerFuncs{

pkg/controller/download_request_controller_test.go

@@ -57,9 +57,9 @@ func newDownloadRequestTestHarness(t *testing.T) *downloadRequestTestHarness {
 		controller      = NewDownloadRequestController(
 			client.VeleroV1(),
 			informerFactory.Velero().V1().DownloadRequests(),
-			informerFactory.Velero().V1().Restores(),
-			informerFactory.Velero().V1().BackupStorageLocations(),
-			informerFactory.Velero().V1().Backups(),
+			informerFactory.Velero().V1().Restores().Lister(),
+			informerFactory.Velero().V1().BackupStorageLocations().Lister(),
+			informerFactory.Velero().V1().Backups().Lister(),
 			func(logrus.FieldLogger) clientmgmt.Manager { return pluginManager },
 			velerotest.NewLogger(),
 		).(*downloadRequestController)

pkg/controller/gc_controller.go

@@ -29,8 +29,8 @@ import (
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/label"
 )
 
@@ -42,10 +42,10 @@ const (
 type gcController struct {
 	*genericController
 
-	backupLister              listers.BackupLister
-	deleteBackupRequestLister listers.DeleteBackupRequestLister
+	backupLister              velerov1listers.BackupLister
+	deleteBackupRequestLister velerov1listers.DeleteBackupRequestLister
 	deleteBackupRequestClient velerov1client.DeleteBackupRequestsGetter
-	backupLocationLister      listers.BackupStorageLocationLister
+	backupLocationLister      velerov1listers.BackupStorageLocationLister
 
 	clock clock.Clock
 }
@@ -53,27 +53,21 @@ type gcController struct {
 // NewGCController constructs a new gcController.
 func NewGCController(
 	logger logrus.FieldLogger,
-	backupInformer informers.BackupInformer,
-	deleteBackupRequestInformer informers.DeleteBackupRequestInformer,
+	backupInformer velerov1informers.BackupInformer,
+	deleteBackupRequestLister velerov1listers.DeleteBackupRequestLister,
 	deleteBackupRequestClient velerov1client.DeleteBackupRequestsGetter,
-	backupLocationInformer informers.BackupStorageLocationInformer,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
 ) Interface {
 	c := &gcController{
 		genericController:         newGenericController("gc-controller", logger),
 		clock:                     clock.RealClock{},
 		backupLister:              backupInformer.Lister(),
-		deleteBackupRequestLister: deleteBackupRequestInformer.Lister(),
+		deleteBackupRequestLister: deleteBackupRequestLister,
 		deleteBackupRequestClient: deleteBackupRequestClient,
-		backupLocationLister:      backupLocationInformer.Lister(),
+		backupLocationLister:      backupLocationLister,
 	}
 
 	c.syncHandler = c.processQueueItem
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters,
-		backupInformer.Informer().HasSynced,
-		deleteBackupRequestInformer.Informer().HasSynced,
-		backupLocationInformer.Informer().HasSynced,
-	)
-
 	c.resyncPeriod = GCSyncPeriod
 	c.resyncFunc = c.enqueueAllBackups
 

pkg/controller/gc_controller_test.go

@@ -48,15 +48,12 @@ func TestGCControllerEnqueueAllBackups(t *testing.T) {
 		controller = NewGCController(
 			velerotest.NewLogger(),
 			sharedInformers.Velero().V1().Backups(),
-			sharedInformers.Velero().V1().DeleteBackupRequests(),
+			sharedInformers.Velero().V1().DeleteBackupRequests().Lister(),
 			client.VeleroV1(),
-			sharedInformers.Velero().V1().BackupStorageLocations(),
+			sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 		).(*gcController)
 	)
 
-	// Have to clear this out so the controller doesn't wait
-	controller.cacheSyncWaiters = nil
-
 	keys := make(chan string)
 
 	controller.syncHandler = func(key string) error {
@@ -112,9 +109,9 @@ func TestGCControllerHasUpdateFunc(t *testing.T) {
 	controller := NewGCController(
 		velerotest.NewLogger(),
 		sharedInformers.Velero().V1().Backups(),
-		sharedInformers.Velero().V1().DeleteBackupRequests(),
+		sharedInformers.Velero().V1().DeleteBackupRequests().Lister(),
 		client.VeleroV1(),
-		sharedInformers.Velero().V1().BackupStorageLocations(),
+		sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 	).(*gcController)
 
 	keys := make(chan string)
@@ -252,9 +249,9 @@ func TestGCControllerProcessQueueItem(t *testing.T) {
 			controller := NewGCController(
 				velerotest.NewLogger(),
 				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().DeleteBackupRequests(),
+				sharedInformers.Velero().V1().DeleteBackupRequests().Lister(),
 				client.VeleroV1(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
 			).(*gcController)
 			controller.clock = fakeClock
 

pkg/controller/generic_controller.go

@@ -76,11 +76,14 @@ func (c *genericController) Run(ctx context.Context, numWorkers int) error {
 	c.logger.Info("Starting controller")
 	defer c.logger.Info("Shutting down controller")
 
-	c.logger.Info("Waiting for caches to sync")
-	if !cache.WaitForCacheSync(ctx.Done(), c.cacheSyncWaiters...) {
-		return errors.New("timed out waiting for caches to sync")
+	// only want to log about cache sync waiters if there are any
+	if len(c.cacheSyncWaiters) > 0 {
+		c.logger.Info("Waiting for caches to sync")
+		if !cache.WaitForCacheSync(ctx.Done(), c.cacheSyncWaiters...) {
+			return errors.New("timed out waiting for caches to sync")
+		}
+		c.logger.Info("Caches are synced")
 	}
-	c.logger.Info("Caches are synced")
 
 	if c.syncHandler != nil {
 		wg.Add(numWorkers)

pkg/controller/restic_repository_controller.go

@@ -33,8 +33,8 @@ import (
 
 	v1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/restic"
 )
 
@@ -42,8 +42,8 @@ type resticRepositoryController struct {
 	*genericController
 
 	resticRepositoryClient      velerov1client.ResticRepositoriesGetter
-	resticRepositoryLister      listers.ResticRepositoryLister
-	backupLocationLister        listers.BackupStorageLocationLister
+	resticRepositoryLister      velerov1listers.ResticRepositoryLister
+	backupLocationLister        velerov1listers.BackupStorageLocationLister
 	repositoryManager           restic.RepositoryManager
 	defaultMaintenanceFrequency time.Duration
 
@@ -53,9 +53,9 @@ type resticRepositoryController struct {
 // NewResticRepositoryController creates a new restic repository controller.
 func NewResticRepositoryController(
 	logger logrus.FieldLogger,
-	resticRepositoryInformer informers.ResticRepositoryInformer,
+	resticRepositoryInformer velerov1informers.ResticRepositoryInformer,
 	resticRepositoryClient velerov1client.ResticRepositoriesGetter,
-	backupLocationInformer informers.BackupStorageLocationInformer,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
 	repositoryManager restic.RepositoryManager,
 	defaultMaintenanceFrequency time.Duration,
 ) Interface {
@@ -63,7 +63,7 @@ func NewResticRepositoryController(
 		genericController:           newGenericController("restic-repository", logger),
 		resticRepositoryClient:      resticRepositoryClient,
 		resticRepositoryLister:      resticRepositoryInformer.Lister(),
-		backupLocationLister:        backupLocationInformer.Lister(),
+		backupLocationLister:        backupLocationLister,
 		repositoryManager:           repositoryManager,
 		defaultMaintenanceFrequency: defaultMaintenanceFrequency,
 
@@ -76,7 +76,6 @@ func NewResticRepositoryController(
 	}
 
 	c.syncHandler = c.processQueueItem
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters, resticRepositoryInformer.Informer().HasSynced, backupLocationInformer.Informer().HasSynced)
 
 	resticRepositoryInformer.Informer().AddEventHandler(
 		cache.ResourceEventHandlerFuncs{

pkg/controller/restore_controller.go

@@ -38,8 +38,8 @@ import (
 	api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt"
@@ -78,10 +78,10 @@ type restoreController struct {
 	restoreClient          velerov1client.RestoresGetter
 	podVolumeBackupClient  velerov1client.PodVolumeBackupsGetter
 	restorer               pkgrestore.Restorer
-	backupLister           listers.BackupLister
-	restoreLister          listers.RestoreLister
-	backupLocationLister   listers.BackupStorageLocationLister
-	snapshotLocationLister listers.VolumeSnapshotLocationLister
+	backupLister           velerov1listers.BackupLister
+	restoreLister          velerov1listers.RestoreLister
+	backupLocationLister   velerov1listers.BackupStorageLocationLister
+	snapshotLocationLister velerov1listers.VolumeSnapshotLocationLister
 	restoreLogLevel        logrus.Level
 	defaultBackupLocation  string
 	metrics                *metrics.ServerMetrics
@@ -93,13 +93,13 @@ type restoreController struct {
 
 func NewRestoreController(
 	namespace string,
-	restoreInformer informers.RestoreInformer,
+	restoreInformer velerov1informers.RestoreInformer,
 	restoreClient velerov1client.RestoresGetter,
 	podVolumeBackupClient velerov1client.PodVolumeBackupsGetter,
 	restorer pkgrestore.Restorer,
-	backupInformer informers.BackupInformer,
-	backupLocationInformer informers.BackupStorageLocationInformer,
-	snapshotLocationInformer informers.VolumeSnapshotLocationInformer,
+	backupLister velerov1listers.BackupLister,
+	backupLocationLister velerov1listers.BackupStorageLocationLister,
+	snapshotLocationLister velerov1listers.VolumeSnapshotLocationLister,
 	logger logrus.FieldLogger,
 	restoreLogLevel logrus.Level,
 	newPluginManager func(logrus.FieldLogger) clientmgmt.Manager,
@@ -113,10 +113,10 @@ func NewRestoreController(
 		restoreClient:          restoreClient,
 		podVolumeBackupClient:  podVolumeBackupClient,
 		restorer:               restorer,
-		backupLister:           backupInformer.Lister(),
+		backupLister:           backupLister,
 		restoreLister:          restoreInformer.Lister(),
-		backupLocationLister:   backupLocationInformer.Lister(),
-		snapshotLocationLister: snapshotLocationInformer.Lister(),
+		backupLocationLister:   backupLocationLister,
+		snapshotLocationLister: snapshotLocationLister,
 		restoreLogLevel:        restoreLogLevel,
 		defaultBackupLocation:  defaultBackupLocation,
 		metrics:                metrics,
@@ -129,12 +129,6 @@ func NewRestoreController(
 	}
 
 	c.syncHandler = c.processQueueItem
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters,
-		backupInformer.Informer().HasSynced,
-		restoreInformer.Informer().HasSynced,
-		backupLocationInformer.Informer().HasSynced,
-		snapshotLocationInformer.Informer().HasSynced,
-	)
 	c.resyncFunc = c.resync
 	c.resyncPeriod = time.Minute
 
@@ -445,6 +439,7 @@ func (c *restoreController) runValidatedRestore(restore *api.Restore, info backu
 	defer closeAndRemoveFile(backupFile, c.logger)
 
 	opts := restic.NewPodVolumeBackupListOptions(restore.Spec.BackupName)
+
 	podVolumeBackupList, err := c.podVolumeBackupClient.PodVolumeBackups(c.namespace).List(opts)
 	if err != nil {
 		return errors.WithStack(err)

pkg/controller/restore_controller_test.go

@@ -107,9 +107,9 @@ func TestFetchBackupInfo(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				restorer,
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+				sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 				logger,
 				logrus.InfoLevel,
 				func(logrus.FieldLogger) clientmgmt.Manager { return pluginManager },
@@ -203,9 +203,9 @@ func TestProcessQueueItemSkips(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				restorer,
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+				sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 				logger,
 				logrus.InfoLevel,
 				nil,
@@ -408,9 +408,9 @@ func TestProcessQueueItem(t *testing.T) {
 				client.VeleroV1(),
 				client.VeleroV1(),
 				restorer,
-				sharedInformers.Velero().V1().Backups(),
-				sharedInformers.Velero().V1().BackupStorageLocations(),
-				sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+				sharedInformers.Velero().V1().Backups().Lister(),
+				sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+				sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 				logger,
 				logrus.InfoLevel,
 				func(logrus.FieldLogger) clientmgmt.Manager { return pluginManager },
@@ -633,9 +633,9 @@ func TestvalidateAndCompleteWhenScheduleNameSpecified(t *testing.T) {
 		client.VeleroV1(),
 		client.VeleroV1(),
 		nil,
-		sharedInformers.Velero().V1().Backups(),
-		sharedInformers.Velero().V1().BackupStorageLocations(),
-		sharedInformers.Velero().V1().VolumeSnapshotLocations(),
+		sharedInformers.Velero().V1().Backups().Lister(),
+		sharedInformers.Velero().V1().BackupStorageLocations().Lister(),
+		sharedInformers.Velero().V1().VolumeSnapshotLocations().Lister(),
 		logger,
 		logrus.DebugLevel,
 		nil,

pkg/controller/schedule_controller.go

@@ -35,8 +35,8 @@ import (
 	api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/builder"
 	velerov1client "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1"
-	informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
-	listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
+	velerov1informers "github.com/vmware-tanzu/velero/pkg/generated/informers/externalversions/velero/v1"
+	velerov1listers "github.com/vmware-tanzu/velero/pkg/generated/listers/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
 	kubeutil "github.com/vmware-tanzu/velero/pkg/util/kube"
 )
@@ -51,7 +51,7 @@ type scheduleController struct {
 	namespace       string
 	schedulesClient velerov1client.SchedulesGetter
 	backupsClient   velerov1client.BackupsGetter
-	schedulesLister listers.ScheduleLister
+	schedulesLister velerov1listers.ScheduleLister
 	clock           clock.Clock
 	metrics         *metrics.ServerMetrics
 }
@@ -60,7 +60,7 @@ func NewScheduleController(
 	namespace string,
 	schedulesClient velerov1client.SchedulesGetter,
 	backupsClient velerov1client.BackupsGetter,
-	schedulesInformer informers.ScheduleInformer,
+	schedulesInformer velerov1informers.ScheduleInformer,
 	logger logrus.FieldLogger,
 	metrics *metrics.ServerMetrics,
 ) *scheduleController {
@@ -75,7 +75,6 @@ func NewScheduleController(
 	}
 
 	c.syncHandler = c.processSchedule
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters, schedulesInformer.Informer().HasSynced)
 	c.resyncFunc = c.enqueueAllEnabledSchedules
 	c.resyncPeriod = scheduleSyncPeriod
 

pkg/controller/server_status_request_controller.go

@@ -62,8 +62,6 @@ func NewServerStatusRequestController(
 	}
 
 	c.syncHandler = c.processItem
-	c.cacheSyncWaiters = append(c.cacheSyncWaiters, informer.Informer().HasSynced)
-
 	c.resyncFunc = c.enqueueAllItems
 	c.resyncPeriod = statusRequestResyncPeriod