// NewMockBaseWatcher creates a new mock instance
556963
func NewMockBaseWatcher(ctrl *gomock.Controller) *MockBaseWatcher {
	mock := &MockBaseWatcher{ctrl: ctrl}
	mock.recorder = &MockBaseWatcherMockRecorder{mock}
	return mock
}
1299438
func NewMockDeploymentInterface(ctrl *gomock.Controller) *MockDeploymentInterface {
	mock := &MockDeploymentInterface{ctrl: ctrl}
	mock.recorder = &MockDeploymentInterfaceMockRecorder{mock}
	return mock
}
1186577
func newConfigWatcher(
	keys []string, cache *hashCache, hub *pubsub.SimpleHub, topic string, res *Resident,
) *ConfigWatcher {
	sort.Strings(keys)

	w := &ConfigWatcher{
		notifyWatcherBase: newNotifyWatcherBase(),

		keys: keys,
		hash: cache.getHash(keys),
	}

	deregister := res.registerWorker(w)
	unsub := hub.Subscribe(topic, w.configChanged)
	w.tomb.Go(func() error {
		<-w.tomb.Dying()
		unsub()
		deregister()
		return nil
	})

	return w
}
796831
func NewWatcher(sessionStartTime time.Time) *Watcher {
	return &Watcher{
		sessionStartTime: sessionStartTime,
		errorChan:        make(chan *probe.Error),
		eventInfoChan:    make(chan EventInfo),
		o:                []*watchObject{},
	}
}
1340057
func NewMockProcessManager(ctrl *gomock.Controller) *MockProcessManager {
	mock := &MockProcessManager{ctrl: ctrl}
	mock.recorder = &MockProcessManagerMockRecorder{mock}
	return mock
}
433355
func NewMockScope(ctrl *gomock.Controller) *MockScope {
	mock := &MockScope{ctrl: ctrl}
	mock.recorder = &MockScopeMockRecorder{mock}
	return mock
}
1055903
func NewMockRCHTTPClienter(ctrl *gomock.Controller) *MockRCHTTPClienter {
	mock := &MockRCHTTPClienter{ctrl: ctrl}
	mock.recorder = &MockRCHTTPClienterMockRecorder{mock}
	return mock
}
835075
func NewWatcher() (*RWatcher, error) {
	fsWatch, err := fsnotify.NewWatcher()
	if err != nil {
		return nil, err
	}

	m := &RWatcher{}
	m.fsnotify = fsWatch
	m.Events = make(chan fsnotify.Event)
	m.Errors = make(chan error)
	m.done = make(chan struct{})

	go m.start()

	return m, nil
}
1066929
func (s *Wrapper) NewWatcher(ctx context.Context, watch Watch) (Watcher, error) {
	if err := s.GetReadError(); err != nil {
		return nil, trace.Wrap(err)
	}
	return s.backend.NewWatcher(ctx, watch)
}
747400
func NewMockInstanceBroker(ctrl *gomock.Controller) *MockInstanceBroker {
	mock := &MockInstanceBroker{ctrl: ctrl}
	mock.recorder = &MockInstanceBrokerMockRecorder{mock}
	return mock
}
1281636
func NewMockUnit(ctrl *gomock.Controller) *MockUnit {
	mock := &MockUnit{ctrl: ctrl}
	mock.recorder = &MockUnitMockRecorder{mock}
	return mock
}
749182
func NewMockLocker(ctrl *gomock.Controller) *MockLocker {
	mock := &MockLocker{ctrl: ctrl}
	mock.recorder = &MockLockerMockRecorder{mock}
	return mock
}
48060
func NewMockFacadeCaller(ctrl *gomock.Controller) *MockFacadeCaller {
	mock := &MockFacadeCaller{ctrl: ctrl}
	mock.recorder = &MockFacadeCallerMockRecorder{mock}
	return mock
}
111944
func NewMockCollectorReader(ctrl *gomock.Controller) *MockCollectorReader {
	mock := &MockCollectorReader{ctrl: ctrl}
	mock.recorder = &MockCollectorReaderMockRecorder{mock}
	return mock
}
980945
func (db *ProtoWrapper) NewWatcher(prefix string) keyval.ProtoWatcher {
	return &protoWatcher{db.broker.NewWatcher(prefix), db.serializer}
}
401032
func NewMockLifer(ctrl *gomock.Controller) *MockLifer {
	mock := &MockLifer{ctrl: ctrl}
	mock.recorder = &MockLiferMockRecorder{mock}
	return mock
}
828603
func (p *Plugin) NewWatcher(keyPrefix string) keyval.ProtoWatcher {
	return p.protoWrapper.NewWatcher(keyPrefix)
}