// ParallelExecute executes all of the requests defined in the params,
// using the system identity stored in the dataDir.
func ParallelExecute(dataDir string, runParams []*RemoteExec) params.RunResults {
logger.Debugf("exec %#v", runParams)
var outstanding sync.WaitGroup
var lock sync.Mutex
var result []params.RunResult
identity := filepath.Join(dataDir, agent.SystemIdentity)
for _, param := range runParams {
outstanding.Add(1)
logger.Debugf("exec on %s: %#v", param.MachineId, *param)
param.IdentityFile = identity
go func(param *RemoteExec) {
response, err := ssh.ExecuteCommandOnMachine(param.ExecParams)
logger.Debugf("reponse from %s: %v (err:%v)", param.MachineId, response, err)
execResponse := params.RunResult{
ExecResponse: response,
MachineId: param.MachineId,
UnitId: param.UnitId,
}
if err != nil {
execResponse.Error = fmt.Sprint(err)
}
lock.Lock()
defer lock.Unlock()
result = append(result, execResponse)
outstanding.Done()
}(param)
}
outstanding.Wait()
sort.Sort(MachineOrder(result))
return params.RunResults{result}
}
func (s *ExecuteSSHCommandSuite) TestIdentityFile(c *gc.C) {
s.fakeSSH(c, echoSSH)
response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
IdentityFile: "identity-file",
Host: "hostname",
Timeout: shortWait,
})
c.Assert(err, gc.IsNil)
c.Assert(string(response.Stderr), jc.Contains, " -i identity-file ")
}
func (s *ExecuteSSHCommandSuite) TestCapturesReturnCode(c *gc.C) {
s.fakeSSH(c, passthroughSSH)
response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
IdentityFile: "identity-file",
Host: "hostname",
Command: "echo stdout; exit 42",
Timeout: shortWait,
})
c.Check(err, gc.IsNil)
c.Assert(response.Code, gc.Equals, 42)
c.Assert(string(response.Stdout), gc.Equals, "stdout\n")
c.Assert(string(response.Stderr), gc.Equals, "")
}
func (s *ExecuteSSHCommandSuite) TestTimoutCaptureOutput(c *gc.C) {
s.fakeSSH(c, slowSSH)
response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
IdentityFile: "identity-file",
Host: "hostname",
Command: "ignored",
Timeout: shortWait,
})
c.Check(err, gc.ErrorMatches, "command timed out")
c.Assert(response.Code, gc.Equals, 0)
c.Assert(string(response.Stdout), gc.Equals, "stdout\n")
c.Assert(string(response.Stderr), gc.Equals, "stderr\n")
}
func (s *ExecuteSSHCommandSuite) TestCaptureOutput(c *gc.C) {
s.fakeSSH(c, echoSSH)
response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
Host: "hostname",
Command: "sudo apt-get update\nsudo apt-get upgrade",
Timeout: shortWait,
})
c.Assert(err, gc.IsNil)
c.Assert(response.Code, gc.Equals, 0)
c.Assert(string(response.Stdout), gc.Equals, "sudo apt-get update\nsudo apt-get upgrade\n")
c.Assert(string(response.Stderr), gc.Equals,
"-o StrictHostKeyChecking no -o PasswordAuthentication no hostname /bin/bash -s\n")
}