// TestMissingHookError tests that errors caused by missing hooks do not stop the worker.
func (s *IsolatedWorkerSuite) TestMissingHookError(c *gc.C) {
s.stub.SetErrors(context.NewMissingHookError("meter-status-changed"))
assertSignal(c, s.triggersCreated)
s.clk.Advance(AmberGracePeriod + time.Second)
assertSignal(c, s.hookRan)
s.stub.CheckCallNames(c, "RunHook")
}
func lookPath(hook string) (string, error) {
hookFile, err := exec.LookPath(hook)
if err != nil {
if ee, ok := err.(*exec.Error); ok && os.IsNotExist(ee.Err) {
return "", context.NewMissingHookError(hook)
}
return "", err
}
return hookFile, nil
}
// TestStatusHandlerHandlesHookMissingError tests that the handler does not report errors
// caused by a missing meter-status-changed hook.
func (s *ConnectedWorkerSuite) TestStatusHandlerHandlesHookMissingError(c *gc.C) {
s.stub.SetErrors(context.NewMissingHookError("meter-status-changed"))
handler, err := meterstatus.NewConnectedStatusHandler(
meterstatus.ConnectedConfig{
Runner: &stubRunner{stub: s.stub},
StateFile: meterstatus.NewStateFile(path.Join(s.dataDir, "meter-status.yaml")),
Status: s.msClient,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(handler, gc.NotNil)
_, err = handler.SetUp()
c.Assert(err, jc.ErrorIsNil)
err = handler.Handle(nil)
c.Assert(err, jc.ErrorIsNil)
s.stub.CheckCallNames(c, "WatchMeterStatus", "MeterStatus", "RunHook")
}
// searchHook will search, in order, hooks suffixed with extensions
// in windowsSuffixOrder. As windows cares about extensions to determine
// how to execute a file, we will allow several suffixes, with powershell
// being default.
func searchHook(charmDir, hook string) (string, error) {
hookFile := filepath.Join(charmDir, hook)
if jujuos.HostOS() != jujuos.Windows {
// we are not running on windows,
// there is no need to look for suffixed hooks
return lookPath(hookFile)
}
for _, suffix := range windowsSuffixOrder {
file := fmt.Sprintf("%s%s", hookFile, suffix)
foundHook, err := lookPath(file)
if err != nil {
if context.IsMissingHookError(err) {
// look for next suffix
continue
}
return "", err
}
return foundHook, nil
}
return "", context.NewMissingHookError(hook)
}
func (s *PatchedManifoldSuite) TestStatusWorkerHandlesHookMissingError(c *gc.C) {
s.stub.SetErrors(context.NewMissingHookError("meter-status-changed"))
getResource := dt.StubGetResource(s.dummyResources)
worker, err := s.manifold.Start(getResource)
c.Assert(err, jc.ErrorIsNil)
c.Assert(worker, gc.NotNil)
running := make(chan struct{})
meterstatus.PatchInit(worker, func() { close(running) })
select {
case <-running:
case <-time.After(coretesting.LongWait):
c.Fatal("timed out waiting for signal")
}
worker.Kill()
err = worker.Wait()
c.Assert(err, jc.ErrorIsNil)
s.stub.CheckCallNames(c, "MeterStatus", "RunHook", "WatchMeterStatus")
}
func (s *RunHookSuite) TestExecuteMissingHookError(c *gc.C) {
runErr := context.NewMissingHookError("blah-blah")
for _, kind := range hooks.UnitHooks() {
c.Logf("hook %v", kind)
op, callbacks, runnerFactory := s.getExecuteRunnerTest(c, (operation.Factory).NewRunHook, kind, runErr)
_, err := op.Prepare(operation.State{})
c.Assert(err, jc.ErrorIsNil)
newState, err := op.Execute(operation.State{})
c.Assert(err, jc.ErrorIsNil)
c.Assert(newState, gc.DeepEquals, &operation.State{
Kind: operation.RunHook,
Step: operation.Done,
Hook: &hook.Info{Kind: kind},
})
c.Assert(*runnerFactory.MockNewHookRunner.runner.MockRunHook.gotName, gc.Equals, "some-hook-name")
c.Assert(callbacks.MockNotifyHookCompleted.gotName, gc.IsNil)
c.Assert(callbacks.MockNotifyHookFailed.gotName, gc.IsNil)
status, err := runnerFactory.MockNewHookRunner.runner.Context().UnitStatus()
c.Assert(err, jc.ErrorIsNil)
testAfterHookStatus(c, kind, status, false)
}
}