// Stop any running monitors.
	qm.monitorLock.Lock()
	defer qm.monitorLock.Unlock()
	monitors := qm.monitors
	stopped := 0
	for _, monitor := range monitors {
		if monitor.stopCh != nil {
			stopped++
			close(monitor.stopCh)
		}
	}
	logger.Info("QuotaMonitor stopped monitors", "stopped", stopped, "total", len(monitors))
}

	<-gb.informersStarted

	monitors := gb.monitors
	started := 0
	for _, monitor := range monitors {
		if monitor.stopCh == nil {
			monitor.stopCh = make(chan struct{})
			gb.sharedInformers.Start(gb.stopCh)
			go monitor.Run()
			started++
		}
	}
	logger.V(4).Info("started new monitors", "new", started, "current", len(monitors))
}

	return nil
}

func monitorGetter(factory serverstorage.StorageFactory) func() (monitors []metrics.Monitor, err error) {
	return func() (monitors []metrics.Monitor, err error) {
		defer func() {
			if err != nil {
				for _, m := range monitors {
					m.Close()
				}
			}
		}()

		var m metrics.Monitor
		for _, cfg := range factory.Configs() {
			m, err = storagefactory.CreateMonitor(cfg)

	// knows how to calculate usage
	registry quota.Registry
	// knows how to monitor all the resources tracked by quota and trigger replenishment
	quotaMonitor *QuotaMonitor
	// controls the workers that process quotas
	// this lock is acquired to control write access to the monitors and ensures that all
	// monitors are synced before the controller can process quotas.
	workerLock sync.RWMutex
}

	monitors, err := c.getGetter()()
	if err != nil {
		return
	}

	for i, m := range monitors {
		storageClusterID := fmt.Sprintf("etcd-%d", i)

		klog.V(4).InfoS("Start collecting storage metrics", "storage_cluster_id", storageClusterID)
		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
		metrics, err := m.Monitor(ctx)
		cancel()
		m.Close()

			// attempt.
			if err := gc.resyncMonitors(logger, newResources); err != nil {
				utilruntime.HandleError(fmt.Errorf("failed to sync resource monitors (attempt %d): %v", attempt, err))
				metrics.GarbageCollectorResourcesSyncError.Inc()
				return false, nil
			}
			logger.V(4).Info("resynced monitors")

			// wait for caches to fill for a while (our sync period) before attempting to rediscover resources and retry syncing.

          kind: kindValue
          readOnly: true
        azureFile:
          readOnly: true
          secretName: secretNameValue
          shareName: shareNameValue
        cephfs:
          monitors:
          - monitorsValue
          path: pathValue
          readOnly: true
          secretFile: secretFileValue
          secretRef:
            name: nameValue
          user: userValue

        kind: kindValue
        readOnly: true
      azureFile:
        readOnly: true
        secretName: secretNameValue
        shareName: shareNameValue
      cephfs:
        monitors:
        - monitorsValue
        path: pathValue
        readOnly: true
        secretFile: secretFileValue
        secretRef:
          name: nameValue
        user: userValue
      cinder:

          kind: kindValue
          readOnly: true
        azureFile:
          readOnly: true
          secretName: secretNameValue
          shareName: shareNameValue
        cephfs:
          monitors:
          - monitorsValue
          path: pathValue
          readOnly: true
          secretFile: secretFileValue
          secretRef:
            name: nameValue
          user: userValue

          kind: kindValue
          readOnly: true
        azureFile:
          readOnly: true
          secretName: secretNameValue
          shareName: shareNameValue
        cephfs:
          monitors:
          - monitorsValue
          path: pathValue
          readOnly: true
          secretFile: secretFileValue
          secretRef:
            name: nameValue
          user: userValue