// NewRsyslogConfigWorker returns a worker.Worker that watches // for config changes and updates rsyslog configuration based // on changes. The worker will remove the configuration file // on teardown. func NewRsyslogConfigWorker(st *apirsyslog.State, mode RsyslogMode, tag, namespace string, stateServerAddrs []string) (worker.Worker, error) { handler, err := newRsyslogConfigHandler(st, mode, tag, namespace, stateServerAddrs) if err != nil { return nil, err } logger.Debugf("starting rsyslog worker mode %v for %q %q", mode, tag, namespace) return worker.NewNotifyWorker(handler), nil }
// NewLogger returns a worker.Worker that uses the notify watcher returned // from the setup. func NewLogger(api *logger.State, agentConfig agent.Config) worker.Worker { logger := &Logger{ api: api, agentConfig: agentConfig, lastConfig: loggo.LoggerInfo(), } log.Debugf("initial log config: %q", logger.lastConfig) return worker.NewNotifyWorker(logger) }
func (s *notifyWorkerSuite) SetUpTest(c *gc.C) { s.LoggingSuite.SetUpTest(c) s.actor = ¬ifyHandler{ actions: nil, handled: make(chan struct{}, 1), watcher: &testNotifyWatcher{ changes: make(chan struct{}), }, } s.worker = worker.NewNotifyWorker(s.actor) }
// NewMachineEnvironmentWorker returns a worker.Worker that uses the notify // watcher returned from the setup. func NewMachineEnvironmentWorker(api *environment.Facade, agentConfig agent.Config) worker.Worker { // We don't write out system files for the local provider on machine zero // as that is the host machine. writeSystemFiles := (agentConfig.Tag() != names.MachineTag("0") || agentConfig.Value(agent.ProviderType) != provider.Local) logger.Debugf("write system files: %v", writeSystemFiles) envWorker := &MachineEnvironmentWorker{ api: api, writeSystemFiles: writeSystemFiles, first: true, } return worker.NewNotifyWorker(envWorker) }
func (s *notifyWorkerSuite) TestHandleErrorStopsWorkerAndWatcher(c *gc.C) { s.stopWorker(c) actor := ¬ifyHandler{ actions: nil, handled: make(chan struct{}, 1), handlerError: fmt.Errorf("my handling error"), watcher: &testNotifyWatcher{ changes: make(chan struct{}), }, } w := worker.NewNotifyWorker(actor) actor.watcher.TriggerChange(c) waitForHandledNotify(c, actor.handled) err := waitShort(c, w) c.Check(err, gc.ErrorMatches, "my handling error") actor.CheckActions(c, "setup", "handler", "teardown") c.Check(actor.watcher.stopped, jc.IsTrue) }
func (s *notifyWorkerSuite) TestSetUpFailureStopsWithTearDown(c *gc.C) { // Stop the worker and SetUp again, this time with an error s.stopWorker(c) actor := ¬ifyHandler{ actions: nil, handled: make(chan struct{}, 1), setupError: fmt.Errorf("my special error"), watcher: &testNotifyWatcher{ changes: make(chan struct{}), }, } w := worker.NewNotifyWorker(actor) err := waitShort(c, w) c.Check(err, gc.ErrorMatches, "my special error") // TearDown is not called on SetUp error. actor.CheckActions(c, "setup") c.Check(actor.watcher.stopped, jc.IsTrue) }
// NewWorker returns a worker that keeps track of // the machine's authorised ssh keys and ensures the // ~/.ssh/authorized_keys file is up to date. func NewWorker(st *keyupdater.State, agentConfig agent.Config) worker.Worker { kw := &keyupdaterWorker{st: st, tag: agentConfig.Tag()} return worker.NewNotifyWorker(kw) }
// NewMachiner returns a Worker that will wait for the identified machine // to become Dying and make it Dead; or until the machine becomes Dead by // other means. func NewMachiner(st *machiner.State, agentConfig agent.Config) worker.Worker { mr := &Machiner{st: st, tag: agentConfig.Tag()} return worker.NewNotifyWorker(mr) }
// NewAPIAddressUpdater returns a worker.Worker that runs state.Cleanup() // if the CleanupWatcher signals documents marked for deletion. func NewAPIAddressUpdater(addresser APIAddresser, setter APIAddressSetter) worker.Worker { return worker.NewNotifyWorker(&APIAddressUpdater{ addresser: addresser, setter: setter, }) }
// NewCleaner returns a worker.Worker that runs state.Cleanup() // if the CleanupWatcher signals documents marked for deletion. func NewCleaner(st *state.State) worker.Worker { return worker.NewNotifyWorker(&Cleaner{st: st}) }