func NewFixedWatcher(mesh *meshconfig.MeshConfig) Watcher {
	iw := internalWatcher{}
	iw.MeshConfig.Store(mesh)
	return &iw
}

// NewFileWatcher creates a new Watcher for changes to the given mesh config file. Returns an error
// if the given file does not exist or failed during parsing.
func NewFileWatcher(fileWatcher filewatcher.FileWatcher, filename string, multiWatch bool) (Watcher, error) {

	})

	go c.Run(stop)

	// Ensure the ConfigMap is initially loaded if present.
	if !client.WaitForCacheSync("configmap watcher", stop, c.HasSynced) {
		log.Error("failed to wait for cache sync")
	}
	return w
}

func AddUserMeshConfig(client kube.Client, watcher mesh.Watcher, namespace, key, userMeshConfig string, stop <-chan struct{}) {

	"istio.io/istio/pkg/kube/watcher/configmapwatcher"
	"istio.io/istio/pkg/log"
	"istio.io/istio/pkg/util/istiomultierror"
)

// Watcher watches for and reacts to injection config updates.
type Watcher interface {
	// SetHandler sets the handler that is run when the config changes.
	// Must call this before Run.
	SetHandler(func(*Config, string) error)

	// Run starts the Watcher. Must call this after SetHandler.

	}

	// Initialize watcher, fall back to no-op
	var (
		eventsCh chan fsnotify.Event
		errorCh  chan error
		watcher  watchAddRemover
	)
	if w, err := fsnotify.NewWatcher(); err != nil {
		errorHandler(fmt.Errorf("error creating file watcher, falling back to poll at interval %s: %w", pollInterval, err))
		watcher = noopWatcher{}
	} else {
		watcher = w
		eventsCh = w.Events
		errorCh = w.Errors

	id := w.watcherID
	w.watchers[id] = ch
	w.watcherID++

	return id, ch
}

// RemoveWatcher removes the given watcher.
func (w *Watcher) RemoveWatcher(id int32) {
	w.mutex.Lock()
	defer w.mutex.Unlock()
	ch := w.watchers[id]
	if ch != nil {
		close(ch)
	}
	delete(w.watchers, id)
}

// SetAndNotify sets the key cert and root cert and notify the watchers.

			}
			if len(wc.resultChan) == outgoingBufSize {
				klog.V(3).InfoS("Fast watcher, slow processing. Probably caused by slow dispatching events to watchers", "outgoingEvents", outgoingBufSize, "objectType", wc.watcher.objectType, "groupResource", wc.watcher.groupResource)
			}
			// If user couldn't receive results fast enough, we also block incoming events from watcher.
			// Because storing events in local will cause more memory usage.

John Howard <******@****.***> 1717709495 -0700

	watcher.SetAndNotify(key, cert, ca)
	select {
	case <-watch1:
		keyCertBundle := watcher.GetKeyCertBundle()
		if !bytes.Equal(keyCertBundle.KeyPem, key) || !bytes.Equal(keyCertBundle.CertPem, cert) ||
			!bytes.Equal(keyCertBundle.CABundle, ca) {
			t.Errorf("got wrong keyCertBundle %v", keyCertBundle)
		}
	default:
		t.Errorf("watcher1 watched non keyCertBundle")
	}
	select {
	case <-watch2:

        addSnapshot(snapshotRegularFile(fileInWatchableHierarchies))
        then:
        1 * watcher.startWatching({ equalIgnoringOrder(it, [probeRegistry.getProbeDirectory(file("first"))]) })
        1 * watcher.startWatching({ equalIgnoringOrder(it, [fileInWatchableHierarchies.parentFile]) })
        1 * watcher.startWatching({ equalIgnoringOrder(it, [watchableHierarchies[0]]) })
        0 * _

        when:

	// test add nested subdir inside testDriverName
	basePath := testDriverPath
	for i := 0; i < 10; i++ {
		subdirName := "subdirName"
		subdirPath := filepath.Join(basePath, subdirName)
		fs.MkdirAll(subdirPath, 0777)
		watcher.TriggerEvent(fsnotify.Create, subdirPath)
		// Assert
		assert.Equal(t, 4+i, len(watcher.watches)) // 3 + newly added