func (*DebugHooksClientSuite) TestClientScript(c *gc.C) {
ctx := debug.NewHooksContext("foo/8")
// Test the variable substitutions.
result := debug.ClientScript(ctx, nil)
// No variables left behind.
c.Assert(result, gc.Not(gc.Matches), "(.|\n)*{unit_name}(.|\n)*")
c.Assert(result, gc.Not(gc.Matches), "(.|\n)*{tmux_conf}(.|\n)*")
c.Assert(result, gc.Not(gc.Matches), "(.|\n)*{entry_flock}(.|\n)*")
c.Assert(result, gc.Not(gc.Matches), "(.|\n)*{exit_flock}(.|\n)*")
// tmux new-session -d -s {unit_name}
c.Assert(result, gc.Matches, fmt.Sprintf("(.|\n)*tmux attach-session -t %s(.|\n)*", regexp.QuoteMeta(ctx.Unit)))
//) 9>{exit_flock}
c.Assert(result, gc.Matches, fmt.Sprintf("(.|\n)*\\) 9>%s(.|\n)*", regexp.QuoteMeta(ctx.ClientExitFileLock())))
//) 8>{entry_flock}
c.Assert(result, gc.Matches, fmt.Sprintf("(.|\n)*\\) 8>%s(.|\n)*", regexp.QuoteMeta(ctx.ClientFileLock())))
// nil is the same as empty slice is the same as "*".
// Also, if "*" is present as well as a named hook,
// it is equivalent to "*".
c.Assert(debug.ClientScript(ctx, nil), gc.Equals, debug.ClientScript(ctx, []string{}))
c.Assert(debug.ClientScript(ctx, []string{"*"}), gc.Equals, debug.ClientScript(ctx, nil))
c.Assert(debug.ClientScript(ctx, []string{"*", "something"}), gc.Equals, debug.ClientScript(ctx, []string{"*"}))
// debug.ClientScript does not validate hook names, as it doesn't have
// a full state API connection to determine valid relation hooks.
expected := fmt.Sprintf(
`(.|\n)*echo "aG9va3M6Ci0gc29tZXRoaW5nIHNvbWV0aGluZ2Vsc2UK" | base64 -d > %s(.|\n)*`,
regexp.QuoteMeta(ctx.ClientFileLock()),
)
c.Assert(debug.ClientScript(ctx, []string{"something somethingelse"}), gc.Matches, expected)
}
func (runner *runner) runCharmHookWithLocation(hookName, charmLocation string) error {
srv, err := runner.startJujucServer()
if err != nil {
return err
}
defer srv.Close()
env, err := runner.context.HookVars(runner.paths)
if err != nil {
return errors.Trace(err)
}
if jujuos.HostOS() == jujuos.Windows {
// TODO(fwereade): somehow consolidate with utils/exec?
// We don't do this on the other code path, which uses exec.RunCommands,
// because that already has handling for windows environment requirements.
env = mergeWindowsEnvironment(env, os.Environ())
}
debugctx := debug.NewHooksContext(runner.context.UnitName())
if session, _ := debugctx.FindSession(); session != nil && session.MatchHook(hookName) {
logger.Infof("executing %s via debug-hooks", hookName)
err = session.RunHook(hookName, runner.paths.GetCharmDir(), env)
} else {
err = runner.runCharmHook(hookName, env, charmLocation)
}
return runner.context.Flush(hookName, err)
}
// TestHooksContext tests the behaviour of HooksContext.
func (*DebugHooksCommonSuite) TestHooksContext(c *gc.C) {
ctx := debug.NewHooksContext("foo/8")
c.Assert(ctx.Unit, gc.Equals, "foo/8")
c.Assert(ctx.FlockDir, gc.Equals, "/tmp")
ctx.FlockDir = "/var/lib/juju"
c.Assert(ctx.ClientFileLock(), jc.SamePath, "/var/lib/juju/juju-unit-foo-8-debug-hooks")
c.Assert(ctx.ClientExitFileLock(), jc.SamePath, "/var/lib/juju/juju-unit-foo-8-debug-hooks-exit")
}
// Run ensures c.Target is a unit, and resolves its address,
// and connects to it via SSH to execute the debug-hooks
// script.
func (c *debugHooksCommand) Run(ctx *cmd.Context) error {
err := c.initRun()
if err != nil {
return err
}
defer c.cleanupRun()
err = c.validateHooks()
if err != nil {
return err
}
debugctx := unitdebug.NewHooksContext(c.Target)
script := base64.StdEncoding.EncodeToString([]byte(unitdebug.ClientScript(debugctx, c.hooks)))
innercmd := fmt.Sprintf(`F=$(mktemp); echo %s | base64 -d > $F; . $F`, script)
args := []string{fmt.Sprintf("sudo /bin/bash -c '%s'", innercmd)}
c.Args = args
return c.sshCommand.Run(ctx)
}
