// agentDoing returns what hook or action, if any,
// the agent is currently executing.
// The hook name or action is extracted from the agent message.
func agentDoing(status statusInfoContents) string {
if status.Current != params.StatusExecuting {
return ""
}
// First see if we can determine a hook name.
var hookNames []string
for _, h := range hooks.UnitHooks() {
hookNames = append(hookNames, string(h))
}
for _, h := range hooks.RelationHooks() {
hookNames = append(hookNames, string(h))
}
hookExp := regexp.MustCompile(fmt.Sprintf(`running (?P<hook>%s?) hook`, strings.Join(hookNames, "|")))
match := hookExp.FindStringSubmatch(status.Message)
if len(match) > 0 {
return match[1]
}
// Now try for an action name.
actionExp := regexp.MustCompile(`running action (?P<action>.*)`)
match = actionExp.FindStringSubmatch(status.Message)
if len(match) > 0 {
return match[1]
}
return ""
}
func (s *RunHookSuite) TestExecuteHookWithSetStatus(c *gc.C) {
for _, kind := range hooks.UnitHooks() {
c.Logf("hook %v", kind)
s.testExecuteHookWithSetStatus(c, kind, true)
s.testExecuteHookWithSetStatus(c, kind, false)
}
}
func (c *debugHooksCommand) validateHooks() error {
if len(c.hooks) == 0 {
return nil
}
service, err := names.UnitService(c.Target)
if err != nil {
return err
}
serviceApi, err := c.getServiceAPI()
if err != nil {
return err
}
relations, err := serviceApi.CharmRelations(service)
if err != nil {
return err
}
validHooks := make(map[string]bool)
for _, hook := range hooks.UnitHooks() {
validHooks[string(hook)] = true
}
for _, relation := range relations {
for _, hook := range hooks.RelationHooks() {
hook := fmt.Sprintf("%s-%s", relation, hook)
validHooks[hook] = true
}
}
for _, hook := range c.hooks {
if !validHooks[hook] {
names := make([]string, 0, len(validHooks))
for hookName := range validHooks {
names = append(names, hookName)
}
sort.Strings(names)
logger.Infof("unknown hook %s, valid hook names: %v", hook, names)
return fmt.Errorf("unit %q does not contain hook %q", c.Target, hook)
}
}
return nil
}
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)
}
}
func (s *RunHookSuite) TestBeforeHookStatus(c *gc.C) {
for _, kind := range hooks.UnitHooks() {
c.Logf("hook %v", kind)
s.testBeforeHookExecute(c, (operation.Factory).NewRunHook, kind)
}
}
