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)
}
func (s *notifyWorkerSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.actor = &actionsHandler{
actions: nil,
handled: make(chan struct{}, 1),
description: "test action handler",
watcher: &TestWatcher{
changes: make(chan struct{}),
},
}
s.worker = worker.NewNotifyWorker(s.actor)
}
func (s *notifyWorkerSuite) TestSetUpFailureStopsWithTearDown(c *gc.C) {
// Stop the worker and SetUp again, this time with an error
s.stopWorker(c)
actor := &actionsHandler{
actions: nil,
handled: make(chan struct{}, 1),
setupError: fmt.Errorf("my special error"),
watcher: &TestWatcher{
changes: make(chan struct{}),
},
}
w := worker.NewNotifyWorker(actor)
err := WaitShort(c, w)
c.Check(err, gc.ErrorMatches, "my special error")
actor.CheckActions(c, "setup", "teardown")
c.Check(actor.watcher.stopped, jc.IsTrue)
}
func (s *notifyWorkerSuite) TestHandleErrorStopsWorkerAndWatcher(c *gc.C) {
s.stopWorker(c)
actor := &actionsHandler{
actions: nil,
handled: make(chan struct{}, 1),
handlerError: fmt.Errorf("my handling error"),
watcher: &TestWatcher{
changes: make(chan struct{}),
},
}
w := worker.NewNotifyWorker(actor)
actor.watcher.TriggerChange(c)
WaitForHandled(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)
}
// NewMachiner returns a Machiner 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, tag string) worker.NotifyWorker {
mr := &Machiner{st: st, tag: tag}
return worker.NewNotifyWorker(mr)
}
// NewCleaner returns a worker.NotifyWorker that runs state.Cleanup()
// if the CleanupWatcher signals documents marked for deletion.
func NewCleaner(st *state.State) worker.NotifyWorker {
return worker.NewNotifyWorker(&Cleaner{st: st})
}
// NewMachiner returns a Machiner 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 *state.State, id string) worker.NotifyWorker {
mr := &Machiner{st: st, id: id}
return worker.NewNotifyWorker(mr)
}
