// 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})
}