// 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 waitOnCommand(wg *sync.WaitGroup, cmd *ssh.RunningCmd, result *params.RunResult, cancel <-chan struct{}) {
defer wg.Done()
response, err := cmd.WaitWithCancel(cancel)
logger.Debugf("response from %s: %#v (err:%v)", result.MachineId, response, err)
result.ExecResponse = response
if err != nil {
result.Error = err.Error()
}
}
