func (s *stringsWorkerSuite) TestStop(c *gc.C) {
err := worker.Stop(s.worker)
c.Assert(err, gc.IsNil)
// After stop, Wait should return right away
err = waitShort(c, s.worker)
c.Assert(err, gc.IsNil)
}
func (*runnerSuite) TestOneWorkerStartWhenStopping(c *C) {
worker.RestartDelay = 3 * time.Second
runner := worker.NewRunner(allFatal, noImportance)
starter := newTestWorkerStarter()
starter.stopWait = make(chan struct{})
err := runner.StartWorker("id", testWorkerStart(starter))
c.Assert(err, IsNil)
starter.assertStarted(c, true)
err = runner.StopWorker("id")
c.Assert(err, IsNil)
err = runner.StartWorker("id", testWorkerStart(starter))
c.Assert(err, IsNil)
close(starter.stopWait)
starter.assertStarted(c, false)
// Check that the task is restarted immediately without
// the usual restart timeout delay.
t0 := time.Now()
starter.assertStarted(c, true)
restartDuration := time.Since(t0)
if restartDuration > 1*time.Second {
c.Fatalf("task did not restart immediately")
}
c.Assert(worker.Stop(runner), IsNil)
}
func (s *MachinerSuite) TestSetDead(c *C) {
mr := machiner.NewMachiner(s.machinerState, s.machine.Tag())
defer worker.Stop(mr)
c.Assert(s.machine.Destroy(), IsNil)
s.State.StartSync()
c.Assert(mr.Wait(), Equals, worker.ErrTerminateAgent)
c.Assert(s.machine.Refresh(), IsNil)
c.Assert(s.machine.Life(), Equals, state.Dead)
}
func (*runnerSuite) TestOneWorkerStart(c *C) {
runner := worker.NewRunner(noneFatal, noImportance)
starter := newTestWorkerStarter()
err := runner.StartWorker("id", testWorkerStart(starter))
c.Assert(err, IsNil)
starter.assertStarted(c, true)
c.Assert(worker.Stop(runner), IsNil)
starter.assertStarted(c, false)
}
func (s *MachinerSuite) TestStartSetsStatus(c *C) {
status, info, err := s.machine.Status()
c.Assert(err, IsNil)
c.Assert(status, Equals, params.StatusPending)
c.Assert(info, Equals, "")
mr := machiner.NewMachiner(s.machinerState, s.apiMachine.Tag())
defer worker.Stop(mr)
s.waitMachineStatus(c, s.machine, params.StatusStarted)
}
// During teardown we try to stop the worker, but don't hang the test suite if
// Stop never returns
func (s *stringsWorkerSuite) stopWorker(c *gc.C) {
if s.worker == nil {
return
}
done := make(chan error)
go func() {
done <- worker.Stop(s.worker)
}()
err := waitForTimeout(c, done, coretesting.LongWait)
c.Check(err, gc.IsNil)
s.actor = nil
s.worker = nil
}
func (s *stringsWorkerSuite) TestChangesTriggerHandler(c *gc.C) {
s.actor.CheckActions(c, "setup")
s.actor.watcher.TriggerChange(c, []string{"aa", "bb"})
waitForHandledStrings(c, s.actor.handled, []string{"aa", "bb"})
s.actor.CheckActions(c, "setup", "handler")
s.actor.watcher.TriggerChange(c, []string{"cc", "dd"})
waitForHandledStrings(c, s.actor.handled, []string{"cc", "dd"})
s.actor.watcher.TriggerChange(c, []string{"ee", "ff"})
waitForHandledStrings(c, s.actor.handled, []string{"ee", "ff"})
s.actor.CheckActions(c, "setup", "handler", "handler", "handler")
c.Assert(worker.Stop(s.worker), gc.IsNil)
s.actor.CheckActions(c, "setup", "handler", "handler", "handler", "teardown")
}
func (s *notifyWorkerSuite) TestChangesTriggerHandler(c *gc.C) {
s.actor.CheckActions(c, "setup")
s.actor.watcher.TriggerChange(c)
waitForHandledNotify(c, s.actor.handled)
s.actor.CheckActions(c, "setup", "handler")
s.actor.watcher.TriggerChange(c)
waitForHandledNotify(c, s.actor.handled)
s.actor.watcher.TriggerChange(c)
waitForHandledNotify(c, s.actor.handled)
s.actor.CheckActions(c, "setup", "handler", "handler", "handler")
c.Assert(worker.Stop(s.worker), gc.IsNil)
s.actor.CheckActions(c, "setup", "handler", "handler", "handler", "teardown")
}
func (s *CleanerSuite) TestCleaner(c *C) {
cr := cleaner.NewCleaner(s.State)
defer func() { c.Assert(worker.Stop(cr), IsNil) }()
needed, err := s.State.NeedsCleanup()
c.Assert(err, IsNil)
c.Assert(needed, Equals, false)
_, err = s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
c.Assert(err, IsNil)
_, err = s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
c.Assert(err, IsNil)
eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
c.Assert(err, IsNil)
relM, err := s.State.AddRelation(eps...)
c.Assert(err, IsNil)
needed, err = s.State.NeedsCleanup()
c.Assert(err, IsNil)
c.Assert(needed, Equals, false)
// Observe destroying of the relation with a watcher.
cw := s.State.WatchCleanups()
defer func() { c.Assert(cw.Stop(), IsNil) }()
err = relM.Destroy()
c.Assert(err, IsNil)
timeout := time.After(coretesting.LongWait)
for {
s.State.StartSync()
select {
case <-time.After(coretesting.ShortWait):
continue
case <-timeout:
c.Fatalf("timed out waiting for cleanup")
case <-cw.Changes():
needed, err = s.State.NeedsCleanup()
c.Assert(err, IsNil)
if needed {
continue
}
}
break
}
}
func (*runnerSuite) TestOneWorkerRestart(c *C) {
runner := worker.NewRunner(noneFatal, noImportance)
starter := newTestWorkerStarter()
err := runner.StartWorker("id", testWorkerStart(starter))
c.Assert(err, IsNil)
starter.assertStarted(c, true)
// Check it restarts a few times time.
for i := 0; i < 3; i++ {
starter.die <- fmt.Errorf("an error")
starter.assertStarted(c, false)
starter.assertStarted(c, true)
}
c.Assert(worker.Stop(runner), IsNil)
starter.assertStarted(c, false)
}
func (s *minUnitsWorkerSuite) TestMinUnitsWorker(c *gc.C) {
mu := minunitsworker.NewMinUnitsWorker(s.State)
defer func() { c.Assert(worker.Stop(mu), gc.IsNil) }()
// Set up services and units for later use.
wordpress, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
c.Assert(err, gc.IsNil)
mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
c.Assert(err, gc.IsNil)
unit, err := wordpress.AddUnit()
c.Assert(err, gc.IsNil)
_, err = wordpress.AddUnit()
c.Assert(err, gc.IsNil)
// Set up minimum units for services.
err = wordpress.SetMinUnits(3)
c.Assert(err, gc.IsNil)
err = mysql.SetMinUnits(2)
c.Assert(err, gc.IsNil)
// Remove a unit for a service.
err = unit.Destroy()
c.Assert(err, gc.IsNil)
timeout := time.After(coretesting.LongWait)
for {
s.State.StartSync()
select {
case <-time.After(coretesting.ShortWait):
wordpressUnits, err := wordpress.AllUnits()
c.Assert(err, gc.IsNil)
mysqlUnits, err := mysql.AllUnits()
c.Assert(err, gc.IsNil)
wordpressCount := len(wordpressUnits)
mysqlCount := len(mysqlUnits)
if wordpressCount == 3 && mysqlCount == 2 {
return
}
logger.Infof("wordpress units: %d; mysql units: %d", wordpressCount, mysqlCount)
case <-timeout:
c.Fatalf("timed out waiting for minunits events")
}
}
}
func (s *MachinerSuite) TestRunStop(c *C) {
mr := machiner.NewMachiner(s.machinerState, s.apiMachine.Tag())
c.Assert(worker.Stop(mr), IsNil)
c.Assert(s.apiMachine.Refresh(), IsNil)
c.Assert(s.apiMachine.Life(), Equals, params.Alive)
}
func (s *MachinerSuite) TestSetsStatusWhenDying(c *C) {
mr := machiner.NewMachiner(s.machinerState, s.apiMachine.Tag())
defer worker.Stop(mr)
c.Assert(s.machine.Destroy(), IsNil)
s.waitMachineStatus(c, s.machine, params.StatusStopped)
}
func (*runnerSuite) TestStopWorkerWhenDead(c *C) {
runner := worker.NewRunner(allFatal, noImportance)
c.Assert(worker.Stop(runner), IsNil)
c.Assert(runner.StopWorker("foo"), Equals, worker.ErrDead)
}